gullah 0.0.0

data/test/parse_demo_test.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+
+require 'gullah'
+require 'byebug'
+require 'date'
+
+# :stopdoc:
+
+# a test to make sure the demo code for the parse class is telling the truth
+class ParseDemoTest < Minitest::Test
+  class Example
+    extend Gullah
+
+    rule :S, 'NP VP'
+    rule :NP, 'D N'
+    rule :VP, 'V'
+
+    leaf :D, /the/
+    leaf :N, /cat/
+    leaf :V, /sat/
+  end
+
+  def test_example
+    parses = Example.parse 'the cat sat', n: 1
+
+    parse = parses.first
+    assert_equal 1, parse.length
+    assert_equal 8, parse.size
+    assert_equal 'S[NP[D,_ws,N],_ws,VP[V]]', parse.summary
+  end
+end

data/test/precondition_test.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+
+require 'gullah'
+require 'byebug'
+
+# :stopdoc:
+
+class PreconditionTest < Minitest::Test
+  class Balanced
+    extend Gullah
+
+    rule :a, 'a{2}', preconditions: %i[balanced]
+
+    leaf :a, /\S+/
+
+    # we only want a perfectly symmetrical tree
+    def balanced(_name, _start, _end, _text, children)
+      left, *, right = children
+      left.size == right.size
+    end
+  end
+
+  def test_test
+    parses = Balanced.parse 'foo bar baz plugh'
+    assert_equal 1, parses.length, '1 optimal parse'
+    parse = parses.first
+    assert_equal 1, parse.roots.length, 'parse has a root node'
+    root = parse.roots.first
+    assertion = root.subtree
+                    .select(&:nonterminal?)
+                    .all? { |n| n.children.first.size == n.children.last.size }
+    assert assertion, 'the nodes are all balanced'
+  end
+
+  class LeafPrecondition
+    extend Gullah
+
+    rule :phrase, 'word+'
+
+    leaf :word, /\S+/, preconditions: [:not_foo]
+
+    def not_foo(_name, s, e, text, _children)
+      text[s...e] == 'foo' ? :fail : :pass
+    end
+  end
+
+  def test_good_words
+    parse = LeafPrecondition.first 'bar baz plugh'
+    assert_equal 'phrase[word,_ws,word,_ws,word]', parse.summary
+  end
+
+  def test_bad_first
+    parse = LeafPrecondition.first 'foo bar baz plugh'
+    assert_equal ';_ws;phrase[word,_ws,word,_ws,word]', parse.summary
+  end
+
+  def test_bad_middle
+    parse = LeafPrecondition.first 'bar foo baz plugh'
+    assert_equal 'phrase[word,_ws];;_ws;phrase[word,_ws,word]', parse.summary
+  end
+
+  def test_bad_end
+    parse = LeafPrecondition.first 'bar baz plugh foo'
+    assert_equal 'phrase[word,_ws,word,_ws,word,_ws];', parse.summary
+  end
+end

data/test/tests_per_subrule_test.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+
+require 'gullah'
+require 'byebug'
+
+# :stopdoc:
+
+# to verify that if subrules have different tests the tests only apply to the
+# appropriate subrule
+class TestsPerSubruleTest < Minitest::Test
+  class TestsPerLeaf
+    extend Gullah
+
+    rule :phrase, 'noun+'
+
+    leaf :noun, /\bfoo\b/
+    leaf :noun, /\bbar\b/, tests: [:preceding_foo]
+
+    def preceding_foo(node)
+      node.text_before =~ /\bfoo\s*\z/ ? :pass : :fail
+    end
+  end
+
+  def test_just_foos
+    parse = TestsPerLeaf.first 'foo foo foo'
+    # basically, we should get one good parse
+    assert_equal 'phrase[noun,_ws,noun,_ws,noun]', parse.summary
+  end
+
+  def test_just_bars
+    parse = TestsPerLeaf.first 'bar bar bar'
+    assert_equal 'noun;_ws;noun;_ws;noun', parse.summary
+    assert parse.roots.select(&:significant?).all?(&:error?), 'all leaves are errors'
+  end
+
+  def test_foo_bar
+    parse = TestsPerLeaf.first 'foo bar'
+    # again, one good parse
+    assert_equal 'phrase[noun,_ws,noun]', parse.summary
+  end
+
+  def test_foo_bar_bar
+    parse = TestsPerLeaf.first 'foo bar bar'
+    assert_equal 'phrase[noun,_ws,noun,_ws];noun', parse.summary
+    assert_equal 1, parse.roots.select(&:significant?).count(&:error?)
+  end
+end

