myco 0.1.8 → 0.1.9

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

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

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

@@ -1,9 +0,0 @@
-
-::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

@@ -1,13 +0,0 @@
-
-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?)
-}

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

@@ -1,20 +0,0 @@
-
-::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) { |*| ("Machine")}
-  declare_meme(:new_machine, [], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Machine)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}.instance)}
-  __category__(:tests).component_eval {(
-    declare_meme(:"starts pointing to instruction 0", [[:it, []]], nil, ::Myco.cscope.dup) { |*| (self.assert_equal(
-      self.new_machine.ip,
-      0
-    ))}
-    declare_meme(:"starts pointing to string index 0", [[:it, []]], nil, ::Myco.cscope.dup) { |*| (self.assert_equal(
-      self.new_machine.idx,
-      0
-    ))}
-    declare_meme(:"starts with an empty stack", [[:it, []]], nil, ::Myco.cscope.dup) { |*| (self.assert(self.new_machine.stack.__send__(:empty?)))}
-    declare_meme(:"starts with no captures", [[:it, []]], nil, ::Myco.cscope.dup) { |*| (self.assert(self.new_machine.captures.__send__(:empty?)))}
-  )}
-)}}.instance)}}.instance

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

@@ -1,54 +0,0 @@
-
-BasicSpec {
-  name: "Parser"
-  
-  new_parser: Parser { }
-  
-  basic_grammar: Grammar {
-    c: character_classes
-    
-    [character_classes]
-    upper: range('A','Z')
-    lower: range('a','z') / str('_')
-    num:   range('0','9')
-    alpha: upper / lower
-    spc:   set(" \t\r\f\v")
-    
-    [rules]
-    rule root: expr[:root]
-    rule expr: (array / assign / constant / ident / float / integer)
-    
-    rule sepd_expr: r(c.spc.* + str(',') + c.spc.* + integer[:n0]) { n0 }
-    rule array: r(str('[') + expr[:n0] + sepd_expr.*[:nrest] + str(']'))
-                  { [n0, *nrest] }
-    
-    rule constant: r((c.upper + c.alpha.*)[:text])  { [:constant, text.to_sym] }
-    rule ident:    r((c.lower + c.alpha.*)[:text])  { [:ident,    text.to_sym] }
-    rule integer:  r((str('-').- + c.num.+)[:text]) { [:integer,  text.to_i] }
-    rule float:    r((str('-').- + c.num.+ + str('.') + c.num.+)[:text])
-                                                    { [:float,    text.to_f] }
-    
-    rule assign_lhs: (constant / ident)
-    rule assign_rhs: expr
-    rule assign: r(assign_lhs[:lhs] + c.spc.* + str('=') + c.spc.* +
-                   assign_rhs[:rhs]) { [:assign, lhs, rhs] }
-  }
-  
-  [tests]
-  
-  it "can parse from a basic grammar": {
-    parser = new_parser
-    parser.grammar = basic_grammar
-    
-    examples = [
-      "xyz",           [:ident, :xyz]
-      "_foo = -88.8",  [:assign, [:ident, :"_foo"], [:float, -88.8]]
-      "Foo_BAR=5",     [:assign, [:constant, :"Foo_BAR"], [:integer, 5]]
-      "[99, 99]",      [[:integer, 99], [:integer, 99]]
-    ]
-    
-    examples.each_slice(2) |input, output| {
-      assert_equal(parser.parse(input).result.fetch(:root), output)
-    }
-  }
-}

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

