plurimath-parslet 3.0.0

data/spec/parslet/transform_spec.rb

@@ -0,0 +1,183 @@
+require 'spec_helper'
+
+require 'parslet'
+
+describe Parslet::Transform do
+  include Parslet
+  
+  let(:transform) { Parslet::Transform.new }
+  
+  class A < Struct.new(:elt); end
+  class B < Struct.new(:elt); end
+  class C < Struct.new(:elt); end
+  class Bi < Struct.new(:a, :b); end
+
+  describe "delayed construction" do
+    context "given simple(:x) => A.new(x)" do
+      before(:each) do
+        transform.rule(simple(:x)) { |d| A.new(d[:x]) }
+      end
+
+      it "should transform 'a' into A.new('a')" do
+        transform.apply('a').should == A.new('a')
+      end 
+      it "should transform ['a', 'b'] into [A.new('a'), A.new('b')]" do
+        transform.apply(['a', 'b']).should == 
+          [A.new('a'), A.new('b')]
+      end
+    end
+    context "given rules on {:a => simple(:x)} and {:b => :_x}" do
+      before(:each) do
+        transform.rule(:a => simple(:x)) { |d| A.new(d[:x]) }
+        transform.rule(:b => simple(:x)) { |d| B.new(d[:x]) }
+      end
+
+      it "should transform {:d=>{:b=>'c'}} into d => B('c')" do
+        transform.apply({:d=>{:b=>'c'}}).should == {:d => B.new('c')}
+      end
+      it "should transform {:a=>{:b=>'c'}} into A(B('c'))" do
+        transform.apply({:a=>{:b=>'c'}}).should == A.new(B.new('c'))
+      end
+    end
+    describe "pulling out subbranches" do
+      before(:each) do
+        transform.rule(:a => {:b => simple(:x)}, :d => {:e => simple(:y)}) { |d|
+          Bi.new(*d.values_at(:x, :y))
+        }
+      end
+
+      it "should yield Bi.new('c', 'f')" do
+        transform.apply(:a => {:b => 'c'}, :d => {:e => 'f'}).should ==
+          Bi.new('c', 'f')
+      end 
+    end
+  end
+  describe "dsl construction" do
+    let(:transform) { Parslet::Transform.new do
+        rule(simple(:x)) { A.new(x) }
+      end 
+    }
+    
+    it "should still evaluate rules correctly" do
+      transform.apply('a').should == A.new('a')
+    end 
+  end
+  describe "class construction" do
+    class OptimusPrime < Parslet::Transform 
+      rule(:a => simple(:x)) { A.new(x) }
+      rule(:b => simple(:x)) { B.new(x) }
+    end
+    let(:transform) { OptimusPrime.new }
+    
+    it "should evaluate rules" do
+      transform.apply(:a => 'a').should == A.new('a')
+    end
+
+    context "optionally raise when no match found" do
+      class BumbleBee < Parslet::Transform
+        def initialize(&block)
+          super(raise_on_unmatch: true, &block)
+        end
+        rule(:a => simple(:x)) { A.new(x) }
+      end
+      let(:transform) { BumbleBee.new }
+
+      it "should evaluate rules" do
+        transform.apply(:a => 'a').should == A.new('a')
+      end
+
+      it "should raise when no rules are matched" do
+        lambda {
+          transform.apply(:z => 'z')
+        }.should raise_error(NotImplementedError, /Failed to match/)
+      end
+    end
+
+    context "with inheritance" do
+      class OptimusPrimeJunior < OptimusPrime
+        rule(:b => simple(:x)) { B.new(x.upcase) }
+        rule(:c => simple(:x)) { C.new(x) }
+      end
+      let(:transform) { OptimusPrimeJunior.new }
+
+      it "should inherit rules from its parent" do
+        transform.apply(:a => 'a').should == A.new('a')
+      end
+
+      it "should be able to override rules from its parent" do
+        transform.apply(:b => 'b').should == B.new('B')
+      end
+
+      it "should be able to define new rules" do
+        transform.apply(:c => 'c').should == C.new('c')
+      end
+    end
+  end
+  describe "<- #call_on_match" do
+    let(:bindings) { { :foo => 'test' } }
+    context "when given a block of arity 1" do
+      it "should call the block" do
+        called = false
+        transform.call_on_match(bindings, lambda do |dict|
+          called = true
+        end)
+        
+        called.should == true
+      end 
+      it "should yield the bindings" do
+        transform.call_on_match(bindings, lambda do |dict|
+          dict.should == bindings
+        end)
+      end
+      it "should execute in the current context"  do
+        foo = 'test'
+        transform.call_on_match(bindings, lambda do |dict|
+          foo.should == 'test'
+        end)
+      end
+    end
+    context "when given a block of arity 0" do
+      it "should call the block" do
+        called = false
+        transform.call_on_match(bindings, proc do 
+          called = true
+        end)
+        
+        called.should == true
+      end 
+      it "should have bindings as local variables" do
+        transform.call_on_match(bindings, proc do
+          foo.should == 'test'
+        end)
+      end
+      it "should execute in its own context" do
+        @bar = 'test'
+        transform.call_on_match(bindings, proc do
+          if instance_variable_defined?("@bar")
+            instance_variable_get("@bar").should_not == 'test'
+          end
+        end)
+      end
+    end
+  end
+  
+  context "various transformations (regression)" do
+    context "hashes" do
+      it "are matched completely" do
+        transform.rule(:a => simple(:x)) { fail }
+        transform.apply(:a => 'a', :b => 'b')
+      end 
+    end
+  end
+  
+  context "when not using the bindings as hash, but as local variables" do
+    it "should access the variables" do
+      transform.rule(simple(:x)) { A.new(x) }
+      transform.apply('a').should == A.new('a')
+    end
+    it "should allow context as local variable" do
+      transform.rule(simple(:x)) { foo }
+      transform.apply('a', :foo => 'bar').should == 'bar'
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative 'support/opal' if RUBY_ENGINE == 'opal'
+
+require 'parslet'
+require 'parslet/rig/rspec'
+require 'parslet/atoms/visitor'
+
+# Load custom matchers
+require_relative 'support/parslet_matchers'
+
+begin
+  require 'ae'
+rescue LoadError
+  # AE not available
+end
+
+RSpec.configure do |config|
+  # Allow both old and new syntax for backward compatibility
+  config.expect_with :rspec do |expectations|
+    expectations.syntax = %i[should expect]
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # Use rspec mocks
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  # Shared context and examples
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+  # This is not a Rails project, so no Rails-specific configuration needed
+
+  # Exclude other ruby versions by giving :ruby => '2.7' or :ruby => '3.0'
+  config.filter_run_excluding ruby: lambda { |version|
+    RUBY_VERSION !~ /^#{Regexp.escape(version.to_s)}/
+  }
+
+  # Run specs in random order to surface order dependencies
+  config.order = :random
+  Kernel.srand config.seed
+end
+
+def catch_failed_parse
+  exception = nil
+  begin
+    yield
+  rescue Parslet::ParseFailed => e
+    exception = e
+  end
+  exception&.parse_failure_cause
+end
+
+def slet(name, &block)
+  let(name, &block)
+  subject(&block)
+end
+
+# Helper method to convert Parslet::Slice objects to plain strings for comparison
+def strip_positions(obj)
+  case obj
+  when Parslet::Slice
+    obj.to_s
+  when Hash
+    obj.transform_values { |v| strip_positions(v) }
+  when Array
+    obj.map { |item| strip_positions(item) }
+  when String
+    obj.gsub(/@\d+/, '') # Remove slice of text
+  else
+    obj
+  end
+end

