myco 0.1.7 → 0.1.8

data/lib/myco/code_tools/parser/pegleromyces/spec/Builder.test.my.rb

@@ -0,0 +1,9 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco::Component.new([::Myco.find_constant(:BasicSpec)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:name, [], nil, ::Myco.cscope.dup) { |*| ("Builder")}
+  declare_meme(:new_builder, [], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Builder)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}.instance)}
+  __category__(:tests).component_eval {(declare_meme(:exists, [[:it, []]], nil, ::Myco.cscope.dup) { |*| (self.assert(self.new_builder))})}
+)}}.instance)}}.instance

data/lib/myco/code_tools/parser/pegleromyces/spec/BytecodeInstructions.test.my

@@ -0,0 +1,10 @@
+
+BasicSpec {
+  name: "BytecodeInstructions"
+  
+  instructions: BytecodeInstructions { }
+  
+  [tests]
+  
+  it "exists":  assert(instructions)
+}

data/lib/myco/code_tools/parser/pegleromyces/spec/BytecodeInstructions.test.my.rb

@@ -0,0 +1,9 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco::Component.new([::Myco.find_constant(:BasicSpec)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:name, [], nil, ::Myco.cscope.dup) { |*| ("BytecodeInstructions")}
+  declare_meme(:instructions, [], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:BytecodeInstructions)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}.instance)}
+  __category__(:tests).component_eval {(declare_meme(:exists, [[:it, []]], nil, ::Myco.cscope.dup) { |*| (self.assert(self.instructions))})}
+)}}.instance)}}.instance

data/lib/myco/code_tools/parser/pegleromyces/spec/BytecodeParser.test.my

@@ -0,0 +1,81 @@
+
+BasicSpec {
+  name: "BytecodeParser"
+  
+  new_parser: BytecodeParser { }
+  
+  [tests]
+  
+  it "can match from a tiny grammar": {
+    parser = new_parser
+    parser.grammar = Grammar {
+      [rules]
+      rule root:
+        str('abc') / str('x') + set('Yy') + !str('y') + !!range('a','z') + any
+    }
+    state = parser.parse('xyz')
+    assert_equal(state.end_idx, 3)
+  }
+  
+  it "can match from a grammar with multiplicit patterns": {
+    parser = new_parser
+    parser.grammar = Grammar {
+      [rules]
+      rule root: str('x').+ + str('y').* + str('z').-
+    }
+    state = parser.parse('xxz')
+    assert_equal(state.end_idx, 3)
+  }
+  
+  it "can match from a grammar with rule calls": {
+    parser = new_parser
+    parser.grammar = Grammar {
+      [rules]
+      rule root: unintended / intended
+      rule unintended: abc
+      rule intended: x + any_y + not_y + any_lower
+      
+      rule abc:   str('abc')
+      rule x:     str('x')
+      rule any_y: set('Yy')
+      rule not_y: !str('y')
+      rule lower: range('a','z')
+      rule any_lower: !!lower + any
+    }
+    state = parser.parse('xyz')
+    assert_equal(state.end_idx, 3)
+  }
+  
+  it "skips memoized rule calls without result corruption": {
+    parser = new_parser
+    parser.grammar = Grammar {
+      [rules]
+      rule root: moot
+      rule moot:
+        (array[:root] + str('NO')) / (array[:root] + str('NOPE')) / array[:root]
+      rule array:
+        r(str('[').token(:foo)[:t0] + (!str(']') + any).*[:list] + str(']'))
+          { [:array, t0.line, *list.map(&:to_sym)] }
+    }
+    state = parser.parse('[abc]')
+    assert(state.end_idx)
+    assert_equal(state.result[:root], [:array, 1, :a, :b, :c])
+  }
+  
+  it "can save a parser to a file to load and run it later": {
+    parser = new_parser
+    parser.grammar = Grammar {
+      [rules]
+      rule root: (r(character.+[:clist]) { clist })[:root]
+      rule character: r(any[:text]) { text.to_sym }
+    }
+    state = parser.parse('xyz')
+    assert_equal(state.result.fetch(:root), [:x, :y, :z])
+    parser.save_prototype("/tmp/pegleromyces_output.my.rbc")
+    
+    parser = new_parser
+    parser.load_prototype("/tmp/pegleromyces_output.my.rbc")
+    state = parser.parse('xyz')
+    assert_equal(state.result.fetch(:root), [:x, :y, :z])
+  }
+}

