d-parse 0.1

data/lib/d-parse/version.rb

@@ -0,0 +1,3 @@
+module DParse
+  VERSION = '0.1'.freeze
+end

data/samples/parse-bind

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+require 'd-parse'
+
+include DParse::DSL
+
+digit = chars(*('0'..'9')).capture
+letter = chars(*('a'..'z')).capture
+
+init = alt(char('d'), char('l')).capture
+
+parser_map = {
+  'd' => digit,
+  'l' => letter,
+}
+
+pair =
+  init.bind do |data|
+    new_parser = parser_map[data]
+    new_parser.map { |d| [data, d] }
+  end
+
+parser = repeat(pair)
+
+p parser.apply('lad1d2d3lblc')

data/samples/parse-csv

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+require 'd-parse'
+require 'pp'
+
+data = <<EOS
+first_name,last_name,age
+Denis,Defreyne,29
+EOS
+
+module Grammar
+  extend DParse::DSL
+
+  FIELD = repeat(char_not_in([',', "\n"])).capture
+  LINE = intersperse(FIELD, char(',')).select_even
+  FILE = seq(intersperse(LINE, char("\n")).select_even, eof).first
+end
+
+pp Grammar::FILE.apply(data)

data/samples/parse-errortest

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+require 'd-parse'
+require 'pp'
+
+module MyGrammar
+  extend DParse::DSL
+
+  LETTER =
+    describe(alt(*('a'..'z').map { |c| char(c) }), 'letter')
+
+  IDENTIFIER =
+    describe(
+      repeat(LETTER).capture,
+      'identifier',
+    )
+
+  FUNDEF =
+    seq(
+      describe(IDENTIFIER, 'identifier'),
+      eof,
+    )
+
+  PARSER =
+    alt(
+      string('Hello!'),
+      string('Hello, world!'),
+      string('Hello… ?'),
+    )
+
+  TESTB =
+    seq(
+      alt(
+        seq(string('a+a').capture),
+        seq(string('a').capture),
+      ),
+      eof,
+    )
+end
+
+puts MyGrammar::PARSER.apply('Hello, what?').pretty_message
+puts
+puts MyGrammar::FUNDEF.apply('foo3a').pretty_message
+puts
+puts MyGrammar::TESTB.apply('a+').pretty_message

data/samples/parse-fun

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+
+require 'd-parse'
+require 'pp'
+
+data = <<EOS
+add(1, mul(2, 3))
+mul(2,3)
+EOS
+
+include DParse::DSL
+
+# primitives
+digit = describe(alt(*('0'..'9').map { |c| char(c) }), 'digit')
+letter = describe(alt(*('a'..'z').map { |c| char(c) }), 'letter')
+lparen = char('(')
+rparen = char(')')
+comma = char(',')
+
+# basic
+identifier = describe(seq(letter, repeat(letter)).capture, 'identifier')
+lit = seq(digit, repeat(digit)).capture.map { |d| d.to_i(10) }
+eof_with_opt_nl = seq(opt(char("\n")), eof)
+whitespace = repeat(whitespace_char)
+
+# complex
+funcall = nil
+expression = alt(lazy { funcall }, lit)
+arglist_tail = repeat(seq(comma, whitespace, expression).map { |d| d[2] })
+arglist = seq(expression, arglist_tail).map { |d| [d[0]] + d[1] }
+funcall = seq(identifier, lparen, arglist, rparen).map { |d| [d[0]] + d[2] }
+program = seq(intersperse(expression, char("\n")).select_even, eof_with_opt_nl).first
+
+def eval_expr(expr)
+  case expr
+  when Array
+    case expr[0]
+    when 'add'
+      eval_expr(expr[1]) + eval_expr(expr[2])
+    when 'mul'
+      eval_expr(expr[1]) * eval_expr(expr[2])
+    else
+      raise '???'
+    end
+  when Integer
+    expr
+  else
+    raise '???'
+  end
+end
+
+res = program.apply(data)
+case res
+when DParse::Success
+  exprs = res.data
+  pp exprs
+  exprs.each { |e| p eval_expr(e) }
+when DParse::Failure
+  $stderr.puts res.pretty_message
+  exit 1
+end

data/samples/parse-json

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+require 'd-parse'
+require 'pp'
+
+json = DParse::Parsers::JSON.new
+
+puts "[#{Time.now}] start"
+res = json.apply($stdin.read)
+puts "[#{Time.now}] stop"
+puts
+
+case res
+when DParse::Success
+  pp res.data
+when DParse::Failure
+  puts res.pretty_message
+end

data/samples/parse-readme

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+require 'd-parse'
+
+module Grammar
+  extend DParse::DSL
+
+  DIGIT = char_in('0'..'9')
+
+  ROOT =
+    seq(
+      intersperse(
+        repeat(DIGIT).capture.map { |d| d.to_i(10) },
+        char(',').ignore,
+      ).compact,
+      eof,
+    ).first
+end
+
+res = Grammar::ROOT.apply('1,2,100,582048,07,09')
+case res
+when DParse::Success
+  p res.data
+when DParse::Failure
+  $stderr.puts res.pretty_message
+  exit 1
+end