data/spec/support/opal.rb

@@ -0,0 +1,8 @@
+# A set of patches required to run Opal-RSpec
+require 'nodejs/yaml'
+
+module AE
+  # Compile in AE metadata
+  @metadata =
+    { 'revision' => 2013, 'type' => 'ruby', 'sources' => ['var'], 'authors' => [{ 'name' => 'Trans', 'email' => 'transfire@gmail.com' }], 'organizations' => [], 'requirements' => [{ 'name' => 'ansi' }, { 'groups' => ['build'], 'development' => true, 'name' => 'detroit' }, { 'groups' => ['test'], 'development' => true, 'name' => 'qed' }], 'conflicts' => [], 'alternatives' => [], 'resources' => [{ 'type' => 'home', 'uri' => 'http://rubyworks.github.com/ae', 'label' => 'Homepage' }, { 'type' => 'code', 'uri' => 'http://github.com/rubyworks/ae', 'label' => 'Source Code' }, { 'type' => 'docs', 'uri' => 'http://rubydoc.info/gems/ae', 'label' => 'Documentation' }, { 'type' => 'wiki', 'uri' => 'http://wiki.github.com/rubyworks/ae', 'label' => 'User Guide' }, { 'type' => 'bugs', 'uri' => 'http://github.com/rubyworks/ae/issues', 'label' => 'Issue Tracker' }, { 'type' => 'mail', 'uri' => 'http://groups.google.com/group/rubyworks-mailinglist', 'label' => 'Mailing List' }], 'repositories' => [{ 'name' => 'upstream', 'scm' => 'git', 'uri' => 'git://github.com/rubyworks/ae.git' }], 'categories' => [], 'copyrights' => [{ 'holder' => 'Rubyworks', 'year' => '2008', 'license' => 'BSD-2-Clause' }], 'customs' => [], 'paths' => { 'lib' => ['lib'] }, 'created' => '2008-08-17', 'summary' => 'Assertive Expressive', 'title' => 'AE', 'version' => '1.8.2', 'name' => 'ae', 'description' => "Assertive Expressive is an assertions library specifically designed \nfor reuse by other test frameworks.", 'date' => '2013-02-18' }
+end