@@ -1,215 +0,0 @@
-
-::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) { |*| ("Parser")}
-  declare_meme(:new_parser, [], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Parser)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}.instance)}
-  declare_meme(:basic_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 {(
-    declare_meme(:c, [], nil, ::Myco.cscope.dup) { |*| (self.character_classes)}
-    __category__(:character_classes).component_eval {(
-      declare_meme(:upper, [], nil, ::Myco.cscope.dup) { |*| (self.range(
-        "A",
-        "Z"
-      ))}
-      declare_meme(:lower, [], nil, ::Myco.cscope.dup) { |*| (self.range(
-        "a",
-        "z"
-      ).__send__(
-        :/,
-        self.str("_")
-      ))}
-      declare_meme(:num, [], nil, ::Myco.cscope.dup) { |*| (self.range(
-        "0",
-        "9"
-      ))}
-      declare_meme(:alpha, [], nil, ::Myco.cscope.dup) { |*| (self.upper.__send__(
-        :/,
-        self.lower
-      ))}
-      declare_meme(:spc, [], nil, ::Myco.cscope.dup) { |*| (self.set(" \t\r\f\v"))}
-    )}
-    __category__(:rules).component_eval {(
-      declare_meme(:root, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.expr.__send__(
-        :[],
-        :root
-      ))}
-      declare_meme(:expr, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.array.__send__(
-        :/,
-        self.assign
-      ).__send__(
-        :/,
-        self.constant
-      ).__send__(
-        :/,
-        self.ident
-      ).__send__(
-        :/,
-        self.float
-      ).__send__(
-        :/,
-        self.integer
-      ))}
-      declare_meme(:sepd_expr, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.c.spc.__send__(:*).__send__(
-        :+,
-        self.str(",")
-      ).__send__(
-        :+,
-        self.c.spc.__send__(:*)
-      ).__send__(
-        :+,
-        self.integer.__send__(
-          :[],
-          :n0
-        )
-      )) { || (self.__send__(:n0))})}
-      declare_meme(:array, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.str("[").__send__(
-        :+,
-        self.expr.__send__(
-          :[],
-          :n0
-        )
-      ).__send__(
-        :+,
-        self.sepd_expr.__send__(:*).__send__(
-          :[],
-          :nrest
-        )
-      ).__send__(
-        :+,
-        self.str("]")
-      )) { || ([
-        self.__send__(:n0),
-        *self.nrest
-      ])})}
-      declare_meme(:constant, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.c.upper.__send__(
-        :+,
-        self.c.alpha.__send__(:*)
-      ).__send__(
-        :[],
-        :text
-      )) { || ([
-        :constant,
-        self.text.to_sym
-      ])})}
-      declare_meme(:ident, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.c.lower.__send__(
-        :+,
-        self.c.alpha.__send__(:*)
-      ).__send__(
-        :[],
-        :text
-      )) { || ([
-        :ident,
-        self.text.to_sym
-      ])})}
-      declare_meme(:integer, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.str("-").__send__(:-).__send__(
-        :+,
-        self.c.num.__send__(:+)
-      ).__send__(
-        :[],
-        :text
-      )) { || ([
-        :integer,
-        self.text.to_i
-      ])})}
-      declare_meme(:float, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.str("-").__send__(:-).__send__(
-        :+,
-        self.c.num.__send__(:+)
-      ).__send__(
-        :+,
-        self.str(".")
-      ).__send__(
-        :+,
-        self.c.num.__send__(:+)
-      ).__send__(
-        :[],
-        :text
-      )) { || ([
-        :float,
-        self.text.to_f
-      ])})}
-      declare_meme(:assign_lhs, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.constant.__send__(
-        :/,
-        self.ident
-      ))}
-      declare_meme(:assign_rhs, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.expr)}
-      declare_meme(:assign, [[:rule, []]], nil, ::Myco.cscope.dup) { |*| (self.r(self.assign_lhs.__send__(
-        :[],
-        :lhs
-      ).__send__(
-        :+,
-        self.c.spc.__send__(:*)
-      ).__send__(
-        :+,
-        self.str("=")
-      ).__send__(
-        :+,
-        self.c.spc.__send__(:*)
-      ).__send__(
-        :+,
-        self.assign_rhs.__send__(
-          :[],
-          :rhs
-        )
-      )) { || ([
-        :assign,
-        self.lhs,
-        self.rhs
-      ])})}
-    )}
-  )}}.instance)}
-  __category__(:tests).component_eval {(declare_meme(:"can parse from a basic grammar", [[:it, []]], nil, ::Myco.cscope.dup) { |*| (
-    parser = self.new_parser
-    parser.__send__(
-      :grammar=,
-      self.basic_grammar
-    )
-    examples = [
-      "xyz",
-      [
-        :ident,
-        :xyz
-      ],
-      "_foo = -88.8",
-      [
-        :assign,
-        [
-          :ident,
-          :_foo
-        ],
-        [
-          :float,
-          -88.8
-        ]
-      ],
-      "Foo_BAR=5",
-      [
-        :assign,
-        [
-          :constant,
-          :Foo_BAR
-        ],
-        [
-          :integer,
-          5
-        ]
-      ],
-      "[99, 99]",
-      [
-        [
-          :integer,
-          99
-        ],
-        [
-          :integer,
-          99
-        ]
-      ]
-    ]
-    examples.each_slice(2) { |input, output| (self.assert_equal(
-      parser.parse(input).result.fetch(:root),
-      output
-    ))}
-  )})}
-)}}.instance)}}.instance