motion-strscan 0.5.0

data/spec/string_spec/_shared/slice.rb

@@ -0,0 +1,244 @@
+# encoding: utf-8
+
+shared :string_slice do
+
+  it "returns the character code of the character at the given index" do
+    "hello".send(@method, 0).should == ?h
+    "hello".send(@method, -1).should == ?o
+  end
+
+  it "returns nil if index is outside of self" do
+    "hello".send(@method, 20).should == nil
+    "hello".send(@method, -20).should == nil
+
+    # TODO "".send(@method, 0).should == nil
+    "".send(@method, -1).should == nil
+  end
+
+  it "calls to_int on the given index" do
+    "hello".send(@method, 0.5).should == ?h
+
+    obj = 1.0
+    obj.respond_to?(:to_int).should == true
+    "hello".send(@method, obj).should == ?e
+  end
+
+  it "raises a TypeError if the given index is nil" do
+    lambda { "hello".send(@method, nil) }.should.raise(TypeError)
+  end
+
+  it "raises a TypeError if the given index can't be converted to an Integer" do
+    # lambda { "hello".send(@method, mock('x')) }.should.raise(TypeError)
+    lambda { "hello".send(@method, {})}.should.raise(TypeError)
+    lambda { "hello".send(@method, [])}.should.raise(TypeError)
+  end
+end
+
+
+shared :string_slice_index_length do
+  it "returns the substring starting at the given index with the given length" do
+    "hello there".send(@method, 0,0).should == ""
+    "hello there".send(@method, 0,1).should == "h"
+    "hello there".send(@method, 0,3).should == "hel"
+    "hello there".send(@method, 0,6).should == "hello "
+    "hello there".send(@method, 0,9).should == "hello the"
+    "hello there".send(@method, 0,12).should == "hello there"
+
+    "hello there".send(@method, 1,0).should == ""
+    "hello there".send(@method, 1,1).should == "e"
+    "hello there".send(@method, 1,3).should == "ell"
+    "hello there".send(@method, 1,6).should == "ello t"
+    "hello there".send(@method, 1,9).should == "ello ther"
+    "hello there".send(@method, 1,12).should == "ello there"
+
+    "hello there".send(@method, 3,0).should == ""
+    "hello there".send(@method, 3,1).should == "l"
+    "hello there".send(@method, 3,3).should == "lo "
+    "hello there".send(@method, 3,6).should == "lo the"
+    "hello there".send(@method, 3,9).should == "lo there"
+
+    "hello there".send(@method, 4,0).should == ""
+    "hello there".send(@method, 4,3).should == "o t"
+    "hello there".send(@method, 4,6).should == "o ther"
+    "hello there".send(@method, 4,9).should == "o there"
+
+    "foo".send(@method, 2,1).should == "o"
+    "foo".send(@method, 3,0).should == ""
+    "foo".send(@method, 3,1).should == ""
+
+    "".send(@method, 0,0).should == ""
+    "".send(@method, 0,1).should == ""
+
+    "x".send(@method, 0,0).should == ""
+    "x".send(@method, 0,1).should == "x"
+    "x".send(@method, 1,0).should == ""
+    "x".send(@method, 1,1).should == ""
+
+    "x".send(@method, -1,0).should == ""
+    "x".send(@method, -1,1).should == "x"
+
+    "hello there".send(@method, -3,2).should == "er"
+  end
+
+  it "always taints resulting strings when self is tainted" do
+    str = "hello world"
+    str.taint
+
+    str.send(@method, 0,0).tainted?.should == true
+    str.send(@method, 0,1).tainted?.should == true
+    str.send(@method, 2,1).tainted?.should == true
+  end
+
+  it "returns nil if the offset falls outside of self" do
+    "hello there".send(@method, 20,3).should == nil
+    "hello there".send(@method, -20,3).should == nil
+
+    "".send(@method, 1,0).should == nil
+    "".send(@method, 1,1).should == nil
+
+    "".send(@method, -1,0).should == nil
+    "".send(@method, -1,1).should == nil
+
+    "x".send(@method, 2,0).should == nil
+    "x".send(@method, 2,1).should == nil
+
+    "x".send(@method, -2,0).should == nil
+    "x".send(@method, -2,1).should == nil
+  end
+
+  it "returns nil if the length is negative" do
+    "hello there".send(@method, 4,-3).should == nil
+    "hello there".send(@method, -4,-3).should == nil
+  end
+
+  it "calls to_int on the given index and the given length" do
+    "hello".send(@method, 0.5, 1).should == "h"
+    "hello".send(@method, 0.5, 2.5).should == "he"
+    "hello".send(@method, 1, 2.5).should == "el"
+
+    # obj = mock('2')
+    # obj.should_receive(:to_int).exactly(4).times.and_return(2)
+
+    # "hello".send(@method, obj, 1).should == "l"
+    # "hello".send(@method, obj, obj).should == "ll"
+    # "hello".send(@method, 0, obj).should == "he"
+  end
+
+  it "raises a TypeError when idx or length can't be converted to an integer" do
+    lambda { "hello".send(@method, 'x', 0) }.should.raise(TypeError)
+    lambda { "hello".send(@method, 0, 'x') }.should.raise(TypeError)
+
+    # I'm deliberately including this here.
+    # It means that str.send(@method, other, idx) isn't supported.
+    lambda { "hello".send(@method, "", 0) }.should.raise(TypeError)
+  end
+
+  it "raises a TypeError when the given index or the given length is nil" do
+    lambda { "hello".send(@method, 1, nil)   }.should.raise(TypeError)
+    lambda { "hello".send(@method, nil, 1)   }.should.raise(TypeError)
+    lambda { "hello".send(@method, nil, nil) }.should.raise(TypeError)
+  end
+
+  # it "returns subclass instances" do
+  #   s = StringSpecs::MyString.new("hello")
+  #   s.send(@method, 0,0).should be_kind_of(StringSpecs::MyString)
+  #   s.send(@method, 0,4).should be_kind_of(StringSpecs::MyString)
+  #   s.send(@method, 1,4).should be_kind_of(StringSpecs::MyString)
+  # end
+end
+
+shared :string_slice_range do
+  it "returns the substring given by the offsets of the range" do
+    "hello there".send(@method, 1..1).should == "e"
+    "hello there".send(@method, 1..3).should == "ell"
+    "hello there".send(@method, 1...3).should == "el"
+    "hello there".send(@method, -4..-2).should == "her"
+    "hello there".send(@method, -4...-2).should == "he"
+    "hello there".send(@method, 5..-1).should == " there"
+    "hello there".send(@method, 5...-1).should == " ther"
+
+    "".send(@method, 0..0).should == ""
+
+    "x".send(@method, 0..0).should == "x"
+    "x".send(@method, 0..1).should == "x"
+    "x".send(@method, 0...1).should == "x"
+    "x".send(@method, 0..-1).should == "x"
+
+    "x".send(@method, 1..1).should == ""
+    "x".send(@method, 1..-1).should == ""
+  end
+
+  it "returns nil if the beginning of the range falls outside of self" do
+    "hello there".send(@method, 12..-1).should == nil
+    "hello there".send(@method, 20..25).should == nil
+    "hello there".send(@method, 20..1).should == nil
+    "hello there".send(@method, -20..1).should == nil
+    "hello there".send(@method, -20..-1).should == nil
+
+    "".send(@method, -1..-1).should == nil
+    "".send(@method, -1...-1).should == nil
+    "".send(@method, -1..0).should == nil
+    "".send(@method, -1...0).should == nil
+  end
+
+  it "returns an empty string if range.begin is inside self and > real end" do
+    "hello there".send(@method, 1...1).should == ""
+    "hello there".send(@method, 4..2).should == ""
+    "hello".send(@method, 4..-4).should == ""
+    "hello there".send(@method, -5..-6).should == ""
+    "hello there".send(@method, -2..-4).should == ""
+    "hello there".send(@method, -5..-6).should == ""
+    "hello there".send(@method, -5..2).should == ""
+
+    "".send(@method, 0...0).should == ""
+    "".send(@method, 0..-1).should == ""
+    "".send(@method, 0...-1).should == ""
+
+    "x".send(@method, 0...0).should == ""
+    "x".send(@method, 0...-1).should == ""
+    "x".send(@method, 1...1).should == ""
+    "x".send(@method, 1...-1).should == ""
+  end
+
+  it "always taints resulting strings when self is tainted" do
+    str = "hello world"
+    str.taint
+
+    str.send(@method, 0..0).tainted?.should == true
+    str.send(@method, 0...0).tainted?.should == true
+    str.send(@method, 0..1).tainted?.should == true
+    str.send(@method, 0...1).tainted?.should == true
+    str.send(@method, 2..3).tainted?.should == true
+    str.send(@method, 2..0).tainted?.should == true
+  end
+
+  # it "returns subclass instances" do
+  #   s = StringSpecs::MyString.new("hello")
+  #   s.send(@method, 0...0).should be_kind_of(StringSpecs::MyString)
+  #   s.send(@method, 0..4).should be_kind_of(StringSpecs::MyString)
+  #   s.send(@method, 1..4).should be_kind_of(StringSpecs::MyString)
+  # end
+  #
+  # it "calls to_int on range arguments" do
+  #   from = mock('from')
+  #   to = mock('to')
+  #
+  #   # So we can construct a range out of them...
+  #   from.should_receive(:<=>).twice.and_return(0)
+  #
+  #   from.should_receive(:to_int).twice.and_return(1)
+  #   to.should_receive(:to_int).twice.and_return(-2)
+  #
+  #   "hello there".send(@method, from..to).should == "ello ther"
+  #   "hello there".send(@method, from...to).should == "ello the"
+  # end
+  #
+  # it "works with Range subclasses" do
+  #   a = "GOOD"
+  #   range_incl = StringSpecs::MyRange.new(1, 2)
+  #   range_excl = StringSpecs::MyRange.new(-3, -1, true)
+  #
+  #   a.send(@method, range_incl).should == "OO"
+  #   a.send(@method, range_excl).should == "OO"
+  # end
+end