data/spec/support/opal.rb.erb

@@ -0,0 +1,14 @@
+# A set of patches required to run Opal-RSpec
+require 'nodejs/yaml'
+
+module AE
+  # Compile in AE metadata
+  @metadata = (
+      <%=
+        require 'yaml'
+        YAML.load(
+          File.read(
+            File.expand_path('lib/ae.yml', Gem::Specification.find_by_name('ae').gem_dir)))
+      %>
+    )
+end

data/spec/support/parslet_matchers.rb

@@ -0,0 +1,96 @@
+# Custom RSpec matchers for Parslet structures
+# These matchers handle the comparison of Parslet::Slice objects and nested structures
+
+RSpec::Matchers.define :parse_as do |expected|
+  match do |actual|
+    normalize_parslet_structure(actual) == normalize_parslet_structure(expected)
+  end
+
+  failure_message do |actual|
+    "expected #{normalize_parslet_structure(actual)} to parse as #{normalize_parslet_structure(expected)}"
+  end
+
+  failure_message_when_negated do |actual|
+    "expected #{normalize_parslet_structure(actual)} not to parse as #{normalize_parslet_structure(expected)}"
+  end
+
+  def normalize_parslet_structure(obj)
+    case obj
+    when Hash
+      obj.transform_values { |v| normalize_parslet_structure(v) }
+    when Array
+      obj.map { |item| normalize_parslet_structure(item) }
+    when Parslet::Slice
+      obj.to_s
+    else
+      obj
+    end
+  end
+end
+
+RSpec::Matchers.define :match_structure do |expected|
+  match do |actual|
+    deep_match(actual, expected)
+  end
+
+  failure_message do |actual|
+    "expected structure to match:\n#{format_structure(expected)}\n\nbut got:\n#{format_structure(actual)}"
+  end
+
+  def deep_match(actual, expected)
+    case expected
+    when Hash
+      return false unless actual.is_a?(Hash)
+      expected.all? do |key, value|
+        actual.key?(key) && deep_match(actual[key], value)
+      end
+    when Array
+      return false unless actual.is_a?(Array)
+      return false unless actual.length == expected.length
+      actual.zip(expected).all? { |a, e| deep_match(a, e) }
+    when String
+      actual.to_s == expected
+    when Symbol
+      actual.to_s == expected.to_s
+    when Class
+      actual.is_a?(expected)
+    else
+      actual == expected
+    end
+  end
+
+  def format_structure(obj, indent = 0)
+    spaces = "  " * indent
+    case obj
+    when Hash
+      if obj.empty?
+        "{}"
+      else
+        "{\n" + obj.map { |k, v| "#{spaces}  #{k.inspect} => #{format_structure(v, indent + 1)}" }.join(",\n") + "\n#{spaces}}"
+      end
+    when Array
+      if obj.empty?
+        "[]"
+      else
+        "[\n" + obj.map { |item| "#{spaces}  #{format_structure(item, indent + 1)}" }.join(",\n") + "\n#{spaces}]"
+      end
+    when Parslet::Slice
+      obj.to_s.inspect + " (Slice)"
+    else
+      obj.inspect
+    end
+  end
+end
+
+# Helper method to create expected structures more easily
+def slice(str)
+  str
+end
+
+def hash_with(**keys)
+  keys
+end
+
+def array_of(*items)
+  items
+end

