parsanol 3.0.0

data/spec/parsanol/slice_spec.rb

@@ -0,0 +1,249 @@
+require 'spec_helper'
+
+describe Parsanol::Slice do
+  def cslice(string, bytepos, cache = nil)
+    described_class.new(
+      bytepos,
+      string,
+      cache
+    )
+  end
+
+  describe 'construction' do
+    it 'constructs from a byte position 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
+        # In Opal, eql? must handle String comparison for Hash/Array equality
+        skip if RUBY_ENGINE == 'opal'
+
+        slice.should_not eql('foobar')
+      end
+
+      it 'does not hash to the same number' do
+        slice.hash.should_not == 'foobar'.hash
+      end
+    end
+
+    describe 'offset' do
+      it 'returns the associated offset' do
+        slice.offset.should == 40
+      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 '#bytepos' do
+      it 'returns byte position' do
+        slice.bytepos.should == 40
+      end
+    end
+
+    describe '#charpos' do
+      it 'returns same as offset (bytepos)' do
+        slice.charpos.should == 40
+      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 == 40
+        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"@40')
+        }
+      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, Parsanol::Source::LineCache.new) }
+
+        it 'serializes' do
+          Marshal.dump(slice)
+        end
+      end
+    end
+  end
+
+  describe '.from_rope' do
+    let(:bytepos) { 0 }
+
+    it 'creates slice from rope' do
+      rope = Parsanol::Rope.new.append('hello').append(' world')
+      slice = described_class.from_rope(rope, bytepos)
+      expect(slice.str).to eq('hello world')
+      expect(slice.offset).to eq(0)
+    end
+
+    it 'handles empty rope' do
+      rope = Parsanol::Rope.new
+      slice = described_class.from_rope(rope, bytepos)
+      expect(slice.str).to eq('')
+      expect(slice.offset).to eq(0)
+    end
+
+    it 'handles rope with single segment' do
+      rope = Parsanol::Rope.new.append('single')
+      slice = described_class.from_rope(rope, bytepos)
+      expect(slice.str).to eq('single')
+    end
+
+    it 'preserves position information' do
+      rope = Parsanol::Rope.new.append('test')
+      slice = described_class.from_rope(rope, 5)
+      expect(slice.offset).to eq(5)
+    end
+
+    it 'preserves line cache' do
+      cache = double(:cache, line_and_column: [10, 15])
+      rope = Parsanol::Rope.new.append('test')
+      slice = described_class.from_rope(rope, 0, cache)
+      expect(slice.line_and_column).to eq([10, 15])
+    end
+
+    it 'handles rope with Slice segments' do
+      rope = Parsanol::Rope.new
+      rope.append(cslice('hello', 0))
+      rope.append(cslice(' world', 5))
+      slice = described_class.from_rope(rope, bytepos)
+      expect(slice.str).to eq('hello world')
+    end
+
+    it 'creates a proper Slice instance' do
+      rope = Parsanol::Rope.new.append('test')
+      slice = described_class.from_rope(rope, bytepos)
+      expect(slice).to be_a(Parsanol::Slice)
+    end
+  end
+end

data/spec/parsanol/source/line_cache_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe Parsanol::Source::RangeSearch do
+  describe "<- #lbound" do
+    context "for a simple array" do
+      let(:ary) { [10, 20, 30, 40, 50] }
+      before(:each) { ary.extend Parsanol::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 Parsanol::Source::RangeSearch }
+
+      it "should return nil" do
+        ary.lbound(1).should be_nil
+      end 
+    end
+  end
+end
+
+describe Parsanol::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/parsanol/source_spec.rb

@@ -0,0 +1,207 @@
+require 'spec_helper'
+
+describe Parsanol::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 }
+
+      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.should == pos
+          end
+        end
+      end
+    end
+
+    describe '<- #pos=(n)' do
+      subject { source.pos }
+
+      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
+            @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)
+      
+      # Note: pos now returns bytepos directly (not charpos)
+      # For UTF-8: é is 2 bytes, ö is 2 bytes
+      source.pos.should == if RUBY_ENGINE == 'opal'
+                             # In Opal/JavaScript, string indexing is character-based
+                             1
+                           else
+                             # In Ruby, multi-byte characters use multiple bytes
+                             2
+                           end
+
+      # 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 == 2  # Ruby: 2 bytes for 'é'
+
+      source.should match(r('ö'))
+      source.consume(1)
+      
+      # After consuming 'é' (2 bytes) and 'ö' (2 bytes) = 4 bytes total
+      source.pos.should == 4
+
+      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