plurimath-parslet 3.0.0

data/spec/acceptance/regression_spec.rb

@@ -0,0 +1,329 @@
+require 'spec_helper'
+
+require 'parslet'
+
+describe 'Regressions from real examples' do
+  # This parser piece produces on the left a subtree that is keyed (a hash)
+  # and on the right a subtree that is a repetition of such subtrees. I've
+  # for now decided that these would merge into the repetition such that the
+  # return value is an array. This avoids maybe loosing keys/values in a
+  # hash merge.
+  #
+  class ArgumentListParser
+    include Parslet
+
+    rule :argument_list do
+      expression.as(:argument) >>
+        (comma >> expression.as(:argument)).repeat
+    end
+    rule :expression do
+      string
+    end
+    rule :string do
+      str('"') >>
+        (
+          str('\\') >> any |
+          str('"').absent? >> any
+        ).repeat.as(:string) >>
+        str('"') >> space?
+    end
+    rule :comma do
+      str(',') >> space?
+    end
+    rule :space? do
+      space.maybe
+    end
+    rule :space do
+      match("[ \t]").repeat(1)
+    end
+
+    def parse(str)
+      argument_list.parse(str)
+    end
+  end
+  describe ArgumentListParser do
+    let(:instance) { ArgumentListParser.new }
+
+    it 'has method expression' do
+      expect(instance).to respond_to(:expression)
+    end
+
+    it 'parses "arg1", "arg2"' do
+      result = ArgumentListParser.new.parse('"arg1", "arg2"')
+
+      expect(result.size).to eq(2)
+      result.each do |r|
+        r[:argument]
+      end
+    end
+
+    it 'parses "arg1", "arg2", "arg3"' do
+      result = ArgumentListParser.new.parse('"arg1", "arg2", "arg3"')
+
+      expect(result.size).to eq(3)
+      result.each do |r|
+        r[:argument]
+      end
+    end
+  end
+
+  class ParensParser < Parslet::Parser
+    rule(:balanced) do
+      str('(').as(:l) >> balanced.maybe.as(:m) >> str(')').as(:r)
+    end
+
+    root(:balanced)
+  end
+  describe ParensParser do
+    let(:instance) { ParensParser.new }
+
+    context 'statefulness: trying several expressions in sequence' do
+      it 'is not stateful' do
+        # NOTE: Since you've come here to read this, I'll explain why
+        # this is broken and not fixed: You're looking at the tuning branch,
+        # which rewrites a bunch of stuff - so I have failing tests to
+        # remind me of what is left to be done. And to remind you not to
+        # trust this code.
+        instance.parse('(())')
+        expect do
+          instance.parse('((()))')
+          instance.parse('(((())))')
+        end.not_to raise_error
+      end
+    end
+
+    context "expression '(())'" do
+      let(:result) { instance.parse('(())') }
+
+      it 'yields a doubly nested hash' do
+        expect(result).to be_a(Hash)
+        expect(result).to have_key(:m)
+        expect(result[:m]).to be_a(Hash) # This was an array earlier
+      end
+
+      context 'inner hash' do
+        let(:inner) { result[:m] }
+
+        it 'has nil as :m' do
+          expect(inner[:m]).to be_nil
+        end
+      end
+    end
+  end
+
+  class ALanguage < Parslet::Parser
+    root(:expressions)
+
+    rule(:expressions) { (line >> eol).repeat(1) | line }
+    rule(:line) { space? >> an_expression.as(:exp).repeat }
+    rule(:an_expression) { str('a').as(:a) >> space? }
+
+    rule(:eol) { space? >> match["\n\r"].repeat(1) >> space? }
+
+    rule(:space?) { space.repeat }
+    rule(:space) { multiline_comment.as(:multi) | line_comment.as(:line) | str(' ') }
+
+    rule(:line_comment) { str('//') >> (match["\n\r"].absent? >> any).repeat }
+    rule(:multiline_comment) { str('/*') >> (str('*/').absent? >> any).repeat >> str('*/') }
+  end
+  describe ALanguage do
+    def remove_indent(s)
+      s.to_s.lines.map { |l| l.chomp.strip }.join("\n")
+    end
+
+    it 'counts lines correctly' do
+      cause = catch_failed_parse do
+        subject.parse('a
+          a a a 
+          aaa // ff
+          /* 
+          a
+          */
+          b
+        ')
+      end
+
+      expect(remove_indent(cause.ascii_tree)).to eq(remove_indent(%q(
+      Expected one of [(LINE EOL){1, }, LINE] at line 1 char 1.
+      |- Extra input after last repetition at line 7 char 11.
+      |  `- Failed to match sequence (LINE EOL) at line 7 char 11.
+      |     `- Failed to match sequence (SPACE? [\n\r]{1, } SPACE?) at line 7 char 11.
+      |        `- Expected at least 1 of [\n\r] at line 7 char 11.
+      |           `- Failed to match [\n\r] at line 7 char 11.
+      `- Don't know what to do with "\n         " at line 1 char 2.).strip))
+    end
+  end
+
+  class BLanguage < Parslet::Parser
+    root :expression
+    rule(:expression) { b.as(:one) >> b.as(:two) }
+    rule(:b) { str('b') }
+  end
+  describe BLanguage do
+    it "parses 'bb'" do
+      expect(subject).to parse('bb').as(one: 'b', two: 'b')
+    end
+
+    it 'transforms with binding constraint' do
+      transform = Parslet::Transform.new do |t|
+        t.rule(one: simple(:b), two: simple(:b)) { :ok }
+      end
+      expect(transform.apply(subject.parse('bb'))).to eq(:ok)
+    end
+  end
+
+  class UnicodeLanguage < Parslet::Parser
+    root :gobble
+    rule(:gobble) { any.repeat }
+  end
+  describe UnicodeLanguage do
+    it 'parses UTF-8 strings' do
+      expect(subject).to parse('éèäöü').as('éèäöü')
+      expect(subject).to parse('RubyKaigi2009のテーマは、「変わる／変える」です。 前回の').as('RubyKaigi2009のテーマは、「変わる／変える」です。 前回の')
+    end
+  end
+
+  class UnicodeSentenceLanguage < Parslet::Parser
+    rule(:sentence) { (match('[^。]').repeat(1) >> str('。')).as(:sentence) }
+    rule(:sentences) { sentence.repeat }
+    root(:sentences)
+  end
+  describe UnicodeSentenceLanguage do
+    let(:string) do
+      'RubyKaigi2009のテーマは、「変わる／変える」です。 前回の' +
+        'RubyKaigi2008のテーマであった「多様性」の言葉の通り、 ' +
+        '2008年はRubyそのものに関しても、またRubyの活躍する舞台に関しても、 ' +
+        'ますます多様化が進みつつあります。RubyKaigi2008は、そのような ' +
+        'Rubyの生態系をあらためて認識する場となりました。 しかし、' +
+        'こうした多様化が進む中、異なる者同士が単純に距離を 置いたままでは、' +
+        'その違いを認識したところであまり意味がありません。 異なる実装、' +
+        '異なる思想、異なる背景といった、様々な多様性を理解しつつ、 ' +
+        'すり合わせるべきものをすり合わせ、変えていくべきところを ' +
+        '変えていくことが、豊かな未来へとつながる道に違いありません。'
+    end
+
+    it 'parses sentences' do
+      expect(subject).to parse(string)
+    end
+  end
+
+  class TwoCharLanguage < Parslet::Parser
+    root :twochar
+    rule(:twochar) { any >> str('2') }
+  end
+  describe TwoCharLanguage do
+    def di(s)
+      s.strip.to_s.lines.map { |l| l.chomp.strip }.join("\n")
+    end
+
+    it 'raises an error' do
+      error = catch_failed_parse do
+        subject.parse('123')
+      end
+      expect(di(error.ascii_tree)).to eq(di(%q(
+        Failed to match sequence (. '2') at line 1 char 2.
+        `- Don't know what to do with "3" at line 1 char 3.
+      )))
+    end
+  end
+
+  # Issue #68: Extra input reporting, written by jmettraux
+  class RepetitionParser < Parslet::Parser
+    rule(:nl)      { match('[\s]').repeat(1) }
+    rule(:nl?)     { nl.maybe }
+    rule(:sp)      { str(' ').repeat(1) }
+    rule(:sp?)     { str(' ').repeat(0) }
+    rule(:line)    { sp >> str('line') }
+    rule(:body)    { ((line | block) >> nl).repeat(0) }
+    rule(:block)   do
+      sp? >> str('begin') >> sp >> match('[a-z]') >> nl >>
+        body >> sp? >> str('end')
+    end
+    rule(:blocks) { nl? >> block >> (nl >> block).repeat(0) >> nl? }
+
+    root(:blocks)
+  end
+  describe RepetitionParser do
+    def di(s)
+      s.strip.to_s.lines.map { |l| l.chomp.strip }.join("\n")
+    end
+
+    it 'parses a block' do
+      subject.parse('
+        begin a
+        end
+      ')
+    end
+
+    it 'parses nested blocks' do
+      subject.parse('
+        begin a
+          begin b
+          end
+        end
+      ')
+    end
+
+    it 'parses successive blocks' do
+      subject.parse('
+        begin a
+        end
+        begin b
+        end
+      ')
+    end
+
+    it 'fails gracefully on a missing end' do
+      error = catch_failed_parse do
+        subject.parse('
+          begin a
+            begin b
+          end
+        ')
+      end
+
+      expect(di(error.ascii_tree)).to eq(di("
+        Failed to match sequence (NL? BLOCK (NL BLOCK){0, } NL?) at line 2 char 11.
+        `- Failed to match sequence (SP? 'begin' SP [a-z] NL BODY SP? 'end') at line 5 char 9.
+           `- Premature end of input at line 5 char 9.
+        "))
+    end
+
+    it 'fails gracefully on a missing end (2)' do
+      error = catch_failed_parse do
+        subject.parse('
+          begin a
+          end
+          begin b
+            begin c
+          end
+        ')
+      end
+
+      expect(di(error.ascii_tree)).to eq(di(%q(
+        Failed to match sequence (NL? BLOCK (NL BLOCK){0, } NL?) at line 3 char 14.
+        `- Don't know what to do with "begin b\n  " at line 4 char 11.
+        )))
+    end
+
+    it 'fails gracefully on a missing end (deepest reporter)' do
+      error = catch_failed_parse do
+        subject.parse('
+            begin a
+            end
+            begin b
+              begin c
+                li
+              end
+            end
+          ',
+                      reporter: Parslet::ErrorReporter::Deepest.new)
+      end
+
+      expect(di(error.ascii_tree)).to eq(di(%q(
+        Failed to match sequence (NL? BLOCK (NL BLOCK){0, } NL?) at line 3 char 16.
+        `- Expected "end", but got "li\n" at line 6 char 17.
+        )))
+    end
+  end
+end

data/spec/acceptance/repetition_and_maybe_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe 'Tree output' do
+  extend Parslet
+
+  def self.hash_examples(h)
+    h.each do |atom, expected|
+      it "converts #{atom} to #{expected.inspect}" do
+        expect(atom.parse(input)).to eq(expected)
+      end
+    end
+  end
+
+  context 'when parsing the empty string' do
+    let(:input) { '' }
+
+    hash_examples(
+      # No naming
+      str('a').maybe => '',
+      str('a').repeat => '',
+
+      # Named contents: maybe yields nil
+      str('a').maybe.as(:f) => { f: nil },
+      str('a').repeat.as(:f) => { f: [] },
+
+      # Contents that aren't simple strings
+      (str('a') >> str('b')).maybe.as(:f) => { f: nil },
+      (str('a') >> str('b')).repeat.as(:f) => { f: [] },
+
+      # The other way around: Contents would be tagged, but nil result isn't
+      (str('a') >> str('b')).as(:f).maybe => '',
+      (str('a') >> str('b')).as(:f).repeat => '',
+    )
+  end
+
+  context "when parsing 'aa'" do
+    let(:input) { 'aa' }
+
+    hash_examples(
+      # since they're not named, repetitions get merged together.
+      str('a').as(:a).repeat >> str('a').as(:a).repeat => [{ a: 'a' }, { a: 'a' }],
+    )
+  end
+end

data/spec/acceptance/unconsumed_input_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe "Unconsumed input:" do
+  class RepeatingBlockParser < Parslet::Parser
+    root :expressions
+    rule(:expressions) { expression.repeat }
+    rule(:expression) { str('(') >> aab >> str(')') }
+    rule(:aab) { str('a').repeat(1) >> str('b') }
+  end
+  describe RepeatingBlockParser do
+    let(:parser) { described_class.new }
+    it "throws annotated error" do
+      error = catch_failed_parse { parser.parse('(aaac)') }
+    end
+    it "doesn't error out if prefix is true" do
+      expect {
+        parser.parse('(aaac)', :prefix => true)
+      }.not_to raise_error
+    end
+  end
+end

data/spec/examples/boolean_algebra_spec.rb

@@ -0,0 +1,257 @@
+require 'spec_helper'
+require_relative '../fixtures/examples/boolean_algebra'
+
+RSpec.describe 'Boolean Algebra Parser Example' do
+  let(:parser) { MyParser.new }
+  let(:transformer) { Transformer.new }
+
+  describe MyParser do
+    describe '#var' do
+      it 'parses variable names' do
+        result = parser.var.parse('var1')
+        expect(result).to parse_as({ var: '1' })
+      end
+
+      it 'parses multi-digit variables' do
+        result = parser.var.parse('var123')
+        expect(result).to parse_as({ var: '123' })
+      end
+
+      it 'handles trailing space' do
+        result = parser.var.parse('var1 ')
+        expect(result).to parse_as({ var: '1' })
+      end
+    end
+
+    describe '#primary' do
+      it 'parses variables as primary expressions' do
+        result = parser.primary.parse('var1')
+        expect(result).to parse_as({ var: '1' })
+      end
+
+      it 'parses parenthesized expressions' do
+        result = parser.primary.parse('(var1)')
+        expect(result).to parse_as({ var: '1' })
+      end
+
+      it 'parses complex parenthesized expressions' do
+        result = parser.primary.parse('(var1 or var2)')
+        expected = {
+          or: {
+            left: { var: '1' },
+            right: { var: '2' }
+          }
+        }
+        expect(result).to parse_as(expected)
+      end
+    end
+
+    describe '#and_operation' do
+      it 'parses simple AND operations' do
+        result = parser.and_operation.parse('var1 and var2')
+        expected = {
+          and: {
+            left: { var: '1' },
+            right: { var: '2' }
+          }
+        }
+        expect(result).to parse_as(expected)
+      end
+
+      it 'parses chained AND operations (right-associative)' do
+        result = parser.and_operation.parse('var1 and var2 and var3')
+        expected = {
+          and: {
+            left: { var: '1' },
+            right: {
+              and: {
+                left: { var: '2' },
+                right: { var: '3' }
+              }
+            }
+          }
+        }
+        expect(result).to parse_as(expected)
+      end
+
+      it 'parses single variables' do
+        result = parser.and_operation.parse('var1')
+        expect(result).to parse_as({ var: '1' })
+      end
+    end
+
+    describe '#or_operation' do
+      it 'parses simple OR operations' do
+        result = parser.or_operation.parse('var1 or var2')
+        expected = {
+          or: {
+            left: { var: '1' },
+            right: { var: '2' }
+          }
+        }
+        expect(result).to parse_as(expected)
+      end
+
+      it 'parses chained OR operations (right-associative)' do
+        result = parser.or_operation.parse('var1 or var2 or var3')
+        expected = {
+          or: {
+            left: { var: '1' },
+            right: {
+              or: {
+                left: { var: '2' },
+                right: { var: '3' }
+              }
+            }
+          }
+        }
+        expect(result).to parse_as(expected)
+      end
+
+      it 'handles operator precedence (AND binds tighter than OR)' do
+        result = parser.or_operation.parse('var1 or var2 and var3')
+        expected = {
+          or: {
+            left: { var: '1' },
+            right: {
+              and: {
+                left: { var: '2' },
+                right: { var: '3' }
+              }
+            }
+          }
+        }
+        expect(result).to parse_as(expected)
+      end
+    end
+
+    describe 'root parser (or_operation)' do
+      it 'parses the main example: var1 and (var2 or var3)' do
+        input = "var1 and (var2 or var3)"
+        result = parser.parse(input)
+        expected = {
+          and: {
+            left: { var: '1' },
+            right: {
+              or: {
+                left: { var: '2' },
+                right: { var: '3' }
+              }
+            }
+          }
+        }
+        expect(result).to parse_as(expected)
+      end
+
+      it 'handles complex expressions with precedence and parentheses' do
+        result = parser.parse('(var1 and var2) or var3')
+        expected = {
+          or: {
+            left: {
+              and: {
+                left: { var: '1' },
+                right: { var: '2' }
+              }
+            },
+            right: { var: '3' }
+          }
+        }
+        expect(result).to parse_as(expected)
+      end
+    end
+  end
+
+  describe Transformer do
+    it 'transforms variables to DNF arrays' do
+      input = { var: Parslet::Slice.new(Parslet::Position.new("var1", 3), "1") }
+      result = transformer.apply(input)
+      expect(result).to eq([["1"]])
+    end
+
+    it 'transforms OR operations by concatenating arrays' do
+      input = {
+        or: {
+          left: [["1"]],
+          right: [["2"]]
+        }
+      }
+      result = transformer.apply(input)
+      expect(result).to eq([["1"], ["2"]])
+    end
+
+    it 'transforms AND operations by creating cartesian product' do
+      input = {
+        and: {
+          left: [["1"]],
+          right: [["2"]]
+        }
+      }
+      result = transformer.apply(input)
+      expect(result).to eq([["1", "2"]])
+    end
+
+    it 'handles complex AND operations with multiple terms' do
+      input = {
+        and: {
+          left: [["1"], ["2"]],
+          right: [["3"]]
+        }
+      }
+      result = transformer.apply(input)
+      expect(result).to eq([["1", "3"], ["2", "3"]])
+    end
+
+    it 'handles complex OR operations with AND sub-expressions' do
+      input = {
+        and: {
+          left: [["1"]],
+          right: [["2"], ["3"]]
+        }
+      }
+      result = transformer.apply(input)
+      expect(result).to eq([["1", "2"], ["1", "3"]])
+    end
+  end
+
+  describe 'integration test' do
+    it 'processes the main example correctly: var1 and (var2 or var3)' do
+      input = "var1 and (var2 or var3)"
+      tree = parser.parse(input)
+      result = transformer.apply(tree)
+
+      # Expected result: [["1", "2"], ["1", "3"]]
+      # This represents: (var1 AND var2) OR (var1 AND var3)
+      expect(result).to eq([["1", "2"], ["1", "3"]])
+    end
+
+    it 'handles simple OR expressions' do
+      input = "var1 or var2"
+      tree = parser.parse(input)
+      result = transformer.apply(tree)
+      expect(result).to eq([["1"], ["2"]])
+    end
+
+    it 'handles simple AND expressions' do
+      input = "var1 and var2"
+      tree = parser.parse(input)
+      result = transformer.apply(tree)
+      expect(result).to eq([["1", "2"]])
+    end
+
+    it 'handles complex expressions with multiple operators' do
+      input = "(var1 or var2) and (var3 or var4)"
+      tree = parser.parse(input)
+      result = transformer.apply(tree)
+      # Should produce: [["1", "3"], ["1", "4"], ["2", "3"], ["2", "4"]]
+      expect(result).to eq([["1", "3"], ["1", "4"], ["2", "3"], ["2", "4"]])
+    end
+
+    it 'produces the expected output from the example file' do
+      # This matches the exact output shown in the example file
+      input = "var1 and (var2 or var3)"
+      tree = parser.parse(input)
+      result = transformer.apply(tree)
+      expect(result).to eq([["1", "2"], ["1", "3"]])
+    end
+  end
+end