d-parse 0.1

data/spec/d-parse/parsers/char_not_in_spec.rb

@@ -0,0 +1,23 @@
+describe DParse::Parsers::CharNotIn do
+  let(:parser) { described_class.new(%w(a b)) }
+
+  example { expect(parser).to parse('c').up_to(1) }
+  example { expect(parser).to parse('ca').up_to(1) }
+  example { expect(parser).to parse('cb').up_to(1) }
+  example { expect(parser).to parse('cab').up_to(1) }
+
+  example { expect(parser).not_to parse('').and_fail_at(0).line(0).column(0).with_failure('expected any character not in \'a\', \'b\'') }
+  example { expect(parser).not_to parse('a').and_fail_at(0).line(0).column(0).with_failure('expected any character not in \'a\', \'b\'') }
+  example { expect(parser).not_to parse('ab').and_fail_at(0).line(0).column(0).with_failure('expected any character not in \'a\', \'b\'') }
+  example { expect(parser).not_to parse('ac').and_fail_at(0).line(0).column(0).with_failure('expected any character not in \'a\', \'b\'') }
+  example { expect(parser).not_to parse('b').and_fail_at(0).line(0).column(0).with_failure('expected any character not in \'a\', \'b\'') }
+  example { expect(parser).not_to parse('ba').and_fail_at(0).line(0).column(0).with_failure('expected any character not in \'a\', \'b\'') }
+  example { expect(parser).not_to parse('bb').and_fail_at(0).line(0).column(0).with_failure('expected any character not in \'a\', \'b\'') }
+  example { expect(parser).not_to parse('bc').and_fail_at(0).line(0).column(0).with_failure('expected any character not in \'a\', \'b\'') }
+
+  describe '#inspect' do
+    subject { parser.inspect }
+
+    it { is_expected.to eql('char_not_in(["a", "b"])') }
+  end
+end

data/spec/d-parse/parsers/char_not_spec.rb

@@ -0,0 +1,16 @@
+describe DParse::Parsers::CharNot do
+  let(:parser) { described_class.new('a') }
+
+  example { expect(parser).to parse('b').up_to(1) }
+  example { expect(parser).to parse('ba').up_to(1) }
+
+  example { expect(parser).not_to parse('').and_fail_at(0).line(0).column(0).with_failure('expected any character not equal to \'a\'') }
+  example { expect(parser).not_to parse('a').and_fail_at(0).line(0).column(0).with_failure('expected any character not equal to \'a\'') }
+  example { expect(parser).not_to parse('ab').and_fail_at(0).line(0).column(0).with_failure('expected any character not equal to \'a\'') }
+
+  describe '#inspect' do
+    subject { parser.inspect }
+
+    it { is_expected.to eql('char_not("a")') }
+  end
+end

data/spec/d-parse/parsers/char_spec.rb

@@ -0,0 +1,22 @@
+describe DParse::Parsers::Char do
+  let(:parser) { described_class.new('a') }
+
+  example { expect(parser).to parse('a').up_to(1) }
+  example { expect(parser).to parse('aa').up_to(1) }
+  example { expect(parser).to parse('ab').up_to(1) }
+
+  example { expect(parser).not_to parse('').and_fail_at(0).line(0).column(0).with_failure('expected \'a\'') }
+  example { expect(parser).not_to parse('b').and_fail_at(0).line(0).column(0).with_failure('expected \'a\'') }
+
+  context 'newline parser' do
+    let(:parser) { described_class.new("\n") }
+
+    example { expect(parser).to parse("\n").up_to(1).line(1).column(0) }
+  end
+
+  describe '#inspect' do
+    subject { parser.inspect }
+
+    it { is_expected.to eql('char("a")') }
+  end
+end

data/spec/d-parse/parsers/describe_spec.rb

@@ -0,0 +1,22 @@
+describe DParse::Parsers::Describe do
+  let(:identifier) do
+    DParse::Parsers::Seq.new(
+      DParse::Parsers::Repeat.new(
+        DParse::Parsers::CharIn.new('a'..'z'),
+      ),
+      DParse::Parsers::EOF.new,
+    )
+  end
+
+  let(:parser) { described_class.new(identifier, 'identifier') }
+
+  example { expect(parser).not_to parse('0123').and_fail_at(0).line(0).column(0).with_failure('expected identifier') }
+
+  describe '#inspect' do
+    subject { parser.inspect }
+
+    let(:identifier) { DParse::Parsers::Char.new('a') }
+
+    it { is_expected.to eql('identifier()') }
+  end
+end

