plurimath-parslet 3.0.0

data/spec/parslet/scope_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Parslet::Scope do
+  let(:scope) { described_class.new }
+  
+  describe 'simple store/retrieve' do
+    before(:each) { scope[:foo] = :bar }
+    it "allows storing objects" do
+      scope[:obj] = 42
+    end 
+    it "raises on access of empty slots" do
+      expect {
+        scope[:empty]
+      }.to raise_error(Parslet::Scope::NotFound)
+    end 
+    it "allows retrieval of stored values" do
+      scope[:foo].should == :bar
+    end 
+  end
+  
+  describe 'scoping' do
+    before(:each) { scope[:depth] = 1 }
+    before(:each) { scope.push }
+    
+    let(:depth) { scope[:depth] }
+    subject { depth }
+    
+    it { should == 1 }
+    describe 'after a push' do
+      before(:each) { scope.push }
+      it { should == 1 }
+      
+      describe 'and reassign' do
+        before(:each) { scope[:depth] = 2 }
+        
+        it { should == 2 }
+
+        describe 'and a pop' do
+          before(:each) { scope.pop }
+          it { should == 1 }
+        end
+      end
+    end
+  end
+end

data/spec/parslet/slice_spec.rb

@@ -0,0 +1,186 @@
+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 'constructs 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 'is equal to other slices with the same attributes' do
+        other = cslice('foobar', 40)
+        slice.should == other
+        other.should == slice
+      end
+
+      it 'is equal to other slices (offset is irrelevant for comparison)' do
+        other = cslice('foobar', 41)
+        slice.should == other
+        other.should == slice
+      end
+
+      it 'is equal to a string with the same content' do
+        slice.should == 'foobar'
+      end
+
+      it 'is equal to a string (inversed operands)' do
+        'foobar'.should == slice
+      end
+
+      it 'is not equal to a string' do
+        slice.should_not equal('foobar')
+      end
+
+      it 'is not eql to a string' do
+        # For Opal we have redefined inspect to return the string itself
+        skip if RUBY_ENGINE == 'opal'
+
+        slice.should_not eql('foobar')
+      end
+
+      it 'does not hash to the same number' do
+        # In Opal, the hash of a string is the same as the string itself when we redefined inspect
+        skip if RUBY_ENGINE == 'opal'
+        slice.hash.should_not == 'foobar'.hash
+      end
+    end
+
+    describe 'offset' do
+      it 'returns the associated offset' do
+        slice.offset.should == 6
+      end
+
+      it 'fails 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(:cache) { double(:cache, line_and_column: [13, 14]) }
+        let(:slice) { cslice('foobar', 40, cache) }
+
+        it 'returns proper line and column' do
+          slice.line_and_column.should == [13, 14]
+        end
+      end
+    end
+
+    describe 'string methods' do
+      describe 'matching' do
+        it 'matches 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 { is_expected.to eq(6) }
+      end
+
+      describe '<- #length' do
+        subject { slice.length }
+
+        it { is_expected.to eq(6) }
+      end
+
+      describe '<- #+' do
+        subject { slice + other }
+
+        let(:other) { cslice('baz', 10) }
+
+        it 'concats 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 'returns self' do
+          slice.to_slice.should eq(slice)
+        end
+      end
+
+      describe '<- #to_sym' do
+        it 'returns :foobar' do
+          slice.to_sym.should == :foobar
+        end
+      end
+
+      describe 'cast to Float' do
+        it 'returns a float' do
+          Float(cslice('1.345', 11)).should == 1.345
+        end
+      end
+
+      describe 'cast to Integer' do
+        it 'casts to integer as a string would' do
+          s = cslice('1234', 40)
+          Integer(s).should == 1234
+          s.to_i.should == 1234
+        end
+
+        it 'fails when Integer would fail on a string' do
+          -> { Integer(slice.to_s) }.should raise_error(ArgumentError, /invalid value/)
+        end
+
+        it 'turns 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 {
+          # For Opal we have redefined inspect to return the string itself
+          skip if RUBY_ENGINE == 'opal'
+
+          is_expected.to eq('"foobar"@6')
+        }
+      end
+
+      describe '#to_s' do
+        subject { slice.to_s }
+
+        it { is_expected.to eq('foobar') }
+      end
+    end
+
+    describe 'serializability' do
+      it 'serializes' do
+        Marshal.dump(slice)
+      end
+
+      context 'when storing a line cache' do
+        let(:slice) { cslice('foobar', 40, Parslet::Source::LineCache.new) }
+
+        it 'serializes' 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,210 @@
+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 'does not raise error when the return value is nil' do
+        described_class.new('').consume(1)
+      end
+
+      it "returns 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 { is_expected.to eq(202) }
+
+      context 'after depleting the source' do
+        before { source.consume(10_000) }
+
+        it { is_expected.to eq(0) }
+      end
+    end
+
+    describe '<- #pos' do
+      subject { source.pos.charpos }
+
+      it { is_expected.to eq(0) }
+
+      context 'after reading a few bytes' do
+        it 'stills be correct' do
+          pos = 0
+          10.times do
+            pos += (n = rand(1..10))
+            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 { source.bytepos = pos }
+
+          it { is_expected.to eq(pos) }
+        end
+      end
+    end
+
+    describe '#chars_until' do
+      it 'returns 100 chars before line end' do
+        source.chars_until("\n").should == 100
+      end
+    end
+
+    describe '<- #column & #line' do
+      subject { source.line_and_column }
+
+      it { is_expected.to eq([1, 1]) }
+
+      context 'on the first line' do
+        it 'increases 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 { source.consume(101) }
+
+        it { is_expected.to eq([2, 1]) }
+      end
+
+      context 'after reading everything' do
+        before { source.consume(10_000) }
+
+        context 'when seeking to 9' do
+          before { source.bytepos = 9 }
+
+          it { is_expected.to eq([1, 10]) }
+        end
+
+        context 'when seeking to 100' do
+          before { source.bytepos = 100 }
+
+          it { is_expected.to eq([1, 101]) }
+        end
+
+        context 'when seeking to 101' do
+          before { source.bytepos = 101 }
+
+          it { is_expected.to eq([2, 1]) }
+        end
+
+        context 'when seeking to 102' do
+          before { source.bytepos = 102 }
+
+          it { is_expected.to eq([2, 2]) }
+        end
+
+        context 'when seeking beyond eof' do
+          it 'does not throw an error' do
+            source.bytepos = 1000
+          end
+        end
+      end
+
+      context 'reading char by char, storing the results' do
+        attr_reader :results
+
+        before do
+          @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
+        end
+
+        context 'when using pos argument' do
+          it 'returns the same results' do
+            results.each do |pos, result|
+              source.line_and_column(pos).should == result
+            end
+          end
+        end
+
+        it 'gives the same results when seeking' do
+          results.each do |pos, result|
+            source.bytepos = pos
+            source.line_and_column.should == result
+          end
+        end
+
+        it 'gives 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 'reads characters, not bytes' do
+      source.should match(r('é'))
+      source.consume(1)
+      source.pos.charpos.should == 1
+
+      # TODO This needs to be fixed in code with Opal
+      if RUBY_ENGINE == 'opal'
+        skip "Opal does not support byte positions and char positions correctly for multi-byte characters"
+      end
+
+      source.bytepos.should == if RUBY_ENGINE == 'opal'
+                                 # In Opal/JavaScript, string indexing is character-based, not byte-based
+                                 1
+                               else
+                                 # In Ruby, multi-byte characters have different byte positions
+                                 2
+                               end
+
+      source.should match(r('ö'))
+      source.consume(1)
+      source.pos.charpos.should == if RUBY_ENGINE == 'opal'
+                                 1
+                               else
+                                 2
+                               end
+
+      source.bytepos.should == if RUBY_ENGINE == 'opal'
+                                 2
+                               else
+                                 4
+                               end
+
+      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,56 @@
+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
+  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
+
+  describe 'works as a Ruby object should' do
+    let(:obj) { context(a: 1) }
+
+    it 'responds_to? :a' do
+      expect(obj.respond_to?(:a)).to be_truthy
+    end
+    it 'includes :a in #methods' do
+      expect(obj.methods).to include(:a)
+    end
+    it 'allows inspection' do
+      expect(obj.inspect).to match(/@a=1/)
+    end
+    it 'allows conversion to string' do
+      expect(obj.to_s).to match(/Parslet::Context:0x/)
+    end
+
+    context 'when the context is enhanced' do
+      before(:each) do
+        class << obj
+          def foo
+            'foo'
+          end
+        end
+      end
+
+      it 'responds_to correctly' do
+        expect(obj.respond_to?(:foo)).to be_truthy
+      end
+      it 'includes :foo also in methods' do
+        expect(obj.methods).to include(:foo)
+      end
+      it 'allows calling #foo' do
+        expect(obj.foo).to eq('foo')
+      end
+    end
+  end
+end