myco 0.1.7 → 0.1.8

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

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

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

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

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

@@ -0,0 +1,156 @@
+
+BasicSpec {
+  name: "Patterns"
+  
+  new_pattern: Patterns::Base { }
+  var shorthand: Patterns::ShorthandMethods { }
+  
+  [tests]
+  
+  it "knows its name": {
+    assert_equal(new_pattern.name, :new_pattern)
+  }
+  
+  it "creates a NegativePredicate with the '!' unary operator": {
+    a = new_pattern
+    b = !a
+    assert_is_a(b, Patterns::NegativePredicate)
+    assert_equal(b.inner, a)
+  }
+  
+  it "creates a PositivePredicate with two uses of the '!' unary operator": {
+    a = new_pattern
+    b = !!a
+    assert_is_a(b, Patterns::PositivePredicate)
+    assert_equal(b.inner, a)
+  }
+  
+  it "creates a NegativePredicate with three uses of the '!' unary operator": {
+    a = new_pattern
+    b = !!!a
+    assert_is_a(b, Patterns::NegativePredicate)
+    assert_equal(b.inner, a)
+  }
+  
+  it "creates an OrderedChoice with the '/' operator": {
+    a = new_pattern
+    b = new_pattern
+    c = a / b
+    assert_is_a(c, Patterns::OrderedChoice)
+    assert_equal(c.first, a)
+    assert_equal(c.second, b)
+  }
+  
+  it "interprets a series of OrderedChoices as a right-associative tree": {
+    a = new_pattern
+    b = new_pattern
+    c = new_pattern
+    d = new_pattern
+    e = a / b / c / d
+    assert_is_a(e, Patterns::OrderedChoice)
+    assert_is_a(e.second, Patterns::OrderedChoice)
+    assert_is_a(e.second.second, Patterns::OrderedChoice)
+    assert_equal(e.first, a)
+    assert_equal(e.second.first, b)
+    assert_equal(e.second.second.first, c)
+    assert_equal(e.second.second.second, d)
+  }
+  
+  it "creates a Concatenation with the '+' operator": {
+    a = new_pattern
+    b = new_pattern
+    c = a + b
+    assert_is_a(c, Patterns::Concatenation)
+    assert_equal(c.first, a)
+    assert_equal(c.second, b)
+  }
+  
+  it "interprets a series of Concatenations as a right-associative tree": {
+    a = new_pattern
+    b = new_pattern
+    c = new_pattern
+    d = new_pattern
+    e = a + b + c + d
+    assert_is_a(e, Patterns::Concatenation)
+    assert_is_a(e.second, Patterns::Concatenation)
+    assert_is_a(e.second.second, Patterns::Concatenation)
+    assert_equal(e.first, a)
+    assert_equal(e.second.first, b)
+    assert_equal(e.second.second.first, c)
+    assert_equal(e.second.second.second, d)
+  }
+  
+  it "creates a OneOrMore with the '+' operator used as a 'suffix' call": {
+    a = new_pattern
+    b = a.+
+    assert_is_a(b, Patterns::OneOrMore)
+    assert_equal(b.inner, a)
+    
+    # This is implemented as a special case but should act the same
+    a = (new_pattern + new_pattern)
+    b = a.+
+    assert_is_a(b, Patterns::OneOrMore)
+    assert_equal(b.inner, a)
+  }
+  
+  it "creates a ZeroOrOne with the '-' operator used as a 'suffix' call": {
+    a = new_pattern
+    b = a.-
+    assert_is_a(b, Patterns::ZeroOrOne)
+    assert_equal(b.inner, a)
+  }
+  
+  it "creates a ZeroOrMore with the '*' operator used as a 'suffix' call": {
+    a = new_pattern
+    b = a.*
+    assert_is_a(b, Patterns::ZeroOrMore)
+    assert_equal(b.inner, a)
+  }
+  
+  it "creates a NamedCapture with the '[]' operator, given a capture name": {
+    a = new_pattern
+    b = a[:foo]
+    assert_is_a(b, Patterns::NamedCapture)
+    assert_equal(b.inner, a)
+    assert_equal(b.name, :foo)
+  }
+  
+  it "creates an AnyCharacter with the 'any' shorthand method": {
+    a = shorthand.any
+    assert_is_a(a, Patterns::AnyCharacter)
+  }
+  
+  it "creates a Character with the 'char' shorthand method": {
+    a = shorthand.char('x')
+    assert_is_a(a, Patterns::Character)
+    assert_equal(a.code, 120)
+  }
+  
+  it "creates a CharacterString with the 'str' shorthand method": {
+    a = shorthand.str('xyz')
+    assert_is_a(a, Patterns::CharacterString)
+    assert_equal(a.codes, [120,121,122])
+  }
+  
+  it "creates a CharacterSet with the 'set' shorthand method": {
+    a = shorthand.set('xyz')
+    assert_is_a(a, Patterns::CharacterSet)
+    assert_equal(a.codes, [120,121,122])
+  }
+  
+  it "creates a CharacterRange with the 'range' shorthand method": {
+    a = shorthand.range('x','z')
+    assert_is_a(a, Patterns::CharacterRange)
+    assert_equal(a.start, 120)
+    assert_equal(a.stop,  122)
+  }
+  
+  it "creates a Reduction with the 'r' shorthand method": {
+    a_proc = Proc.new { }
+    a = new_pattern
+    b = shorthand.r(a, &a_proc)
+    assert_is_a(b, Patterns::Reduction)
+    assert_equal(b.inner, a)
+    assert_equal(b.block, a_proc)
+  }
+}