data/spec/d-parse/parsers/end_of_input_spec.rb

@@ -0,0 +1,20 @@
+describe DParse::Parsers::EOF do
+  let(:parser) { described_class.new }
+
+  example { expect(parser).to parse('') }
+
+  example { expect(parser).not_to parse('a').and_fail_at(0).line(0).column(0).with_failure('expected end of input') }
+  example { expect(parser).not_to parse('aa').and_fail_at(0).line(0).column(0).with_failure('expected end of input') }
+
+  example { expect(parser).not_to parse("\n").and_fail_at(0).line(0).column(0).with_failure('expected end of input') }
+  example { expect(parser).not_to parse("\r").and_fail_at(0).line(0).column(0).with_failure('expected end of input') }
+  example { expect(parser).not_to parse("'").and_fail_at(0).line(0).column(0).with_failure('expected end of input') }
+  example { expect(parser).not_to parse('"').and_fail_at(0).line(0).column(0).with_failure('expected end of input') }
+  example { expect(parser).not_to parse('\\').and_fail_at(0).line(0).column(0).with_failure('expected end of input') }
+
+  describe '#inspect' do
+    subject { parser.inspect }
+
+    it { is_expected.to eql('eof()') }
+  end
+end

data/spec/d-parse/parsers/except_spec.rb

@@ -0,0 +1,20 @@
+describe DParse::Parsers::Except do
+  let(:parser) { described_class.new(initial_parser, bad_parser) }
+
+  let(:initial_parser) { DParse::Parsers::Any.new }
+  let(:bad_parser) { DParse::Parsers::Char.new('x') }
+
+  example { expect(parser).to parse('a').up_to(1) }
+  example { expect(parser).to parse('aa').up_to(1) }
+  example { expect(parser).to parse('ax').up_to(1) }
+  example { expect(parser).not_to parse('x').and_fail_at(0).line(0).column(0).with_failure('expected any character except end of file, not \'x\'') }
+  example { expect(parser).not_to parse('xa').and_fail_at(0).line(0).column(0).with_failure('expected any character except end of file, not \'x\'') }
+
+  example { expect(parser).not_to parse('').and_fail_at(0).line(0).column(0).with_failure('expected any character except end of file') }
+
+  describe '#inspect' do
+    subject { parser.inspect }
+
+    it { is_expected.to eql('except(any(), char("x"))') }
+  end
+end

data/spec/d-parse/parsers/fail_spec.rb

@@ -0,0 +1,12 @@
+describe DParse::Parsers::Fail do
+  let(:parser) { described_class.new }
+
+  example { expect(parser).not_to parse('').and_fail_at(0).line(0).column(0).with_failure('expected nothing (always fail)') }
+  example { expect(parser).not_to parse('a').and_fail_at(0).line(0).column(0).with_failure('expected nothing (always fail)') }
+
+  describe '#inspect' do
+    subject { parser.inspect }
+
+    it { is_expected.to eql('fail()') }
+  end
+end

data/spec/d-parse/parsers/intersperse_spec.rb

@@ -0,0 +1,18 @@
+describe DParse::Parsers::Intersperse do
+  let(:a) { DParse::Parsers::Char.new('a') }
+  let(:b) { DParse::Parsers::Char.new(',') }
+  let(:parser) { described_class.new(a, b) }
+
+  example { expect(parser).to parse('a').up_to(1) }
+  example { expect(parser).to parse('a,a').up_to(3) }
+  example { expect(parser).to parse('a,a,a').up_to(5) }
+
+  example { expect(parser).to parse('a,').up_to(1) }
+  example { expect(parser).to parse('a,a,').up_to(3) }
+
+  example { expect(parser).not_to parse('') }
+  example { expect(parser).not_to parse(',') }
+  example { expect(parser).not_to parse(',a') }
+  example { expect(parser).not_to parse(',a,') }
+  example { expect(parser).not_to parse(',a,a') }
+end

data/spec/d-parse/parsers/json_spec.rb