data/spec/string_spec/byteslice_spec.rb

@@ -0,0 +1,21 @@
+describe "String#byteslice" do
+  # it "needs to reviewed for spec completeness"
+
+  it_behaves_like :string_slice, :byteslice
+end
+
+describe "String#byteslice with index, length" do
+  it_behaves_like :string_slice_index_length, :byteslice
+end
+
+describe "String#byteslice with Range" do
+  it_behaves_like :string_slice_range, :byteslice
+end
+
+describe "String#byteslice on on non ASCII strings" do
+  it "returns byteslice of unicode strings" do
+    "\u3042".byteslice(1).should == "\x81".force_encoding("UTF-8")
+    "\u3042".byteslice(1, 2).should == "\x81\x82".force_encoding("UTF-8")
+    "\u3042".byteslice(1..2).should == "\x81\x82".force_encoding("UTF-8")
+  end
+end

data/spec/strscan_spec/_shared/bol.rb

@@ -0,0 +1,25 @@
+shared :strscan_bol do
+  it "returns true if the scan pointer is at the beginning of the line, false otherwise" do
+    s = StringScanner.new("This is a test")
+    s.send(@method).should.be_true
+    s.scan(/This/)
+    s.send(@method).should.be_false
+    s.terminate
+    s.send(@method).should.be_false
+
+    s = StringScanner.new("hello\nworld")
+    s.bol?.should.be_true
+    s.scan(/\w+/)
+    s.bol?.should.be_false
+    s.scan(/\n/)
+    s.bol?.should.be_true
+    s.unscan
+    s.bol?.should.be_false
+  end
+
+  it "returns true if the scan pointer is at the end of the line of an empty string." do
+    s = StringScanner.new('')
+    s.terminate
+    s.send(@method).should.be_true
+  end
+end

