parslet 1.7.0 → 1.7.1

data/spec/parslet/slice_spec.rb

@@ -0,0 +1,144 @@
+require 'spec_helper'
+
+describe Parslet::Slice do
+  def cslice string, offset, cache=nil
+    described_class.new(
+      Parslet::Position.new(string, offset), 
+      string, cache)
+  end
+
+  describe "construction" do
+    it "should construct from an offset and a string" do
+      cslice('foobar', 40)
+    end
+  end
+  context "('foobar', 40, 'foobar')" do
+    let(:slice) { cslice('foobar', 40) }
+    describe "comparison" do
+      it "should be equal to other slices with the same attributes" do
+        other = cslice('foobar', 40)
+        slice.should == other
+        other.should == slice
+      end 
+      it "should be equal to other slices (offset is irrelevant for comparison)" do
+        other = cslice('foobar', 41)
+        slice.should == other
+        other.should == slice
+      end 
+      it "should be equal to a string with the same content" do
+        slice.should == 'foobar'
+      end
+      it "should be equal to a string (inversed operands)" do
+        'foobar'.should == slice
+      end 
+      it "should not be equal to a string" do
+        slice.should_not equal('foobar')
+      end 
+      it "should not be eql to a string" do
+        slice.should_not eql('foobar')
+      end 
+      it "should not hash to the same number" do
+        slice.hash.should_not == 'foobar'.hash
+      end 
+    end
+    describe "offset" do
+      it "should return the associated offset" do
+        slice.offset.should == 6
+      end
+      it "should fail to return a line and column" do
+        lambda {
+          slice.line_and_column
+        }.should raise_error(ArgumentError)
+      end 
+      
+      context "when constructed with a source" do
+        let(:slice) { cslice(
+          'foobar', 40,  
+          flexmock(:cache, :line_and_column => [13, 14])) }
+        it "should return proper line and column" do
+          slice.line_and_column.should == [13, 14]
+        end
+      end
+    end
+    describe "string methods" do
+      describe "matching" do
+        it "should match as a string would" do
+          slice.should match(/bar/)
+          slice.should match(/foo/)
+
+          md = slice.match(/f(o)o/)
+          md.captures.first.should == 'o'
+        end
+      end
+      describe "<- #size" do
+        subject { slice.size }
+        it { should == 6 } 
+      end
+      describe "<- #length" do
+        subject { slice.length }
+        it { should == 6 } 
+      end
+      describe "<- #+" do
+        let(:other) { cslice('baz', 10) }
+        subject { slice + other }
+        
+        it "should concat like string does" do
+          subject.size.should == 9
+          subject.should == 'foobarbaz'
+          subject.offset.should == 6
+        end 
+      end
+    end
+    describe "conversion" do
+      describe "<- #to_slice" do
+        it "should return self" do
+          slice.to_slice.should eq(slice)
+        end 
+      end
+      describe "<- #to_sym" do
+        it "should return :foobar" do
+          slice.to_sym.should == :foobar
+        end 
+      end
+      describe "cast to Float" do
+        it "should return a float" do
+          Float(cslice('1.345', 11)).should == 1.345
+        end 
+      end
+      describe "cast to Integer" do
+        it "should cast to integer as a string would" do
+          s = cslice('1234', 40)
+          Integer(s).should == 1234
+          s.to_i.should == 1234
+        end 
+        it "should fail when Integer would fail on a string" do
+          lambda { Integer(slice) }.should raise_error(ArgumentError, /invalid value/)
+        end 
+        it "should turn into zero when a string would" do
+          slice.to_i.should == 0
+        end 
+      end
+    end
+    describe "inspection and string conversion" do
+      describe "#inspect" do
+        subject { slice.inspect }
+        it { should == '"foobar"@6' }
+      end
+      describe "#to_s" do
+        subject { slice.to_s }
+        it { should == 'foobar' }
+      end
+    end
+    describe "serializability" do
+      it "should serialize" do
+        Marshal.dump(slice)
+      end
+      context "when storing a line cache" do
+        let(:slice) { cslice('foobar', 40, Parslet::Source::LineCache.new()) }
+        it "should serialize" do
+          Marshal.dump(slice)
+        end
+      end
+    end
+  end
+end