@@ -0,0 +1,69 @@
+describe DParse::Parsers::JSON do
+  let(:parser) do
+    DParse::Parsers::Seq.new(
+      described_class.new,
+      DParse::Parsers::EOF.new,
+    ).first
+  end
+
+  let(:input) do
+    '{"name": "Denis", "favourite_animals": ["donkey", "giraffe"], "nothing": null, "yup": true, "nope": false, "one": 1, "zero": 0, "two": 2, "object": {"foo":"bar"} }'
+  end
+
+  let(:expected_capture) do
+    {
+      'name' => 'Denis',
+      'favourite_animals' => %w(donkey giraffe),
+      'nothing' => nil,
+      'yup' => true,
+      'nope' => false,
+      'one' => 1,
+      'zero' => 0,
+      'two' => 2,
+      'object' => { 'foo' => 'bar' },
+    }
+  end
+
+  example { expect(parser).to parse(input).up_to(163).and_capture(expected_capture) }
+
+  example { expect(parser).to parse('{"a":"b"}').and_capture('a' => 'b') }
+  example { expect(parser).to parse('{ "a" : "b" }').and_capture('a' => 'b') }
+  example { expect(parser).to parse("{\t\"a\"\t:\t\"b\"\t}").and_capture('a' => 'b') }
+  example { expect(parser).to parse("{\r\"a\"\r:\r\"b\"\r}").and_capture('a' => 'b') }
+  example { expect(parser).to parse("{\n\"a\"\n:\n\"b\"\n}").and_capture('a' => 'b') }
+
+  example { expect(parser).to parse('{"num":0}').up_to(9).and_capture('num' => 0) }
+  example { expect(parser).to parse('{"nu m":0}').up_to(10).and_capture('nu m' => 0) }
+  example { expect(parser).to parse('{"nu\"m":0}').up_to(11).and_capture('nu"m' => 0) }
+  example { expect(parser).to parse('{"nu\\\\m":0}').up_to(11).and_capture('nu\\m' => 0) }
+  example { expect(parser).to parse('{"nu\\/m":0}').up_to(11).and_capture('nu/m' => 0) }
+  example { expect(parser).to parse('{"nu\\bm":0}').up_to(11).and_capture("nu\bm" => 0) }
+  example { expect(parser).to parse('{"nu\\fm":0}').up_to(11).and_capture("nu\fm" => 0) }
+  example { expect(parser).to parse('{"nu\\nm":0}').up_to(11).and_capture("nu\nm" => 0) }
+  example { expect(parser).to parse('{"nu\\rm":0}').up_to(11).and_capture("nu\rm" => 0) }
+  example { expect(parser).to parse('{"nu\\tm":0}').up_to(11).and_capture("nu\tm" => 0) }
+  example { expect(parser).to parse('{"nu\\u0000m":0}').up_to(15).and_capture("nu\u0000m" => 0) }
+  example { expect(parser).to parse('{"nu\\u0020m":0}').up_to(15).and_capture('nu m' => 0) }
+
+  example { expect(parser).to parse('{"num":0}').up_to(9).and_capture('num' => 0) }
+  example { expect(parser).to parse('{"num":-0}').up_to(10).and_capture('num' => 0) }
+  example { expect(parser).to parse('{"num":3}').up_to(9).and_capture('num' => 3) }
+  example { expect(parser).to parse('{"num":-3}').up_to(10).and_capture('num' => -3) }
+  example { expect(parser).to parse('{"num":0.1}').up_to(11).and_capture('num' => 0.1) }
+  example { expect(parser).to parse('{"num":-0.1}').up_to(12).and_capture('num' => -0.1) }
+
+  example { expect(parser).to parse('{"num":0e1}').up_to(11).and_capture('num' => 0) }
+  example { expect(parser).to parse('{"num":0E1}').up_to(11).and_capture('num' => 0) }
+  example { expect(parser).to parse('{"num":0e2}').up_to(11).and_capture('num' => 0) }
+  example { expect(parser).to parse('{"num":0E2}').up_to(11).and_capture('num' => 0) }
+
+  example { expect(parser).to parse('{"num":2e1}').up_to(11).and_capture('num' => 20) }
+  example { expect(parser).to parse('{"num":2E1}').up_to(11).and_capture('num' => 20) }
+  example { expect(parser).to parse('{"num":2e2}').up_to(11).and_capture('num' => 200) }
+  example { expect(parser).to parse('{"num":2E2}').up_to(11).and_capture('num' => 200) }
+
+  example { expect(parser).to parse('{"num":2.1e1}').up_to(13).and_capture('num' => 21.0) }
+  example { expect(parser).to parse('{"num":2.1E1}').up_to(13).and_capture('num' => 21.0) }
+  example { expect(parser).to parse('{"num":2.1e2}').up_to(13).and_capture('num' => 210.0) }
+  example { expect(parser).to parse('{"num":2.1E2}').up_to(13).and_capture('num' => 210.0) }
+end