data/spec/strscan_spec/_shared/concat.rb

@@ -0,0 +1,31 @@
+shared :strscan_concat do
+  it "concatenates the given argument to self and returns self" do
+    s = StringScanner.new("hello ")
+    s.send(@method, 'world').should == s
+    s.string.should == "hello world"
+    s.eos?.should.be_false
+  end
+
+  it "raises a TypeError if the given argument can't be converted to a String" do
+    lambda { a = StringScanner.new('hello').send(@method, :world)    }.should.raise(TypeError)
+    # lambda { a = StringScanner.new('hello').send(@method, mock('x')) }.should.raise(TypeError)
+  end
+end
+
+shared :strscan_concat_fixnum do
+  it "raises a TypeError" do
+    a = StringScanner.new("hello world")
+    lambda { a.send(@method, 333) }.should.raise(TypeError)
+    b = StringScanner.new("")
+    lambda { b.send(@method, (256 * 3 + 64)) }.should.raise(TypeError)
+    lambda { b.send(@method, -200)           }.should.raise(TypeError)
+  end
+
+  # it "doesn't call to_int on the argument" do
+  #   x = mock('x')
+  #   x.respond_to?(:to_int).should == false
+  #
+  #   lambda { "".send(@method, x) }.should.raise(TypeError)
+  # end
+end
+

