myco 0.1.7 → 0.1.8

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

@@ -0,0 +1,663 @@
+
+::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) { |*| ("Constructions")}
+  __category__(:tests).component_eval {(
+    declare_meme(:"AnyCharacter creates a single any instruction", [[:specify, []]], nil, ::Myco.cscope.dup) { |*| (
+      construct = ::Myco.find_constant(:Constructions)::AnyCharacter.new
+      self.assert_equal(
+        construct.sequence,
+        [[
+          :any,
+          1
+        ]]
+      )
+    )}
+    declare_meme(:"Character creates a single char instruction", [[:specify, []]], nil, ::Myco.cscope.dup) { |*| (
+      construct = ::Myco.find_constant(:Constructions)::Character.new({:code => 120})
+      self.assert_equal(
+        construct.sequence,
+        [[
+          :char,
+          120
+        ]]
+      )
+    )}
+    declare_meme(:"CharacterString creates a string of char instructions", [[:specify, []]], nil, ::Myco.cscope.dup) { |*| (
+      construct = ::Myco.find_constant(:Constructions)::CharacterString.new({:codes => [
+        120,
+        121,
+        122
+      ]})
+      self.assert_equal(
+        construct.sequence,
+        [
+          [
+            :char,
+            120
+          ],
+          [
+            :char,
+            121
+          ],
+          [
+            :char,
+            122
+          ]
+        ]
+      )
+    )}
+    declare_meme(:"CharacterSet creates a single charset instruction", [[:specify, []]], nil, ::Myco.cscope.dup) { |*| (
+      construct = ::Myco.find_constant(:Constructions)::CharacterSet.new({:codes => [
+        120,
+        121,
+        122
+      ]})
+      expected_table = [
+        120,
+        121,
+        122
+      ].map { |code| ([
+        code,
+        true
+      ])}.to_h
+      self.assert_equal(
+        construct.sequence,
+        [[
+          :charset,
+          expected_table
+        ]]
+      )
+    )}
+    declare_meme(:"CharacterRange creates a single charrange instruction", [[:specify, []]], nil, ::Myco.cscope.dup) { |*| (
+      construct = ::Myco.find_constant(:Constructions)::CharacterRange.new({
+        :start => 120,
+        :stop => 122
+      })
+      self.assert_equal(
+        construct.sequence,
+        [[
+          :charrange,
+          120,
+          122
+        ]]
+      )
+    )}
+    declare_meme(:"NegativePredicate assembles choice, fail_twice instructions", [[:specify, []]], nil, ::Myco.cscope.dup) { |*| (
+      a = ::Myco.find_constant(:Constructions)::CharacterString.new({:codes => [
+        120,
+        121,
+        122
+      ]})
+      construct = ::Myco.find_constant(:Constructions)::NegativePredicate.new({:inner => a})
+      self.assert_equal(
+        construct.sequence,
+        [
+          [
+            :choice,
+            5
+          ],
+          [
+            :char,
+            120
+          ],
+          [
+            :char,
+            121
+          ],
+          [
+            :char,
+            122
+          ],
+          [:fail_twice]
+        ]
+      )
+    )}
+    declare_meme(:"PositivePredicate assembles choice, commit, fail instructions", [[:specify, []]], nil, ::Myco.cscope.dup) { |*| (
+      a = ::Myco.find_constant(:Constructions)::CharacterString.new({:codes => [
+        120,
+        121,
+        122
+      ]})
+      construct = ::Myco.find_constant(:Constructions)::PositivePredicate.new({:inner => a})
+      self.assert_equal(
+        construct.sequence,
+        [
+          [
+            :choice,
+            7
+          ],
+          [
+            :choice,
+            4
+          ],
+          [
+            :char,
+            120
+          ],
+          [
+            :char,
+            121
+          ],
+          [
+            :char,
+            122
+          ],
+          [
+            :commit,
+            1
+          ],
+          [:fail]
+        ]
+      )
+    )}
+    declare_meme(:"OneOrMore assembles UNOPTIMIZED instructions", [[:specify, []]], nil, ::Myco.cscope.dup) { |*| (
+      a = ::Myco.find_constant(:Constructions)::CharacterString.new({:codes => [
+        120,
+        121,
+        122
+      ]})
+      construct = ::Myco.find_constant(:Constructions)::OneOrMore.new({:inner => a})
+      self.assert_equal(
+        construct.sequence,
+        [
+          [
+            :char,
+            120
+          ],
+          [
+            :char,
+            121
+          ],
+          [
+            :char,
+            122
+          ],
+          [
+            :choice,
+            5
+          ],
+          [
+            :char,
+            120
+          ],
+          [
+            :char,
+            121
+          ],
+          [
+            :char,
+            122
+          ],
+          [
+            :partial_commit,
+            -3
+          ]
+        ]
+      )
+    )}
+    declare_meme(:"ZeroOrOne assembles choice and commit instructions", [[:specify, []]], nil, ::Myco.cscope.dup) { |*| (
+      a = ::Myco.find_constant(:Constructions)::CharacterString.new({:codes => [
+        120,
+        121,
+        122
+      ]})
+      construct = ::Myco.find_constant(:Constructions)::ZeroOrOne.new({:inner => a})
+      self.assert_equal(
+        construct.sequence,
+        [
+          [
+            :choice,
+            5
+          ],
+          [
+            :char,
+            120
+          ],
+          [
+            :char,
+            121
+          ],
+          [
+            :char,
+            122
+          ],
+          [
+            :commit,
+            1
+          ]
+        ]
+      )
+    )}
+    declare_meme(:"ZeroOrMore assembles choice and partial_commit instructions", [[:specify, []]], nil, ::Myco.cscope.dup) { |*| (
+      a = ::Myco.find_constant(:Constructions)::CharacterString.new({:codes => [
+        120,
+        121,
+        122
+      ]})
+      construct = ::Myco.find_constant(:Constructions)::ZeroOrMore.new({:inner => a})
+      self.assert_equal(
+        construct.sequence,
+        [
+          [
+            :choice,
+            5
+          ],
+          [
+            :char,
+            120
+          ],
+          [
+            :char,
+            121
+          ],
+          [
+            :char,
+            122
+          ],
+          [
+            :partial_commit,
+            -3
+          ]
+        ]
+      )
+    )}
+    declare_meme(:"ZeroOrMore<CharacterSet> creates a single span instruction", [[:specify, []]], nil, ::Myco.cscope.dup) { |*| (
+      a = ::Myco.find_constant(:Constructions)::CharacterSet.new({:codes => [
+        120,
+        121,
+        122
+      ]})
+      construct = ::Myco.find_constant(:Constructions)::ZeroOrMore.new({:inner => a})
+      expected_table = [
+        120,
+        121,
+        122
+      ].map { |code| ([
+        code,
+        true
+      ])}.to_h
+      self.assert_equal(
+        construct.sequence,
+        [[
+          :span,
+          expected_table
+        ]]
+      )
+    )}
+    declare_meme(:"OrderedChoice assembles choice and commit instructions", [[:specify, []]], nil, ::Myco.cscope.dup) { |*| (
+      a = ::Myco.find_constant(:Constructions)::CharacterString.new({:codes => [
+        110,
+        111,
+        112
+      ]})
+      b = ::Myco.find_constant(:Constructions)::CharacterString.new({:codes => [
+        120,
+        121,
+        122
+      ]})
+      construct = ::Myco.find_constant(:Constructions)::OrderedChoice.new({
+        :first => a,
+        :second => b
+      })
+      self.assert_equal(
+        construct.sequence,
+        [
+          [
+            :choice,
+            5
+          ],
+          [
+            :char,
+            110
+          ],
+          [
+            :char,
+            111
+          ],
+          [
+            :char,
+            112
+          ],
+          [
+            :commit,
+            4
+          ],
+          [
+            :char,
+            120
+          ],
+          [
+            :char,
+            121
+          ],
+          [
+            :char,
+            122
+          ]
+        ]
+      )
+      a = ::Myco.find_constant(:Constructions)::CharacterString.new({:codes => [
+        110,
+        111,
+        112
+      ]})
+      b = ::Myco.find_constant(:Constructions)::CharacterString.new({:codes => [
+        120,
+        121,
+        122
+      ]})
+      c = ::Myco.find_constant(:Constructions)::CharacterString.new({:codes => [
+        130,
+        131,
+        132
+      ]})
+      construct = ::Myco.find_constant(:Constructions)::OrderedChoice.new({
+        :first => b,
+        :second => c
+      })
+      construct = ::Myco.find_constant(:Constructions)::OrderedChoice.new({
+        :first => a,
+        :second => construct
+      })
+      self.assert_equal(
+        construct.sequence,
+        [
+          [
+            :choice,
+            5
+          ],
+          [
+            :char,
+            110
+          ],
+          [
+            :char,
+            111
+          ],
+          [
+            :char,
+            112
+          ],
+          [
+            :commit,
+            9
+          ],
+          [
+            :choice,
+            5
+          ],
+          [
+            :char,
+            120
+          ],
+          [
+            :char,
+            121
+          ],
+          [
+            :char,
+            122
+          ],
+          [
+            :commit,
+            4
+          ],
+          [
+            :char,
+            130
+          ],
+          [
+            :char,
+            131
+          ],
+          [
+            :char,
+            132
+          ]
+        ]
+      )
+    )}
+    declare_meme(:"Concatenation simply concatenates the operands", [[:specify, []]], nil, ::Myco.cscope.dup) { |*| (
+      a = ::Myco.find_constant(:Constructions)::CharacterString.new({:codes => [
+        110,
+        111,
+        112
+      ]})
+      b = ::Myco.find_constant(:Constructions)::CharacterString.new({:codes => [
+        120,
+        121,
+        122
+      ]})
+      construct = ::Myco.find_constant(:Constructions)::Concatenation.new({
+        :first => a,
+        :second => b
+      })
+      self.assert_equal(
+        construct.sequence,
+        [
+          [
+            :char,
+            110
+          ],
+          [
+            :char,
+            111
+          ],
+          [
+            :char,
+            112
+          ],
+          [
+            :char,
+            120
+          ],
+          [
+            :char,
+            121
+          ],
+          [
+            :char,
+            122
+          ]
+        ]
+      )
+    )}
+    declare_meme(:"NamedCapture assembles capture instructions", [[:specify, []]], nil, ::Myco.cscope.dup) { |*| (
+      a = ::Myco.find_constant(:Constructions)::CharacterString.new({:codes => [
+        120,
+        121,
+        122
+      ]})
+      construct = ::Myco.find_constant(:Constructions)::NamedCapture.new({:inner => a})
+      self.assert_equal(
+        construct.sequence,
+        [
+          [
+            :capture,
+            [:c_start]
+          ],
+          [
+            :char,
+            120
+          ],
+          [
+            :char,
+            121
+          ],
+          [
+            :char,
+            122
+          ],
+          [
+            :capture,
+            [
+              :c_end,
+              construct.captargs
+            ]
+          ]
+        ]
+      )
+    )}
+    declare_meme(:"NamedCapture of ZeroOrMore has a special multiplicit strategy", [[:specify, []]], nil, ::Myco.cscope.dup) { |*| (
+      a = ::Myco.find_constant(:Constructions)::CharacterString.new({:codes => [
+        120,
+        121,
+        122
+      ]})
+      b = ::Myco.find_constant(:Constructions)::ZeroOrMore.new({:inner => a})
+      construct = ::Myco.find_constant(:Constructions)::NamedCapture.new({:inner => b})
+      self.assert_equal(
+        construct.sequence,
+        [
+          [
+            :capture,
+            [:m_start]
+          ],
+          [
+            :choice,
+            6
+          ],
+          [
+            :char,
+            120
+          ],
+          [
+            :char,
+            121
+          ],
+          [
+            :char,
+            122
+          ],
+          [
+            :capture,
+            [
+              :m_split,
+              nil
+            ]
+          ],
+          [
+            :partial_commit,
+            -4
+          ],
+          [
+            :capture,
+            [
+              :m_end,
+              nil
+            ]
+          ]
+        ]
+      )
+    )}
+    declare_meme(:"NamedCapture of OneOrMore has a special multiplicit strategy", [[:specify, []]], nil, ::Myco.cscope.dup) { |*| (
+      a = ::Myco.find_constant(:Constructions)::CharacterString.new({:codes => [
+        120,
+        121,
+        122
+      ]})
+      b = ::Myco.find_constant(:Constructions)::OneOrMore.new({:inner => a})
+      construct = ::Myco.find_constant(:Constructions)::NamedCapture.new({:inner => b})
+      self.assert_equal(
+        construct.sequence,
+        [
+          [
+            :capture,
+            [:m_start]
+          ],
+          [
+            :char,
+            120
+          ],
+          [
+            :char,
+            121
+          ],
+          [
+            :char,
+            122
+          ],
+          [
+            :capture,
+            [
+              :m_split,
+              nil
+            ]
+          ],
+          [
+            :choice,
+            6
+          ],
+          [
+            :char,
+            120
+          ],
+          [
+            :char,
+            121
+          ],
+          [
+            :char,
+            122
+          ],
+          [
+            :capture,
+            [
+              :m_split,
+              nil
+            ]
+          ],
+          [
+            :partial_commit,
+            -4
+          ],
+          [
+            :capture,
+            [
+              :m_end,
+              nil
+            ]
+          ]
+        ]
+      )
+    )}
+    declare_meme(:"Reduction assembles capture instructions", [[:specify, []]], nil, ::Myco.cscope.dup) { |*| (
+      a = ::Myco.find_constant(:Constructions)::CharacterString.new({:codes => [
+        120,
+        121,
+        122
+      ]})
+      construct = ::Myco.find_constant(:Constructions)::Reduction.new({:inner => a})
+      self.assert_equal(
+        construct.sequence,
+        [
+          [
+            :capture,
+            [:r_start]
+          ],
+          [
+            :char,
+            120
+          ],
+          [
+            :char,
+            121
+          ],
+          [
+            :char,
+            122
+          ],
+          [
+            :capture,
+            [
+              :r_end,
+              construct.captargs
+            ]
+          ]
+        ]
+      )
+    )}
+  )}
+)}}.instance)}}.instance

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