data/spec/parslet/source/line_cache_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe Parslet::Source::RangeSearch do
+  describe "<- #lbound" do
+    context "for a simple array" do
+      let(:ary) { [10, 20, 30, 40, 50] }
+      before(:each) { ary.extend Parslet::Source::RangeSearch }
+
+      it "should return correct answers for numbers not in the array" do
+        ary.lbound(5).should == 0
+        ary.lbound(15).should == 1
+        ary.lbound(25).should == 2
+        ary.lbound(35).should == 3
+        ary.lbound(45).should == 4
+      end
+      it "should return correct answers for numbers in the array" do
+        ary.lbound(10).should == 1
+        ary.lbound(20).should == 2
+        ary.lbound(30).should == 3
+        ary.lbound(40).should == 4
+      end
+      it "should cover right edge case" do
+        ary.lbound(50).should be_nil
+        ary.lbound(51).should be_nil
+      end 
+      it "should cover left edge case" do
+        ary.lbound(0).should == 0
+      end
+    end
+    context "for an empty array" do
+      let(:ary) { [] }
+      before(:each) { ary.extend Parslet::Source::RangeSearch }
+
+      it "should return nil" do
+        ary.lbound(1).should be_nil
+      end 
+    end
+  end
+end
+
+describe Parslet::Source::LineCache do
+  describe "<- scan_for_line_endings" do
+    context "calculating the line_and_columns" do
+      let(:str) { "foo\nbar\nbazd" }
+
+      it "should return the first line if we have no line ends" do
+        subject.scan_for_line_endings(0, nil)
+        subject.line_and_column(3).should == [1, 4]
+
+        subject.scan_for_line_endings(0, "")
+        subject.line_and_column(5).should == [1, 6]
+      end
+
+      it "should find the right line starting from pos 0" do
+        subject.scan_for_line_endings(0, str)
+        subject.line_and_column(5).should == [2, 2]
+        subject.line_and_column(9).should == [3, 2]
+      end
+
+      it "should find the right line starting from pos 5" do
+        subject.scan_for_line_endings(5, str)
+        subject.line_and_column(11).should == [2, 3]
+      end
+
+      it "should find the right line if scannning the string multiple times" do
+        subject.scan_for_line_endings(0, str)
+        subject.scan_for_line_endings(0, "#{str}\nthe quick\nbrown fox")
+        subject.line_and_column(10).should == [3,3]
+        subject.line_and_column(24).should == [5,2]
+      end
+    end
+  end
+end
+

data/spec/parslet/source_spec.rb

