crystal-lang · Aug 4, 2016 · Aug 4, 2016 · Aug 4, 2016 · Aug 4, 2016
Showing with 110 additions and 17 deletions.

+29 −0 spec/std/array_spec.cr

+7 −0 spec/std/char_spec.cr

+6 −0 src/char.cr

+55 −4 src/indexable.cr

+1 −1 src/io.cr

+11 −11 src/string.cr

+1 −1 src/uri.cr
diff --git a/spec/std/array_spec.cr b/spec/std/array_spec.cr
@@ -620,12 +620,24 @@ describe "Array" do
       a.index(4).should be_nil
     end
 
+    it "performs without a block and offset" do
+      a = [1, 2, 3, 1, 2, 3]
+      a.index(3, offset: 3).should eq(5)
+      a.index(3, offset: -3).should eq(5)
+    end
+
     it "performs with a block" do
       a = [1, 2, 3]
       a.index { |i| i > 1 }.should eq(1)
       a.index { |i| i > 3 }.should be_nil
     end
 
+    it "performs with a block and offset" do
+      a = [1, 2, 3, 1, 2, 3]
+      a.index(offset: 3) { |i| i > 1 }.should eq(4)
+      a.index(offset: -3) { |i| i > 1 }.should eq(4)
+    end
+
     it "raises if out of bounds" do
       expect_raises IndexError do
         [1, 2, 3][4]
@@ -821,11 +833,28 @@ describe "Array" do
       a.rindex(7).should be_nil
     end
 
+    it "performs without a block and an offset" do
+      a = [1, 2, 3, 4, 5, 3, 6]
+      a.rindex(3, offset: 4).should eq(2)
+      a.rindex(6, offset: 4).should be_nil
+      a.rindex(3, offset: -2).should eq(5)
+      a.rindex(3, offset: -3).should eq(2)
+      a.rindex(3, offset: -100).should be_nil
+    end
+
     it "performs with a block" do
       a = [1, 2, 3, 4, 5, 3, 6]
       a.rindex { |i| i > 1 }.should eq(6)
       a.rindex { |i| i > 6 }.should be_nil
     end
+
+    it "performs with a block and offset" do
+      a = [1, 2, 3, 4, 5, 3, 6]
+      a.rindex { |i| i > 1 }.should eq(6)
+      a.rindex { |i| i > 6 }.should be_nil
+      a.rindex(offset: 4) { |i| i == 3 }.should eq(2)
+      a.rindex(offset: -3) { |i| i == 3 }.should eq(2)
+    end
   end
 
   describe "sample" do

diff --git a/spec/std/char_spec.cr b/spec/std/char_spec.cr
@@ -344,6 +344,13 @@ describe "Char" do
     '\u0019'.control?.should be_true
   end
 
+  it "does ascii?" do
+    'a'.ascii?.should be_true
+    127.chr.ascii?.should be_true
+    128.chr.ascii?.should be_false
+    '酒'.ascii?.should be_false
+  end
+
   describe "clone" do
     assert { 'a'.clone.should eq('a') }
   end

diff --git a/src/char.cr b/src/char.cr
@@ -98,6 +98,12 @@ struct Char
     self - other
   end
 
+  # Returns `true` if this char is an ASCII character
+  # (codepoint is in (0..127))
+  def ascii?
+    ord < 128
+  end
+
   # Returns `true` if this char is an ASCII digit in specified base.
   #
   # Base can be from 0 to 36 with digits from '0' to '9' and 'a' to 'z' or 'A' to 'Z'.

diff --git a/src/indexable.cr b/src/indexable.cr
@@ -271,6 +271,34 @@ module Indexable(T)
     end
   end
 
+  # Returns the index of the first appearance of *value* in `self`
+  # starting from the given *offset*, or `nil` if the value is not in `self`.
+  #
+  # ```
+  # [1, 2, 3, 1, 2, 3].index(2, offset: 2) # => 4
+  # ```
+  def index(object, offset : Int = 0)
+    index(offset) { |e| e == object }
+  end
+
+  # Returns the index of the first object in `self` for which the block
+  # returns `true`, starting from the given *offset*, or `nil` if no match
+  # is found.
+  #
+  # ```
+  # [1, 2, 3, 1, 2, 3].rindex(offset: 4) { |x| x < 2 } # => 4
+  # ```
+  def index(offset : Int = 0)
+    offset += size if offset < 0
+
+    offset.upto(size - 1) do |i|
+      if yield unsafe_at(i)
+        return i
+      end
+    end
+    nil
+  end
+
   # Returns the last element of `self` if it's not empty, or raises `IndexError`.
   #
   # ```