data/spec/d-parse/failure_spec.rb

@@ -0,0 +1,36 @@
+describe DParse::Failure do
+  let(:failure) { described_class.new("one\ntwo\nthree\nfour\nfive", position, origin: origin) }
+
+  let(:position) { DParse::Position.new(index: 13, line: 2, column: 3) }
+  let(:origin) { double(:origin, expectation_message: expectation_message) }
+  let(:expectation_message) { 'lols' }
+
+  describe '#full_message' do
+    subject { failure.full_message }
+    it { is_expected.to eql('expected lols at line 3, column 4') }
+
+    context 'no origin' do
+      let(:origin) { nil }
+      it { is_expected.to eql('expected ? at line 3, column 4') }
+    end
+  end
+
+  describe '#pretty_message' do
+    subject { failure.pretty_message }
+
+    context 'column 3' do
+      let(:position) { DParse::Position.new(index: 13, line: 2, column: 3) }
+      it { is_expected.to eql("expected lols at line 3, column 4\n\nthr\e[31me\e[0me\n\e[31m   ↑\e[0m") }
+    end
+
+    context 'column 4' do
+      let(:position) { DParse::Position.new(index: 14, line: 2, column: 4) }
+      it { is_expected.to eql("expected lols at line 3, column 5\n\nthre\e[31me\e[0m\n\e[31m    ↑\e[0m") }
+    end
+
+    context 'column 5' do
+      let(:position) { DParse::Position.new(index: 15, line: 2, column: 5) }
+      it { is_expected.to eql("expected lols at line 3, column 6\n\nthree\n\e[31m     ↑\e[0m") }
+    end
+  end
+end

data/spec/d-parse/parser_spec.rb

@@ -0,0 +1,77 @@
+describe DParse::Parser do
+  context 'bare parser' do
+    let(:klass) do
+      Class.new(described_class) do
+      end
+    end
+
+    let(:parser) { klass.new }
+
+    it 'errors on #read' do
+      expect { parser.read('foo', :some_pos) }.to raise_error(NotImplementedError)
+    end
+
+    it 'errors on #inspect' do
+      expect { parser.inspect }.to raise_error(NotImplementedError)
+    end
+  end
+
+  context 'parser returning an array' do
+    let(:klass) do
+      Class.new(described_class) do
+        def initialize(result)
+          @result = result
+        end
+
+        def read(_input, _pos)
+          @result
+        end
+
+        def inspect
+          'sample()'
+        end
+      end
+    end
+
+    let(:result) { DParse::Success.new('…', pos, data: [:a, :b, :c, :d, :e]) }
+    let(:pos) { DParse::Position.new(index: 0, line: 0, column: 0) }
+
+    let(:parser) { klass.new(result) }
+
+    describe '#first' do
+      subject { parser.first }
+      example { expect(subject).to parse('…').and_capture(:a) }
+    end
+
+    describe '#second' do
+      subject { parser.second }
+      example { expect(subject).to parse('…').and_capture(:b) }
+    end
+
+    describe '#select_even' do
+      subject { parser.select_even }
+      example { expect(subject).to parse('…').and_capture([:a, :c, :e]) }
+    end
+
+    describe '#select_odd' do
+      subject { parser.select_odd }
+      example { expect(subject).to parse('…').and_capture([:b, :d]) }
+    end
+
+    describe '#match?' do
+      subject { parser.match?('…') }
+
+      let(:pos) { DParse::Position.new(index: 0, line: 0, column: 0) }
+
+      context 'failure' do
+        let(:result) { DParse::Failure.new('…', pos) }
+        it { is_expected.to equal(false) }
+      end
+
+      context 'success' do
+        let(:result) { DParse::Success.new('…', pos) }
+        it { is_expected.to equal(true) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+describe DParse::Parsers::Alt do
+  let(:a) { DParse::Parsers::String.new('Hello') }
+  let(:b) { DParse::Parsers::String.new('Goodbye') }
+  let(:parser) { described_class.new(a, b) }
+
+  example { expect(parser).to parse('Hello').up_to(5).line(0).column(5) }
+  example { expect(parser).to parse('Goodbye').up_to(7).line(0).column(7) }
+
+  example { expect(parser).not_to parse('').and_fail_at(0).line(0).column(0).with_failure('expected \'H\'') }
+  example { expect(parser).not_to parse('Wilkommen').and_fail_at(0).line(0).column(0).with_failure('expected \'H\'') }
+  example { expect(parser).not_to parse('Hallo').and_fail_at(1).line(0).column(1).with_failure('expected \'e\'') }
+  example { expect(parser).not_to parse('Hellenistic period').and_fail_at(4).line(0).column(4).with_failure('expected \'o\'') }
+
+  describe '#inspect' do
+    subject { parser.inspect }
+
+    let(:a) { DParse::Parsers::Char.new('a') }
+    let(:b) { DParse::Parsers::Char.new('b') }
+
+    it { is_expected.to eql('alt(char("a"),char("b"))') }
+  end
+
+  context 'ambiguous parsers' do
+    let(:a) { double('parser') }
+    let(:b) { double('parser') }
+
+    before do
+      expect(a).to receive(:read).and_return(DParse::Failure.new('…', DParse::Position.new(index: 10, line: 0, column: 10)))
+      expect(b).to receive(:read).and_return(DParse::Failure.new('…', DParse::Position.new(index: 20, line: 0, column: 20)))
+    end
+
+    context 'shortest first' do
+      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
+
+    context 'longest first' do
+      let(:parser) { described_class.new(b, a) }
+
+      it 'picks the most specific failure' do
+        expect(parser).not_to parse('…').and_fail_at(20).line(0).column(20)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+describe DParse::Parsers::Any do
+  let(:parser) { described_class.new }
+
+  example { expect(parser).to parse('a').up_to(1).line(0).column(1) }
+  example { expect(parser).to parse('b').up_to(1).line(0).column(1) }
+  example { expect(parser).to parse('ab').up_to(1).line(0).column(1) }
+
+  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('any()') }
+  end
+end

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