@@ -0,0 +1,168 @@
+# Encoding: UTF-8
+
+require 'spec_helper'
+
+describe Parslet::Source do
+  describe "using simple input" do
+    let(:str)     { "a"*100 + "\n" + "a"*100 + "\n" }
+    let(:source)  { described_class.new(str) }
+  
+    describe "<- #read(n)" do
+      it "should not raise error when the return value is nil" do
+        described_class.new('').consume(1)
+      end 
+      it "should return 100 'a's when reading 100 chars" do
+        source.consume(100).should == 'a'*100
+      end
+    end
+    describe "<- #chars_left" do
+      subject { source.chars_left }
+  
+      it { should == 202 }
+      context "after depleting the source" do
+        before(:each) { source.consume(10000) }
+  
+        it { should == 0 }
+      end
+    end
+    describe "<- #pos" do
+      subject { source.pos.charpos }
+  
+      it { should == 0 }
+      context "after reading a few bytes" do
+        it "should still be correct" do
+          pos = 0
+          10.times do
+            pos += (n = rand(10)+1)
+            source.consume(n)
+  
+            source.pos.charpos.should == pos
+          end
+        end 
+      end
+    end
+    describe "<- #pos=(n)" do
+      subject { source.pos.charpos }
+      10.times do
+        pos = rand(200)
+        context "setting position #{pos}" do
+          before(:each) { source.bytepos = pos }
+  
+          it { should == pos }
+        end
+      end
+    end
+    describe '#chars_until' do
+      it 'should return 100 chars before line end' do
+        source.chars_until("\n").should == 100
+      end
+    end
+    describe "<- #column & #line" do
+      subject { source.line_and_column }
+  
+      it { should == [1,1] }
+  
+      context "on the first line" do
+        it "should increase column with every read" do
+          10.times do |i|
+            source.line_and_column.last.should == 1+i
+            source.consume(1)
+          end
+        end 
+      end
+      context "on the second line" do
+        before(:each) { source.consume(101) }
+        it { should == [2, 1]}
+      end
+      context "after reading everything" do
+        before(:each) { source.consume(10000) }
+  
+        context "when seeking to 9" do
+          before(:each) { source.bytepos = 9 }
+          it { should == [1, 10] }
+        end
+        context "when seeking to 100" do
+          before(:each) { source.bytepos = 100 }
+          it { should == [1, 101] }
+        end
+        context "when seeking to 101" do
+          before(:each) { source.bytepos = 101 }
+          it { should == [2, 1] }
+        end
+        context "when seeking to 102" do
+          before(:each) { source.bytepos = 102 }
+          it { should == [2, 2] }
+        end
+        context "when seeking beyond eof" do
+          it "should not throw an error" do
+            source.bytepos = 1000
+          end 
+        end
+      end
+      context "reading char by char, storing the results" do
+        attr_reader :results
+        before(:each) { 
+          @results = {}
+          while source.chars_left>0
+            pos = source.pos.charpos
+            @results[pos] = source.line_and_column
+            source.consume(1)
+          end
+  
+          @results.entries.size.should == 202
+          @results
+        }
+  
+        context "when using pos argument" do
+          it "should return the same results" do
+            results.each do |pos, result|
+              source.line_and_column(pos).should == result
+            end
+          end 
+        end
+        it "should give the same results when seeking" do
+          results.each do |pos, result|
+            source.bytepos = pos
+            source.line_and_column.should == result
+          end
+        end
+        it "should give the same results when reading" do
+          cur = source.bytepos = 0
+          while source.chars_left>0
+            source.line_and_column.should == results[cur]
+            cur += 1
+            source.consume(1)
+          end
+        end 
+      end
+    end
+    
+  end
+  
+  describe "reading encoded input" do
+    let(:source) { described_class.new("éö変わる") }
+
+    def r str
+      Regexp.new(Regexp.escape(str))
+    end
+  
+    it "should read characters, not bytes" do
+      source.should match(r("é"))
+      source.consume(1)
+      source.pos.charpos.should == 1
+      source.bytepos.should == 2
+      
+      source.should match(r("ö"))
+      source.consume(1)
+      source.pos.charpos.should == 2
+      source.bytepos.should == 4
+      
+      source.should match(r("変"))
+      source.consume(1)
+      
+      source.consume(2)
+      source.chars_left.should == 0
+      source.chars_left.should == 0
+    end 
+  end
+end

data/spec/parslet/transform/context_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Parslet::Context do
+  def context(*args)
+    described_class.new(*args)
+  end
+  
+  it "binds hash keys as variable like things" do
+    context(:a => 'value').instance_eval { a }.
+      should == 'value'
+  end
+  describe 'when a method in BlankSlate is inherited from the environment somehow' do
+    before(:each) { BlankSlate.send(:define_method, :a) { 'c' } }
+    after(:each) { BlankSlate.send(:undef_method, :a) }
+    
+    it "masks what is already on blank slate" do
+      context(:a => 'b').instance_eval { a }.
+        should == 'b'
+    end  
+  end
+  it "should not reveal define_singleton_method for all users of blankslate, just for us" do
+    expect {
+      BlankSlate.new.instance_eval {
+        define_singleton_method(:foo) { 'foo' }
+      }
+    }.to raise_error(NoMethodError)
+  end 
+  it "one contexts variables aren't the next ones" do
+    ca = context(:a => 'b')
+    cb = context(:b => 'c')
+
+    ca.methods.should_not include(:b)
+    cb.methods.should_not include(:a)
+  end
+end

data/spec/parslet/transform_spec.rb