@@ -314,12 +342,35 @@ module Indexable(T)
     ReverseItemIterator(self, T).new(self)
   end
 
-  def rindex(value)
-    rindex { |elem| elem == value }
+  # Returns the index of the last appearance of *value* in `self`, or
+  # `nil` if the value is not in `self`.
+  #
+  # If *offset* is given, it defines the position to _end_ the search
+  # (elements beyond this point are ignored).
+  #
+  # ```
+  # [1, 2, 3, 2, 3].rindex(2)            # => 3
+  # [1, 2, 3, 2, 3].rindex(2, offset: 2) # => 1
+  # ```
+  def rindex(value, offset = size - 1)
+    rindex(offset) { |elem| elem == value }
   end
 
-  def rindex
-    (size - 1).downto(0) do |i|
+  # Returns the index of the first object in `self` for which the block
+  # returns `true`, starting from the last object, or `nil` if no match
+  # is found.
+  #
+  # If *offset* is given, the search starts from that index towards the
+  # first elements in `self`.
+  #
+  # ```
+  # [1, 2, 3, 2, 3].rindex { |x| x < 3 }            # => 3
+  # [1, 2, 3, 2, 3].rindex(offset: 2) { |x| x < 3 } # => 1
+  # ```
+  def rindex(offset = size - 1)
+    offset += size if offset < 0
+
+    offset.downto(0) do |i|
       if yield unsafe_at(i)
         return i
       end

diff --git a/src/io.cr b/src/io.cr
@@ -588,7 +588,7 @@ module IO
 
     # # If the char's representation is a single byte and we have an encoding,
     # search the delimiter in the buffer
-    if delimiter.ord < 0x80 && (decoder = decoder())
+    if delimiter.ascii? && (decoder = decoder())
       return decoder.gets(self, delimiter.ord.to_u8, limit)
     end
 

diff --git a/src/string.cr b/src/string.cr
@@ -2075,6 +2075,11 @@ class String
   # "Hello, World".index("H", 2) # => nil
   # ```
   def index(search : Char, offset = 0)
+    # If it's ASCII we can delegate to slice
+    if search.ascii?
+      return to_slice.index(search.ord.to_u8, offset)
+    end
+
     offset += size if offset < 0
     return nil if offset < 0
 
@@ -2119,19 +2124,14 @@ class String
   # "Hello, World".rindex("H", 2) # => nil
   # ```
   def rindex(search : Char, offset = size - 1)
+    # If it's ASCII we can delegate to slice
+    if search.ascii?
+      return to_slice.rindex(search.ord.to_u8, offset)
+    end
+
     offset += size if offset < 0
     return nil if offset < 0
 
-    # If it's ASCII we can search from the end
-    if search.ord < 0x80
-      offset.downto(0) do |i|
-        if to_unsafe[i] == search.ord
-          return i
-        end
-      end
-      return nil
-    end
-
     last_index = nil
 
     each_char_with_index do |char, i|
@@ -3043,7 +3043,7 @@ class String
   def ends_with?(char : Char)
     return false unless bytesize > 0
 
-    if char.ord < 0x80 || ascii_only?
+    if char.ascii? || ascii_only?
       return to_unsafe[bytesize - 1] == char.ord
     end
 

diff --git a/src/uri.cr b/src/uri.cr
@@ -262,7 +262,7 @@ class URI
       char = byte.unsafe_chr
       if char == ' ' && space_to_plus
         io.write_byte '+'.ord.to_u8
-      elsif byte < 0x80 && yield(byte) && (!space_to_plus || char != '+')
+      elsif char.ascii? && yield(byte) && (!space_to_plus || char != '+')
         io.write_byte byte
       else
         io.write_byte '%'.ord.to_u8