data/spec/strscan_spec/_shared/eos.rb

@@ -0,0 +1,17 @@
+shared :strscan_eos do
+  before do
+    @s = StringScanner.new("This is a test")
+  end
+
+  it "Returns true if the scan pointer is at the end of the string" do
+    @s.terminate
+    @s.send(@method).should.be_true
+
+    s = StringScanner.new('')
+    s.send(@method).should.be_true
+  end
+
+  it "Returns false if the scan pointer is not at the end of the string" do
+    @s.send(@method).should.be_false
+  end
+end

data/spec/strscan_spec/_shared/extract_range.rb

@@ -0,0 +1,22 @@
+shared :extract_range do
+  it "returns an instance of String when passed a String subclass" do
+    cls = Class.new(String)
+    sub = cls.new("abc")
+
+    s = StringScanner.new(sub)
+    ch = s.send(@method)
+    ch.should.not.be.kind_of(cls)
+    ch.should.be.an.instance_of(String)
+  end
+
+  it "taints the returned String if the input was tainted" do
+    str = 'abc'
+    str.taint
+
+    s = StringScanner.new(str)
+
+    s.send(@method).tainted?.should.be_true
+    s.send(@method).tainted?.should.be_true
+    s.send(@method).tainted?.should.be_true
+  end
+end

data/spec/strscan_spec/_shared/extract_range_matched.rb

@@ -0,0 +1,22 @@
+shared :extract_range_matched do
+  it "returns an instance of String when passed a String subclass" do
+    cls = Class.new(String)
+    sub = cls.new("abc")
+
+    s = StringScanner.new(sub)
+    s.scan(/\w{1}/)
+
+    ch = s.send(@method)
+    ch.should.not.be.kind_of(cls)
+    ch.should.be.an.instance_of(String)
+  end
+
+  it "taints the returned String if the input was tainted" do
+    str = 'abc'
+    str.taint
+
+    s = StringScanner.new(str)
+    s.scan(/\w{1}/)
+    s.send(@method).tainted?.should.be_true
+  end
+end

data/spec/strscan_spec/_shared/get_byte.rb

@@ -0,0 +1,28 @@
+shared :strscan_get_byte do
+  it "scans one byte and returns it" do
+    s = StringScanner.new('abc5.')
+    s.send(@method).should == 'a'
+    s.send(@method).should == 'b'
+    s.send(@method).should == 'c'
+    s.send(@method).should == '5'
+    s.send(@method).should == '.'
+  end
+
+  it "is not multi-byte character sensitive" do
+    s = StringScanner.new("\244\242")
+    s.send(@method).should == "\244"
+    s.send(@method).should == "\242"
+  end
+
+  it "returns nil at the end of the string" do
+    # empty string case
+    s = StringScanner.new('')
+    s.send(@method).should == nil
+    s.send(@method).should == nil
+
+    # non-empty string case
+    s = StringScanner.new('a')
+    s.send(@method) # skip one
+    s.send(@method).should == nil
+  end
+end