@@ -0,0 +1,165 @@
+require 'spec_helper'
+
+require 'parslet'
+
+describe Parslet::Transform do
+  include Parslet
+  
+  let(:transform) { Parslet::Transform.new }
+  attr_reader :transform
+  before(:each) do
+    @transform = Parslet::Transform.new
+  end
+  
+  class A < Struct.new(:elt); end
+  class B < Struct.new(:elt); end
+  class C < Struct.new(:elt); end
+  class Bi < Struct.new(:a, :b); end
+
+  describe "delayed construction" do
+    context "given simple(:x) => A.new(x)" do
+      before(:each) do
+        transform.rule(simple(:x)) { |d| A.new(d[:x]) }
+      end
+
+      it "should transform 'a' into A.new('a')" do
+        transform.apply('a').should == A.new('a')
+      end 
+      it "should transform ['a', 'b'] into [A.new('a'), A.new('b')]" do
+        transform.apply(['a', 'b']).should == 
+          [A.new('a'), A.new('b')]
+      end
+    end
+    context "given rules on {:a => simple(:x)} and {:b => :_x}" do
+      before(:each) do
+        transform.rule(:a => simple(:x)) { |d| A.new(d[:x]) }
+        transform.rule(:b => simple(:x)) { |d| B.new(d[:x]) }
+      end
+
+      it "should transform {:d=>{:b=>'c'}} into d => B('c')" do
+        transform.apply({:d=>{:b=>'c'}}).should == {:d => B.new('c')}
+      end
+      it "should transform {:a=>{:b=>'c'}} into A(B('c'))" do
+        transform.apply({:a=>{:b=>'c'}}).should == A.new(B.new('c'))
+      end
+    end
+    describe "pulling out subbranches" do
+      before(:each) do
+        transform.rule(:a => {:b => simple(:x)}, :d => {:e => simple(:y)}) { |d|
+          Bi.new(*d.values_at(:x, :y))
+        }
+      end
+
+      it "should yield Bi.new('c', 'f')" do
+        transform.apply(:a => {:b => 'c'}, :d => {:e => 'f'}).should ==
+          Bi.new('c', 'f')
+      end 
+    end
+  end
+  describe "dsl construction" do
+    let(:transform) { Parslet::Transform.new do
+        rule(simple(:x)) { A.new(x) }
+      end 
+    }
+    
+    it "should still evaluate rules correctly" do
+      transform.apply('a').should == A.new('a')
+    end 
+  end
+  describe "class construction" do
+    class OptimusPrime < Parslet::Transform 
+      rule(:a => simple(:x)) { A.new(x) }
+      rule(:b => simple(:x)) { B.new(x) }
+    end
+    let(:transform) { OptimusPrime.new }
+    
+    it "should evaluate rules" do
+      transform.apply(:a => 'a').should == A.new('a')
+    end
+
+    context "with inheritance" do
+      class OptimusPrimeJunior < OptimusPrime
+        rule(:b => simple(:x)) { B.new(x.upcase) }
+        rule(:c => simple(:x)) { C.new(x) }
+      end
+      let(:transform) { OptimusPrimeJunior.new }
+
+      it "should inherit rules from its parent" do
+        transform.apply(:a => 'a').should == A.new('a')
+      end
+
+      it "should be able to override rules from its parent" do
+        transform.apply(:b => 'b').should == B.new('B')
+      end
+
+      it "should be able to define new rules" do
+        transform.apply(:c => 'c').should == C.new('c')
+      end
+    end
+  end
+  describe "<- #call_on_match" do
+    let(:bindings) { { :foo => 'test' } }
+    context "when given a block of arity 1" do
+      it "should call the block" do
+        called = false
+        transform.call_on_match(bindings, lambda do |dict|
+          called = true
+        end)
+        
+        called.should == true
+      end 
+      it "should yield the bindings" do
+        transform.call_on_match(bindings, lambda do |dict|
+          dict.should == bindings
+        end)
+      end
+      it "should execute in the current context"  do
+        foo = 'test'
+        transform.call_on_match(bindings, lambda do |dict|
+          foo.should == 'test'
+        end)
+      end
+    end
+    context "when given a block of arity 0" do
+      it "should call the block" do
+        called = false
+        transform.call_on_match(bindings, proc do 
+          called = true
+        end)
+        
+        called.should == true
+      end 
+      it "should have bindings as local variables" do
+        transform.call_on_match(bindings, proc do
+          foo.should == 'test'
+        end)
+      end
+      it "should execute in its own context" do
+        @bar = 'test'
+        transform.call_on_match(bindings, proc do
+          @bar.should_not == 'test'
+        end)
+      end
+    end
+  end
+  
+  context "various transformations (regression)" do
+    context "hashes" do
+      it "are matched completely" do
+        transform.rule(:a => simple(:x)) { fail }
+        transform.apply(:a => 'a', :b => 'b')
+      end 
+    end
+  end
+  
+  context "when not using the bindings as hash, but as local variables" do
+    it "should access the variables" do
+      transform.rule(simple(:x)) { A.new(x) }
+      transform.apply('a').should == A.new('a')
+    end
+    it "should allow context as local variable" do
+      transform.rule(simple(:x)) { foo }
+      transform.apply('a', :foo => 'bar').should == 'bar'
+    end
+  end
+end