metadata

@@ -0,0 +1,240 @@
+--- !ruby/object:Gem::Specification
+name: plurimath-parslet
+version: !ruby/object:Gem::Version
+  version: 3.0.0
+platform: ruby
+authors:
+- Kaspar Schiess
+- Ribose Inc.
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-06-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: A small Ruby library for constructing parsers in the PEG (Parsing Expression
+  Grammar) fashion. This is a fork of the original parslet gem with Opal (JavaScript-based
+  Ruby) compatibility.
+email:
+- open.source@ribose.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- HISTORY.txt
+- LICENSE
+- README.adoc
+- Rakefile
+- lib/parslet.rb
+- lib/parslet/accelerator.rb
+- lib/parslet/accelerator/application.rb
+- lib/parslet/accelerator/engine.rb
+- lib/parslet/atoms.rb
+- lib/parslet/atoms/alternative.rb
+- lib/parslet/atoms/base.rb
+- lib/parslet/atoms/can_flatten.rb
+- lib/parslet/atoms/capture.rb
+- lib/parslet/atoms/context.rb
+- lib/parslet/atoms/dsl.rb
+- lib/parslet/atoms/dynamic.rb
+- lib/parslet/atoms/entity.rb
+- lib/parslet/atoms/ignored.rb
+- lib/parslet/atoms/infix.rb
+- lib/parslet/atoms/lookahead.rb
+- lib/parslet/atoms/named.rb
+- lib/parslet/atoms/re.rb
+- lib/parslet/atoms/repetition.rb
+- lib/parslet/atoms/scope.rb
+- lib/parslet/atoms/sequence.rb
+- lib/parslet/atoms/str.rb
+- lib/parslet/atoms/visitor.rb
+- lib/parslet/cause.rb
+- lib/parslet/context.rb
+- lib/parslet/convenience.rb
+- lib/parslet/error_reporter.rb
+- lib/parslet/error_reporter/contextual.rb
+- lib/parslet/error_reporter/deepest.rb
+- lib/parslet/error_reporter/tree.rb
+- lib/parslet/export.rb
+- lib/parslet/expression.rb
+- lib/parslet/expression/treetop.rb
+- lib/parslet/graphviz.rb
+- lib/parslet/parser.rb
+- lib/parslet/pattern.rb
+- lib/parslet/pattern/binding.rb
+- lib/parslet/position.rb
+- lib/parslet/rig/rspec.rb
+- lib/parslet/scope.rb
+- lib/parslet/slice.rb
+- lib/parslet/source.rb
+- lib/parslet/source/line_cache.rb
+- lib/parslet/transform.rb
+- lib/parslet/version.rb
+- plurimath-parslet.gemspec
+- spec/acceptance/infix_parser_spec.rb
+- spec/acceptance/mixing_parsers_spec.rb
+- spec/acceptance/regression_spec.rb
+- spec/acceptance/repetition_and_maybe_spec.rb
+- spec/acceptance/unconsumed_input_spec.rb
+- spec/examples/boolean_algebra_spec.rb
+- spec/examples/calc_spec.rb
+- spec/examples/capture_spec.rb
+- spec/examples/comments_spec.rb
+- spec/examples/deepest_errors_spec.rb
+- spec/examples/documentation_spec.rb
+- spec/examples/email_parser_spec.rb
+- spec/examples/empty_spec.rb
+- spec/examples/erb_spec.rb
+- spec/examples/ip_address_spec.rb
+- spec/examples/json_spec.rb
+- spec/examples/local_spec.rb
+- spec/examples/mathn_spec.rb
+- spec/examples/minilisp_spec.rb
+- spec/examples/modularity_spec.rb
+- spec/examples/nested_errors_spec.rb
+- spec/examples/optimized_erb_spec.rb
+- spec/examples/parens_spec.rb
+- spec/examples/prec_calc_spec.rb
+- spec/examples/readme_spec.rb
+- spec/examples/scopes_spec.rb
+- spec/examples/seasons_spec.rb
+- spec/examples/sentence_spec.rb
+- spec/examples/simple_xml_spec.rb
+- spec/examples/string_parser_spec.rb
+- spec/fixtures/examples/boolean_algebra.rb
+- spec/fixtures/examples/calc.rb
+- spec/fixtures/examples/capture.rb
+- spec/fixtures/examples/comments.rb
+- spec/fixtures/examples/deepest_errors.rb
+- spec/fixtures/examples/documentation.rb
+- spec/fixtures/examples/email_parser.rb
+- spec/fixtures/examples/empty.rb
+- spec/fixtures/examples/erb.rb
+- spec/fixtures/examples/ip_address.rb
+- spec/fixtures/examples/json.rb
+- spec/fixtures/examples/local.rb
+- spec/fixtures/examples/mathn.rb
+- spec/fixtures/examples/minilisp.rb
+- spec/fixtures/examples/modularity.rb
+- spec/fixtures/examples/nested_errors.rb
+- spec/fixtures/examples/optimized_erb.rb
+- spec/fixtures/examples/parens.rb
+- spec/fixtures/examples/prec_calc.rb
+- spec/fixtures/examples/readme.rb
+- spec/fixtures/examples/scopes.rb
+- spec/fixtures/examples/seasons.rb
+- spec/fixtures/examples/sentence.rb
+- spec/fixtures/examples/simple_xml.rb
+- spec/fixtures/examples/string_parser.rb
+- spec/parslet/atom_results_spec.rb
+- spec/parslet/atoms/alternative_spec.rb
+- spec/parslet/atoms/base_spec.rb
+- spec/parslet/atoms/capture_spec.rb
+- spec/parslet/atoms/combinations_spec.rb
+- spec/parslet/atoms/dsl_spec.rb
+- spec/parslet/atoms/entity_spec.rb
+- spec/parslet/atoms/ignored_spec.rb
+- spec/parslet/atoms/infix_spec.rb
+- spec/parslet/atoms/lookahead_spec.rb
+- spec/parslet/atoms/named_spec.rb
+- spec/parslet/atoms/re_spec.rb
+- spec/parslet/atoms/repetition_spec.rb
+- spec/parslet/atoms/scope_spec.rb
+- spec/parslet/atoms/sequence_spec.rb
+- spec/parslet/atoms/str_spec.rb
+- spec/parslet/atoms/visitor_spec.rb
+- spec/parslet/atoms_spec.rb
+- spec/parslet/convenience_spec.rb
+- spec/parslet/error_reporter/contextual_spec.rb
+- spec/parslet/error_reporter/deepest_spec.rb
+- spec/parslet/error_reporter/tree_spec.rb
+- spec/parslet/export_spec.rb
+- spec/parslet/expression/treetop_spec.rb
+- spec/parslet/minilisp.citrus
+- spec/parslet/minilisp.tt
+- spec/parslet/parser_spec.rb
+- spec/parslet/parslet_spec.rb
+- spec/parslet/pattern_spec.rb
+- spec/parslet/position_spec.rb
+- spec/parslet/rig/rspec_spec.rb
+- spec/parslet/scope_spec.rb
+- spec/parslet/slice_spec.rb
+- spec/parslet/source/line_cache_spec.rb
+- spec/parslet/source_spec.rb
+- spec/parslet/transform/context_spec.rb
+- spec/parslet/transform_spec.rb
+- spec/spec_helper.rb
+- spec/support/opal.rb
+- spec/support/opal.rb.erb
+- spec/support/parslet_matchers.rb
+homepage: https://github.com/plurimath/plurimath-parslet
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/plurimath/plurimath-parslet/issues
+  changelog_uri: https://github.com/plurimath/plurimath-parslet/blob/main/HISTORY.txt
+  documentation_uri: https://kschiess.github.io/parslet/
+  homepage_uri: https://github.com/plurimath/plurimath-parslet
+  source_code_uri: https://github.com/plurimath/plurimath-parslet
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Parser construction library with great error reporting in Ruby.
+test_files: []