data/spec/strscan_spec/_shared/matched_size.rb

@@ -0,0 +1,21 @@
+shared :strscan_matched_size do
+  before do
+    @s = StringScanner.new("This is a test")
+  end
+
+ it "returns the size of the most recent match" do
+    @s.check /This/
+    @s.send(@method).should == 4
+    @s.send(@method).should == 4
+    @s.scan //
+    @s.send(@method).should == 0
+  end
+
+  it "returns nil if there was no recent match" do
+    @s.send(@method).should == nil
+    @s.check /\d+/
+    @s.send(@method).should == nil
+    @s.terminate
+    @s.send(@method).should == nil
+  end
+end

data/spec/strscan_spec/_shared/peek.rb

@@ -0,0 +1,44 @@
+shared :strscan_peek do
+  before do
+    @s = StringScanner.new('This is a test')
+  end
+
+  it "returns at most the specified number of characters from the current position" do
+    @s.send(@method, 4).should == "This"
+    @s.pos.should == 0
+    @s.pos = 5
+    @s.send(@method, 2).should == "is"
+    @s.send(@method, 1000).should == "is a test"
+  end
+
+  it "returns an empty string when the passed argument is zero" do
+    @s.send(@method, 0).should == ""
+  end
+
+  it "raises a ArgumentError when the passed argument is negative" do
+    lambda { @s.send(@method, -2) }.should.raise(ArgumentError)
+  end
+
+  # it "raises a RangeError when the passed argument is a Bignum" do
+  #   lambda { @s.send(@method, bignum_value) }.should.raise(RangeError)
+  # end
+
+  it "returns an instance of String when passed a String subclass" do
+    cls = Class.new(String)
+    sub = cls.new("abc")
+
+    s = StringScanner.new(sub)
+
+    ch = s.send(@method, 1)
+    ch.should.not.be.kind_of(cls)
+    ch.should.be.an.instance_of(String)
+  end
+
+  it "taints the returned String if the input was tainted" do
+    str = 'abc'
+    str.taint
+
+    s = StringScanner.new(str)
+    s.send(@method, 1).tainted?.should.be_true
+  end
+end

data/spec/strscan_spec/_shared/pos.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+
+shared :strscan_pos do
+  before do
+    @s = StringScanner.new("This is a test")
+    @m = StringScanner.new("cölorfül")
+  end
+
+  it "returns the position of the scan pointer" do
+    @s.send(@method).should == 0
+    @s.scan_until /This is/
+    @s.send(@method).should == 7
+    @s.get_byte
+    @s.send(@method).should == 8
+    @s.terminate
+    @s.send(@method).should == 14
+  end
+
+  it "returns the position of the scan pointer for multibyte string" do
+    @m.send(@method).should == 0
+    @m.scan_until /cö/
+    @m.send(@method).should == 3
+    @m.get_byte
+    @m.send(@method).should == 4
+    @m.terminate
+    @m.send(@method).should == 10
+  end
+
+  it "returns 0 in the reset position" do
+    @s.reset
+    @s.send(@method).should == 0
+  end
+
+  it "returns the length of the string in the terminate position" do
+    @s.terminate
+    @s.send(@method).should == @s.string.length
+  end
+
+  it "returns the `bytesize` for multibyte string in the terminate position" do
+    @m.terminate
+    @m.send(@method).should == @m.string.bytesize
+    @m.send(@method).should >= @m.string.length
+  end
+end
+
+shared :strscan_pos_set do
+  before do
+    @s = StringScanner.new("This is a test")
+    @m = StringScanner.new("cölorfül")
+  end
+
+  it "modify the scan pointer" do
+    @s.send(@method, 5)
+    @s.rest.should == "is a test"
+  end
+
+  it "can poin position that greater than string length for multibyte string" do
+    @m.send(@method, 9)
+    @m.rest.should == "l"
+  end
+
+  it "positions from the end if the argument is negative" do
+    @s.send(@method, -2)
+    @s.rest.should == "st"
+    @s.pos.should == 12
+  end
+
+  it "positions from the end if the argument is negative for multibyte string" do
+    @m.send(@method, -3)
+    @m.rest.should == "ül"
+    @m.pos.should == 7
+  end
+
+  it "raises a RangeError if position too far backward" do
+    lambda {
+      @s.send(@method, -20)
+    }.should.raise(RangeError)
+  end
+
+  it "raises a RangeError when the passed argument is out of range" do
+    lambda { @s.send(@method, 20) }.should.raise(RangeError)
+  end
+end