data/spec/d-parse/parsers/lazy_spec.rb

@@ -0,0 +1,16 @@
+describe DParse::Parsers::Lazy do
+  let(:char) { DParse::Parsers::Char.new('a') }
+  let(:parser) { described_class.new { char } }
+
+  example { expect(parser).to parse('a').up_to(1) }
+  example { expect(parser).to parse('aa').up_to(1) }
+  example { expect(parser).to parse('ab').up_to(1) }
+  example { expect(parser).not_to parse('') }
+  example { expect(parser).not_to parse('b') }
+
+  describe '#inspect' do
+    subject { parser.inspect }
+
+    it { is_expected.to eql('lazy(?)') }
+  end
+end

data/spec/d-parse/parsers/map_spec.rb

@@ -0,0 +1,54 @@
+describe DParse::Parsers::Map do
+  let(:inner_parser) { double(:parser) }
+  let(:parser) { described_class.new(inner_parser) { |data, res, orig_pos| [:mapped, data, res.class.to_s, orig_pos.index] } }
+
+  describe '#apply / #read' do
+    subject { parser.apply('a') }
+
+    context 'success' do
+      before do
+        expect(inner_parser).to receive(:read).and_return(
+          DParse::Success.new(
+            '…',
+            DParse::Position.new(index: 10, line: 2, column: 3),
+            best_failure: DParse::Failure.new(
+              '…',
+              DParse::Position.new(index: 20, line: 4, column: 6),
+            ),
+          ),
+        )
+      end
+
+      it 'retains successness' do
+        expect(subject).to be_a(DParse::Success)
+      end
+
+      it 'retains position' do
+        expect(subject.pos.index).to eql(10)
+        expect(subject.pos.line).to eql(2)
+        expect(subject.pos.column).to eql(3)
+      end
+
+      it 'maps data' do
+        expect(subject.data).to eql([:mapped, nil, 'DParse::Success', 0])
+      end
+
+      it 'retains best_failure' do
+        expect(subject.best_failure).to be_a(DParse::Failure)
+        expect(subject.best_failure.pos.index).to eql(20)
+        expect(subject.best_failure.pos.line).to eql(4)
+        expect(subject.best_failure.pos.column).to eql(6)
+      end
+    end
+  end
+
+  describe '#inspect' do
+    subject { parser.inspect }
+
+    before do
+      expect(inner_parser).to receive(:inspect).and_return('test_parser()')
+    end
+
+    it { is_expected.to eql('map(test_parser(), <proc>)') }
+  end
+end

data/spec/d-parse/parsers/optional_spec.rb

@@ -0,0 +1,16 @@
+describe DParse::Parsers::Opt do
+  let(:char) { DParse::Parsers::Char.new('a') }
+  let(:parser) { described_class.new(char) }
+
+  example { expect(parser).to parse('a').up_to(1) }
+  example { expect(parser).to parse('b').up_to(0) }
+  example { expect(parser).to parse('ab').up_to(1) }
+  example { expect(parser).to parse('ba').up_to(0) }
+  example { expect(parser).to parse('').up_to(0) }
+
+  describe '#inspect' do
+    subject { parser.inspect }
+
+    it { is_expected.to eql('alt(char("a"),succeed())') }
+  end
+end

data/spec/d-parse/parsers/or_spec.rb

@@ -0,0 +1,26 @@
+describe DParse::Parsers::Alt do
+  let(:a) { DParse::Parsers::Char.new('a') }
+  let(:b) { DParse::Parsers::Char.new('b') }
+  let(:parser) { described_class.new(a, b) }
+
+  example { expect(parser).to parse('a') }
+  example { expect(parser).to parse('aa') }
+  example { expect(parser).to parse('ab') }
+  example { expect(parser).to parse('ac') }
+  example { expect(parser).to parse('b') }
+  example { expect(parser).to parse('ba') }
+  example { expect(parser).to parse('bb') }
+  example { expect(parser).to parse('bc') }
+
+  example { expect(parser).not_to parse('') }
+  example { expect(parser).not_to parse('c') }
+  example { expect(parser).not_to parse('ca') }
+  example { expect(parser).not_to parse('cb') }
+  example { expect(parser).not_to parse('cc') }
+
+  describe '#inspect' do
+    subject { parser.inspect }
+
+    it { is_expected.to eql('alt(char("a"),char("b"))') }
+  end
+end