@@ -0,0 +1,10 @@
+
+BasicSpec {
+  name: "Grammar"
+  
+  new_grammar: Grammar { }
+  
+  [tests]
+  
+  it "starts with a root rule defined":  assert(new_grammar.rules.root)
+}

data/lib/myco/code_tools/parser/pegleromyces/spec/Grammar.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) { |*| ("Grammar")}
+  declare_meme(:new_grammar, [], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Grammar)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}.instance)}
+  __category__(:tests).component_eval {(declare_meme(:"starts with a root rule defined", [[:it, []]], nil, ::Myco.cscope.dup) { |*| (self.assert(self.new_grammar.rules.root))})}
+)}}.instance)}}.instance

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

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

data/lib/myco/code_tools/parser/pegleromyces/spec/Instructions.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) { |*| ("Instructions")}
+  declare_meme(:instructions, [], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Instructions)], ::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/Machine.test.my

@@ -0,0 +1,13 @@
+
+BasicSpec {
+  name: "Machine"
+  
+  new_machine: Machine { }
+  
+  [tests]
+  
+  it "starts pointing to instruction 0":   assert_equal(new_machine.ip, 0)
+  it "starts pointing to string index 0":  assert_equal(new_machine.idx, 0)
+  it "starts with an empty stack":         assert(new_machine.stack.empty?)
+  it "starts with no captures":            assert(new_machine.captures.empty?)
+}