data/lib/myco/code_tools/parser/pegleromyces/spec/BytecodeParser.test.my.rb

@@ -0,0 +1,209 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco::Component.new([::Myco.find_constant(:BasicSpec)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:name, [], nil, ::Myco.cscope.dup) { |*| ("BytecodeParser")}
+  declare_meme(:new_parser, [], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:BytecodeParser)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}.instance)}
+  __category__(:tests).component_eval {(
+    declare_meme(:"can match from a tiny grammar", [[:it, []]], nil, ::Myco.cscope.dup) { |*| (
+      parser = self.new_parser
+      parser.__send__(
+        :grammar=,
+        ::Myco::Component.new([::Myco.find_constant(:Grammar)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+        .tap { |__c__| __c__.__last__ = __c__.component_eval {(__category__(:rules).component_eval {(declare_meme(:root, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.str("abc").__send__(
+          :/,
+          self.str("x")
+        ).__send__(
+          :+,
+          self.set("Yy")
+        ).__send__(
+          :+,
+          self.str("y").__send__(:!)
+        ).__send__(
+          :+,
+          self.range(
+            "a",
+            "z"
+          ).__send__(:!).__send__(:!)
+        ).__send__(
+          :+,
+          self.any
+        ))})})}}.instance
+      )
+      state = parser.parse("xyz")
+      self.assert_equal(
+        state.end_idx,
+        3
+      )
+    )}
+    declare_meme(:"can match from a grammar with multiplicit patterns", [[:it, []]], nil, ::Myco.cscope.dup) { |*| (
+      parser = self.new_parser
+      parser.__send__(
+        :grammar=,
+        ::Myco::Component.new([::Myco.find_constant(:Grammar)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+        .tap { |__c__| __c__.__last__ = __c__.component_eval {(__category__(:rules).component_eval {(declare_meme(:root, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.str("x").__send__(:+).__send__(
+          :+,
+          self.str("y").__send__(:*)
+        ).__send__(
+          :+,
+          self.str("z").__send__(:-)
+        ))})})}}.instance
+      )
+      state = parser.parse("xxz")
+      self.assert_equal(
+        state.end_idx,
+        3
+      )
+    )}
+    declare_meme(:"can match from a grammar with rule calls", [[:it, []]], nil, ::Myco.cscope.dup) { |*| (
+      parser = self.new_parser
+      parser.__send__(
+        :grammar=,
+        ::Myco::Component.new([::Myco.find_constant(:Grammar)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+        .tap { |__c__| __c__.__last__ = __c__.component_eval {(__category__(:rules).component_eval {(
+          declare_meme(:root, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.unintended.__send__(
+            :/,
+            self.intended
+          ))}
+          declare_meme(:unintended, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.abc)}
+          declare_meme(:intended, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.x.__send__(
+            :+,
+            self.any_y
+          ).__send__(
+            :+,
+            self.not_y
+          ).__send__(
+            :+,
+            self.any_lower
+          ))}
+          declare_meme(:abc, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.str("abc"))}
+          declare_meme(:x, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.str("x"))}
+          declare_meme(:any_y, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.set("Yy"))}
+          declare_meme(:not_y, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.str("y").__send__(:!))}
+          declare_meme(:lower, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.range(
+            "a",
+            "z"
+          ))}
+          declare_meme(:any_lower, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.lower.__send__(:!).__send__(:!).__send__(
+            :+,
+            self.any
+          ))}
+        )})}}.instance
+      )
+      state = parser.parse("xyz")
+      self.assert_equal(
+        state.end_idx,
+        3
+      )
+    )}
+    declare_meme(:"skips memoized rule calls without result corruption", [[:it, []]], nil, ::Myco.cscope.dup) { |*| (
+      parser = self.new_parser
+      parser.__send__(
+        :grammar=,
+        ::Myco::Component.new([::Myco.find_constant(:Grammar)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+        .tap { |__c__| __c__.__last__ = __c__.component_eval {(__category__(:rules).component_eval {(
+          declare_meme(:root, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.moot)}
+          declare_meme(:moot, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.array.__send__(
+            :[],
+            :root
+          ).__send__(
+            :+,
+            self.str("NO")
+          ).__send__(
+            :/,
+            self.array.__send__(
+              :[],
+              :root
+            ).__send__(
+              :+,
+              self.str("NOPE")
+            )
+          ).__send__(
+            :/,
+            self.array.__send__(
+              :[],
+              :root
+            )
+          ))}
+          declare_meme(:array, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.str("[").token(:foo).__send__(
+            :[],
+            :t0
+          ).__send__(
+            :+,
+            self.str("]").__send__(:!).__send__(
+              :+,
+              self.any
+            ).__send__(:*).__send__(
+              :[],
+              :list
+            )
+          ).__send__(
+            :+,
+            self.str("]")
+          )) { || ([
+            :array,
+            self.__send__(:t0).line,
+            *self.list.map(&:to_sym)
+          ])})}
+        )})}}.instance
+      )
+      state = parser.parse("[abc]")
+      self.assert(state.end_idx)
+      self.assert_equal(
+        state.result.__send__(
+          :[],
+          :root
+        ),
+        [
+          :array,
+          1,
+          :a,
+          :b,
+          :c
+        ]
+      )
+    )}
+    declare_meme(:"can save a parser to a file to load and run it later", [[:it, []]], nil, ::Myco.cscope.dup) { |*| (
+      parser = self.new_parser
+      parser.__send__(
+        :grammar=,
+        ::Myco::Component.new([::Myco.find_constant(:Grammar)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+        .tap { |__c__| __c__.__last__ = __c__.component_eval {(__category__(:rules).component_eval {(
+          declare_meme(:root, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.character.__send__(:+).__send__(
+            :[],
+            :clist
+          )) { || (self.clist)}.__send__(
+            :[],
+            :root
+          ))}
+          declare_meme(:character, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.any.__send__(
+            :[],
+            :text
+          )) { || (self.text.to_sym)})}
+        )})}}.instance
+      )
+      state = parser.parse("xyz")
+      self.assert_equal(
+        state.result.fetch(:root),
+        [
+          :x,
+          :y,
+          :z
+        ]
+      )
+      parser.save_prototype("/tmp/pegleromyces_output.my.rbc")
+      parser = self.new_parser
+      parser.load_prototype("/tmp/pegleromyces_output.my.rbc")
+      state = parser.parse("xyz")
+      self.assert_equal(
+        state.result.fetch(:root),
+        [
+          :x,
+          :y,
+          :z
+        ]
+      )
+    )}
+  )}
+)}}.instance)}}.instance