data/spec/d-parse/parsers/repeat_spec.rb

@@ -0,0 +1,40 @@
+describe DParse::Parsers::Repeat do
+  let(:char) { DParse::Parsers::Char.new('a') }
+  let(:parser) { described_class.new(char) }
+
+  example { expect(parser).to parse('').up_to(0) }
+  example { expect(parser).to parse('b').up_to(0) }
+  example { expect(parser).to parse('a').up_to(1) }
+  example { expect(parser).to parse('ab').up_to(1) }
+  example { expect(parser).to parse('aa').up_to(2) }
+  example { expect(parser).to parse('aab').up_to(2) }
+  example { expect(parser).to parse('aaa').up_to(3) }
+  example { expect(parser).to parse('aaab').up_to(3) }
+
+  describe '#inspect' do
+    subject { parser.inspect }
+
+    it { is_expected.to eql('repeat(char("a"))') }
+  end
+
+  context 'successes with associated failures' do
+    let(:parser) { described_class.new(DParse::Parsers::String.new('hello')) }
+
+    it 'picks the most specific failure' do
+      expect(parser.apply('hell')).to be_a(DParse::Success)
+      expect(parser.apply('hell').pos.index).to eql(0)
+      expect(parser.apply('hell').best_failure).to be_a(DParse::Failure)
+      expect(parser.apply('hell').best_failure.pos.index).to eql(4)
+
+      expect(parser.apply('hello')).to be_a(DParse::Success)
+      expect(parser.apply('hello').pos.index).to eql(5)
+      expect(parser.apply('hello').best_failure).to be_a(DParse::Failure)
+      expect(parser.apply('hello').best_failure.pos.index).to eql(5)
+
+      expect(parser.apply('helloh')).to be_a(DParse::Success)
+      expect(parser.apply('helloh').pos.index).to eql(5)
+      expect(parser.apply('helloh').best_failure).to be_a(DParse::Failure)
+      expect(parser.apply('helloh').best_failure.pos.index).to eql(6)
+    end
+  end
+end

data/spec/d-parse/parsers/sequence_spec.rb

@@ -0,0 +1,52 @@
+describe DParse::Parsers::Seq do
+  let(:char_a) { DParse::Parsers::Char.new('a') }
+  let(:char_b) { DParse::Parsers::Char.new('b') }
+  let(:parser) { described_class.new(char_a, char_b) }
+
+  example { expect(parser).not_to parse('').and_fail_at(0).line(0).column(0).with_failure('expected \'a\'') }
+  example { expect(parser).not_to parse('a').and_fail_at(1).line(0).column(1).with_failure('expected \'b\'') }
+  example { expect(parser).not_to parse('ac').and_fail_at(1).line(0).column(1).with_failure('expected \'b\'') }
+  example { expect(parser).not_to parse('b').and_fail_at(0).line(0).column(0).with_failure('expected \'a\'') }
+  example { expect(parser).not_to parse('ba').and_fail_at(0).line(0).column(0).with_failure('expected \'a\'') }
+
+  example { expect(parser).to parse('ab').up_to(2) }
+  example { expect(parser).to parse('aba').up_to(2) }
+  example { expect(parser).to parse('abb').up_to(2) }
+
+  describe '#inspect' do
+    subject { parser.inspect }
+
+    it { is_expected.to eql('seq(char("a"),char("b"))') }
+  end
+
+  context 'successes with associated failures' do
+    let(:a) { double('parser') }
+    let(:b) { double('parser') }
+
+    before do
+      expect(a).to receive(:read).and_return(
+        DParse::Success.new(
+          '…',
+          DParse::Position.new(index: 1, line: 0, column: 1),
+          best_failure: DParse::Failure.new(
+            '…',
+            DParse::Position.new(index: 20, line: 0, column: 20),
+          ),
+        ),
+      )
+
+      expect(b).to receive(:read).and_return(
+        DParse::Failure.new(
+          '…',
+          DParse::Position.new(index: 10, line: 0, column: 10),
+        ),
+      )
+    end
+
+    let(:parser) { described_class.new(a, b) }
+
+    it 'picks the most specific failure' do
+      expect(parser).not_to parse('…').and_fail_at(20).line(0).column(20)
+    end
+  end
+end