data/spec/strscan_spec/_shared/rest_size.rb

@@ -0,0 +1,18 @@
+shared :strscan_rest_size do
+  before do
+    @s = StringScanner.new('This is a test')
+  end
+
+  it "Returns the length of the rest of the string" do
+    @s.send(@method).should == 14
+    @s.scan(/This/)
+    @s.send(@method).should == 10
+    @s.terminate
+    @s.send(@method).should == 0
+  end
+
+  it "is equivalent to rest.size" do
+    @s.scan(/This/)
+    @s.send(@method).should == @s.rest.size
+  end
+end

data/spec/strscan_spec/_shared/terminate.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+shared :strscan_terminate do
+  it "set the scan pointer to the end of the string and clear matching data." do
+    s = StringScanner.new('This is a test')
+    s.send(@method)
+    s.bol?.should.be_false
+    s.eos?.should.be_true
+  end
+
+  it "set the scan pointer to the end of the string and clear matching data for multibyte string." do
+    s = StringScanner.new('cölorfül')
+    s.send(@method)
+    s.bol?.should.be_false
+    s.eos?.should.be_true
+  end
+end

data/spec/strscan_spec/append_spec.rb

@@ -0,0 +1,7 @@
+describe "StringScanner#<<" do
+  it_behaves_like :strscan_concat, :<<
+end
+
+describe "StringScanner#<< when passed a Fixnum" do
+  it_behaves_like :strscan_concat_fixnum, :<<
+end

data/spec/strscan_spec/beginning_of_line_spec.rb

@@ -0,0 +1,3 @@
+describe "StringScanner#beginning_of_line?" do
+  it_behaves_like(:strscan_bol, :beginning_of_line?)
+end

data/spec/strscan_spec/bol_spec.rb

@@ -0,0 +1,3 @@
+describe "StringScanner#bol?" do
+  it_behaves_like(:strscan_bol, :bol?)
+end

data/spec/strscan_spec/check_spec.rb

@@ -0,0 +1,13 @@
+describe "StringScanner#check" do
+  before do
+    @s = StringScanner.new("This is a test")
+  end
+
+  it "returns the value that scan would return, without advancing the scan pointer" do
+    @s.check(/This/).should == "This"
+    @s.matched.should == "This"
+    @s.pos.should == 0
+    @s.check(/is/).should == nil
+    @s.matched.should == nil
+  end
+end

data/spec/strscan_spec/check_until_spec.rb

@@ -0,0 +1,14 @@
+# require 'strscan'
+
+describe "StringScanner#check_until" do
+  before do
+    @s = StringScanner.new("This is a test")
+  end
+
+  it "returns the same value of scan_until, but don't advances the scan pointer" do
+    @s.check_until(/a/).should == "This is a"
+    @s.pos.should == 0
+    @s.matched.should == "a"
+    @s.check_until(/test/).should == "This is a test"
+  end
+end

data/spec/strscan_spec/clear_spec.rb

@@ -0,0 +1,21 @@
+describe "StringScanner#clear" do
+  it_behaves_like(:strscan_terminate, :clear)
+
+  # it "warns in verbose mode that the method is obsolete" do
+  #   s = StringScanner.new("abc")
+  #   begin
+  #     old = $VERBOSE
+  #     lambda {
+  #       $VERBOSE = true
+  #       s.clear
+  #     }.should complain(/clear.*obsolete.*terminate/)
+  #
+  #     lambda {
+  #       $VERBOSE = false
+  #       s.clear
+  #     }.should_not complain
+  #   ensure
+  #     $VERBOSE = old
+  #   end
+  # end
+end