@@ -0,0 +1,31 @@
+describe DParse::Parsers::Bind do
+  let(:a) { DParse::Parsers::Char.new('a') }
+  let(:b) { DParse::Parsers::Char.new('b') }
+
+  let(:init) { DParse::Parsers::Alt.new(a, b).capture }
+
+  let(:parser) do
+    parser_map = {
+      'a' => DParse::Parsers::Char.new('0'),
+      'b' => DParse::Parsers::Char.new('1'),
+    }
+
+    init.bind do |data|
+      new_parser = parser_map[data]
+      new_parser.map { |d| [data, d] }
+    end
+  end
+
+  example { expect(parser).to parse('a0').up_to(2).line(0).column(2) }
+  example { expect(parser).to parse('b1').up_to(2).line(0).column(2) }
+
+  example { expect(parser).not_to parse('').and_fail_at(0).line(0).column(0) }
+  example { expect(parser).not_to parse('a').and_fail_at(1).line(0).column(1) }
+  example { expect(parser).not_to parse('aa').and_fail_at(1).line(0).column(1) }
+  example { expect(parser).not_to parse('ab').and_fail_at(1).line(0).column(1) }
+  example { expect(parser).not_to parse('a1').and_fail_at(1).line(0).column(1) }
+  example { expect(parser).not_to parse('b').and_fail_at(1).line(0).column(1) }
+  example { expect(parser).not_to parse('ba').and_fail_at(1).line(0).column(1) }
+  example { expect(parser).not_to parse('bb').and_fail_at(1).line(0).column(1) }
+  example { expect(parser).not_to parse('b0').and_fail_at(1).line(0).column(1) }
+end

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

@@ -0,0 +1,11 @@
+describe DParse::Parsers::Capturing do
+  let(:any) { DParse::Parsers::Any.new }
+  let(:parser) { described_class.new(any) }
+
+  example { expect(parser).to parse('a').up_to(1).line(0).column(1).and_capture('a') }
+  example { expect(parser).to parse('aa').up_to(1).line(0).column(1).and_capture('a')  }
+  example { expect(parser).to parse('ab').up_to(1).line(0).column(1).and_capture('a')  }
+  example { expect(parser).to parse('ba').up_to(1).line(0).column(1).and_capture('b')  }
+
+  example { expect(parser).not_to parse('').and_fail_at(0).line(0).column(0) }
+end

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

@@ -0,0 +1,22 @@
+describe DParse::Parsers::CharIn do
+  let(:parser) { described_class.new(%w(a b)) }
+
+  example { expect(parser).to parse('a').up_to(1) }
+  example { expect(parser).to parse('b').up_to(1) }
+  example { expect(parser).to parse('ab').up_to(1) }
+  example { expect(parser).to parse('ac').up_to(1) }
+  example { expect(parser).to parse('ba').up_to(1) }
+  example { expect(parser).to parse('bc').up_to(1) }
+
+  example { expect(parser).not_to parse('').and_fail_at(0).line(0).column(0) }
+  example { expect(parser).not_to parse('c').and_fail_at(0).line(0).column(0) }
+  example { expect(parser).not_to parse('d').and_fail_at(0).line(0).column(0) }
+  example { expect(parser).not_to parse('ca').and_fail_at(0).line(0).column(0) }
+  example { expect(parser).not_to parse('db').and_fail_at(0).line(0).column(0) }
+
+  describe '#inspect' do
+    subject { parser.inspect }
+
+    it { is_expected.to eql('alt(char("a"),char("b"))') }
+  end
+end