data/lib/myco/code_tools/parser/pegleromyces/spec/Constructions.test.my

@@ -0,0 +1,229 @@
+
+BasicSpec {
+  name: "Constructions"
+  
+  [tests]
+  
+  specify "AnyCharacter creates a single any instruction": {
+    construct = Constructions::AnyCharacter.new
+    assert_equal(construct.sequence, [
+      [:any, 1]
+    ])
+  }
+  
+  specify "Character creates a single char instruction": {
+    construct = Constructions::Character.new(code:120)
+    assert_equal(construct.sequence, [
+      [:char, 120]
+    ])
+  }
+  
+  specify "CharacterString creates a string of char instructions": {
+    construct = Constructions::CharacterString.new(codes:[120,121,122])
+    assert_equal(construct.sequence, [
+      [:char, 120]
+      [:char, 121]
+      [:char, 122]
+    ])
+  }
+  
+  specify "CharacterSet creates a single charset instruction": {
+    construct = Constructions::CharacterSet.new(codes:[120,121,122])
+    expected_table = [120,121,122].map |code| { [code,true] }.to_h
+    assert_equal(construct.sequence, [
+      [:charset, expected_table]
+    ])
+  }
+  
+  specify "CharacterRange creates a single charrange instruction": {
+    construct = Constructions::CharacterRange.new(start:120, stop:122)
+    assert_equal(construct.sequence, [
+      [:charrange, 120, 122]
+    ])
+  }
+  
+  specify "NegativePredicate assembles choice, fail_twice instructions": {
+    a = Constructions::CharacterString.new(codes:[120,121,122])
+    construct = Constructions::NegativePredicate.new(inner:a)
+    assert_equal(construct.sequence, [
+      [:choice, 5] # ip+5 == L1
+      [:char, 120]
+      [:char, 121]
+      [:char, 122]
+      [:fail_twice]
+    ])             # (L1)
+  }
+  
+  specify "PositivePredicate assembles choice, commit, fail instructions": {
+    a = Constructions::CharacterString.new(codes:[120,121,122])
+    construct = Constructions::PositivePredicate.new(inner:a)
+    assert_equal(construct.sequence, [
+      [:choice, 7] # ip+7 == L1
+      [:choice, 4] # ip+4 == L2
+      [:char, 120]
+      [:char, 121]
+      [:char, 122]
+      [:commit, 1] # ip+1 == L3 (L2)
+      [:fail]      # (L3)
+    ])             # (L1)
+  }
+  
+  specify "OneOrMore assembles UNOPTIMIZED instructions": {
+    a = Constructions::CharacterString.new(codes:[120,121,122])
+    construct = Constructions::OneOrMore.new(inner:a)
+    assert_equal(construct.sequence, [
+      [:char, 120] # TODO: optimize and eliminate the double specification here
+      [:char, 121]
+      [:char, 122]
+      [:choice, 5] # ip+5 == L2
+      [:char, 120] # (L1)
+      [:char, 121]
+      [:char, 122]
+      [:partial_commit, -3] # ip-3 == L1
+    ])             # (L2)
+  }
+  
+  specify "ZeroOrOne assembles choice and commit instructions": {
+    a = Constructions::CharacterString.new(codes:[120,121,122])
+    construct = Constructions::ZeroOrOne.new(inner:a)
+    assert_equal(construct.sequence, [
+      [:choice, 5] # ip+5 == L1
+      [:char, 120]
+      [:char, 121]
+      [:char, 122]
+      [:commit, 1] # ip+1 == L1
+    ])             # (L1)
+  }
+  
+  specify "ZeroOrMore assembles choice and partial_commit instructions": {
+    a = Constructions::CharacterString.new(codes:[120,121,122])
+    construct = Constructions::ZeroOrMore.new(inner:a)
+    assert_equal(construct.sequence, [
+      [:choice, 5] # ip+5 == L2
+      [:char, 120] # (L1)
+      [:char, 121]
+      [:char, 122]
+      [:partial_commit, -3] # ip-3 == L1
+    ])             # (L2)
+  }
+  
+  specify "ZeroOrMore<CharacterSet> creates a single span instruction": {
+    a = Constructions::CharacterSet.new(codes:[120,121,122])
+    construct = Constructions::ZeroOrMore.new(inner:a)
+    expected_table = [120,121,122].map |code| { [code,true] }.to_h
+    assert_equal(construct.sequence, [
+      [:span, expected_table]
+    ])
+  }
+  
+  specify "OrderedChoice assembles choice and commit instructions": {
+    a = Constructions::CharacterString.new(codes:[110,111,112])
+    b = Constructions::CharacterString.new(codes:[120,121,122])
+    construct = Constructions::OrderedChoice.new(first:a, second:b)
+    assert_equal(construct.sequence, [
+      [:choice, 5] # ip+5 == L1
+      [:char, 110]
+      [:char, 111]
+      [:char, 112]
+      [:commit, 4] # ip+4 == L2
+      [:char, 120] # (L1)
+      [:char, 121]
+      [:char, 122]
+    ])             # (L2)
+    
+    a = Constructions::CharacterString.new(codes:[110,111,112])
+    b = Constructions::CharacterString.new(codes:[120,121,122])
+    c = Constructions::CharacterString.new(codes:[130,131,132])
+    construct = Constructions::OrderedChoice.new(first:b, second:c)
+    construct = Constructions::OrderedChoice.new(first:a, second:construct)
+    assert_equal(construct.sequence, [
+      [:choice, 5] # ip+5 == L1
+      [:char, 110]
+      [:char, 111]
+      [:char, 112]
+      [:commit, 9] # ip+9 == L2
+      [:choice, 5] # ip+5 == L3; (L1)
+      [:char, 120]
+      [:char, 121]
+      [:char, 122]
+      [:commit, 4] # ip+4 == L2
+      [:char, 130] # (L3)
+      [:char, 131]
+      [:char, 132]
+    ])             # (L2)
+  }
+  
+  specify "Concatenation simply concatenates the operands": {
+    a = Constructions::CharacterString.new(codes:[110,111,112])
+    b = Constructions::CharacterString.new(codes:[120,121,122])
+    construct = Constructions::Concatenation.new(first:a, second:b)
+    assert_equal(construct.sequence, [
+      [:char, 110]
+      [:char, 111]
+      [:char, 112]
+      [:char, 120]
+      [:char, 121]
+      [:char, 122]
+    ])
+  }
+  
+  specify "NamedCapture assembles capture instructions": {
+    a = Constructions::CharacterString.new(codes:[120,121,122])
+    construct = Constructions::NamedCapture.new(inner:a)
+    assert_equal(construct.sequence, [
+      [:capture, [:c_start]]
+      [:char, 120]
+      [:char, 121]
+      [:char, 122]
+      [:capture, [:c_end, construct.captargs]]
+    ])
+  }
+  
+  specify "NamedCapture of ZeroOrMore has a special multiplicit strategy": {
+    a = Constructions::CharacterString.new(codes:[120,121,122])
+    b = Constructions::ZeroOrMore.new(inner:a)
+    construct = Constructions::NamedCapture.new(inner:b)
+    assert_equal(construct.sequence, [
+      [:capture, [:m_start]]
+      [:choice, 6]
+      [:char, 120]
+      [:char, 121]
+      [:char, 122]
+      [:capture, [:m_split, null]]
+      [:partial_commit, -4]
+      [:capture, [:m_end, null]]
+    ])
+  }
+  
+  specify "NamedCapture of OneOrMore has a special multiplicit strategy": {
+    a = Constructions::CharacterString.new(codes:[120,121,122])
+    b = Constructions::OneOrMore.new(inner:a)
+    construct = Constructions::NamedCapture.new(inner:b)
+    assert_equal(construct.sequence, [
+      [:capture, [:m_start]]
+      [:char, 120]
+      [:char, 121]
+      [:char, 122]
+      [:capture, [:m_split, null]]
+      [:choice, 6]
+      [:char, 120]
+      [:char, 121]
+      [:char, 122]
+      [:capture, [:m_split, null]]
+      [:partial_commit, -4]
+      [:capture, [:m_end, null]]
+    ])
+  }
+  
+  specify "Reduction assembles capture instructions": {
+    a = Constructions::CharacterString.new(codes:[120,121,122])
+    construct = Constructions::Reduction.new(inner:a)
+    assert_equal(construct.sequence, [
+      [:capture, [:r_start]]
+      [:char, 120]
+      [:char, 121]
+      [:char, 122]
+      [:capture, [:r_end, construct.captargs]]
+    ])
+  }
+}