data/test/tree_walking_test.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+
+require 'gullah'
+require 'byebug'
+
+# :stopdoc:
+
+# test all the tree walking methods on node
+class TreeWalkingTest < Minitest::Test
+  class Quaternary
+    extend Gullah
+
+    rule :b, 'a{4} | b{4}'
+
+    leaf :a, /\S+/
+  end
+
+  def test_tree_walking
+    parses = Quaternary.parse '1 2 3 4  5 6 7 8  9 10 11 12  13 14 15 16'
+    assert_equal 1, parses.length, 'only one optimal parse'
+    parse = parses.first
+    assert_equal 1, parse.roots.length, 'parse has a root node'
+    root = parse.roots.first
+    nine = root.leaves.find { |l| l.text == '9' }
+    assert !nine.nil?, 'found node number 9'
+    assert_equal root, nine.root
+    assert_equal 0, nine.sibling_index
+    assert_nil nine.prior_sibling
+    assert nine.first_child?
+    ls = nine.later_sibling
+    assert !ls.nil?
+    assert_equal ' ', ls.text
+    assert_equal [10, 11, 12], collect(nine.siblings).map(&:to_i)
+    assert_equal [10, 11, 12], collect(nine.later_siblings).map(&:to_i)
+    assert_equal (1..8).to_a, collect(nine.prior.select(&:leaf?)).map(&:to_i)
+    assert_equal (10..16).to_a, collect(nine.later.select(&:leaf?)).map(&:to_i)
+    assert_equal %i[b b], nine.prior.reject(&:leaf?).map(&:name)
+    assert_equal %i[b], nine.later.reject(&:leaf?).map(&:name)
+    assert_equal (9..12).to_a, collect(nine.parent.leaves).map(&:to_i)
+    assert_equal (1..16).to_a, collect(root.leaves).map(&:to_i)
+    ten = root.leaves.find { |l| l.text == '10' }
+    assert !ten.nil?, 'found node number 10'
+    assert !ten.first_child?
+    assert_equal 2, ten.sibling_index
+    assert_equal ' ', ten.prior_sibling.text
+    assert_equal nine, ten.prior_sibling.prior_sibling
+    assert_equal ' ', ten.later_sibling.text
+    assert_equal '11', ten.later_sibling.later_sibling.text
+    assert_equal [9, 11, 12], collect(ten.siblings).map(&:to_i)
+    assert_equal [11, 12], collect(ten.later_siblings).map(&:to_i)
+    assert_equal ten.parent, ten.ancestors.first
+    assert_equal root, ten.ancestors.last
+    assert_equal %i[b b], ten.ancestors.map(&:name)
+    assert root.subtree.include?(root)
+    assert !root.descendants.include?(root)
+    [nine, ten].each do |n|
+      assert root.subtree.include?(n)
+      assert root.descendants.include?(n)
+      assert n.ancestors.include?(root)
+      assert !n.siblings.include?(n)
+    end
+    last_node = nil
+    root.subtree.each do |n|
+      last_node = n
+      assert n.ancestors.include?(root) unless n == root
+      assert !n.ancestors.include?(n)
+      next if n.leaf?
+
+      first, *, last = n.children
+      assert first.first_child?
+      if last
+        assert last.last_child?
+      else
+        assert first.last_child?
+      end
+    end
+    assert_equal root.leaves.last, root.subtree.last
+    assert_equal last_node, root.subtree.last
+  end
+
+  private
+
+  def collect(nodes)
+    nodes.reject(&:ignorable?).map(&:text)
+  end
+end

metadata

@@ -0,0 +1,157 @@
+--- !ruby/object:Gem::Specification
+name: gullah
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- David F. Houghton
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-08-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 9.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 9.1.0
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Gullah is a bottom-up parser generator than can handle errors, ambiguous
+  syntax, and arbitrary matching conditions.
+email: dfhoughton@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- LICENSE
+- README.md
+- Rakefile
+- TODO.md
+- examples/hat.rb
+- examples/trash.rb
+- examples/xml.rb
+- gullah.gemspec
+- lib/gullah.rb
+- lib/gullah/atom.rb
+- lib/gullah/boundary.rb
+- lib/gullah/dotifier.rb
+- lib/gullah/error.rb
+- lib/gullah/hopper.rb
+- lib/gullah/iterator.rb
+- lib/gullah/leaf.rb
+- lib/gullah/node.rb
+- lib/gullah/parse.rb
+- lib/gullah/picker.rb
+- lib/gullah/rule.rb
+- lib/gullah/segment.rb
+- lib/gullah/trash.rb
+- lib/gullah/version.rb
+- test/basic_test.rb
+- test/big_tree_test.rb
+- test/boundary_test.rb
+- test/date_test.rb
+- test/error_test.rb
+- test/json_test.rb
+- test/parse_demo_test.rb
+- test/precondition_test.rb
+- test/tests_per_subrule_test.rb
+- test/tree_walking_test.rb
+homepage: https://rubygems.org/gems/gullah
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.6'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.15
+signing_key:
+specification_version: 4
+summary: A bottom up parser generator
+test_files:
+- test/basic_test.rb
+- test/big_tree_test.rb
+- test/boundary_test.rb
+- test/date_test.rb
+- test/error_test.rb
+- test/json_test.rb
+- test/parse_demo_test.rb
+- test/precondition_test.rb
+- test/tests_per_subrule_test.rb
+- test/tree_walking_test.rb