myco 0.1.7 → 0.1.8

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

@@ -1,8 +1,31 @@
 
 BytecodeParser < BasicObject {
-  var grammar: Grammar { }
+  State < BasicObject {
+    var string
+    var start_idx
+    var end_idx
+    var rule
+    var result
+    
+    var error_idx
+    var error_row
+    var error_col
+    var error_string
+    
+    raise_error: self.error_idx && raise(SyntaxError
+      "Unexpected character with parser: "self.rule \
+        " near line: "self.error_row \
+        ", column: "self.error_col".\n" \
+        self.string.each_line.to_a[self.error_row - 1]"" \
+        (' ' * [(self.error_col - 1), 0].max)"^"
+    )
+  }
+  
+  var grammar: Grammar.new
+  var builder: Builder.new
   
   new_worker: set_up_worker(prototype.new)
+  new_processor: Processor.new(builder: builder)
   
   var prototype: compile_prototype
   
@@ -20,8 +43,8 @@ BytecodeParser < BasicObject {
   compile_rule_into: |proto, name, rule| {
     construct = rule.construct_rule
     
-    proto.dynamic_method(name, "(compiled parser)") |g| {
-      instructor = BytecodeInstructions { }
+    Myco.add_dynamic_method(proto, name, "(compiled parser)") |g| {
+      instructor = BytecodeInstructions.new
       instructor.g = g
       g.extend(BytecodeHelpers)
       
@@ -80,58 +103,45 @@ BytecodeParser < BasicObject {
   }
   
   set_up_worker: |worker| {
-    worker.instance_variable_set(:"@captures", [])
-    worker.instance_variable_set(:"@highest_idx", 0)
+    worker.__set_ivar__(:"@captures", [])
+    worker.__set_ivar__(:"@highest_idx", 0)
     worker
   }
   
   captures_of_worker: |worker|
-    worker.instance_variable_get(:"@captures")
+    worker.__get_ivar__(:"@captures")
   
   highest_idx_of_worker: |worker|
-    worker.instance_variable_get(:"@highest_idx")
-  
-  new_processor: Processor.new(builder: new_builder)
-  new_builder: Builder.new
+    worker.__get_ivar__(:"@highest_idx")
   
   
   # Match and process the given string using the current grammar
-  parse: |string| {
-    worker = new_worker
-    
-    self.error_idx = null
-    self.error_row = null
-    self.error_col = null
-    self.error_string = null
-    self.result = null
-    self.end_idx = worker.root(string, 0)
-    
+  parse: |string, rule:"root", start_idx:0| {
+    worker    = new_worker
     processor = new_processor
+    state     = State.new(
+      string:       string.to_s
+      rule:         rule.to_sym
+      start_idx:    start_idx.to_i
+      error_idx:    null
+      error_row:    null
+      error_col:    null
+      error_string: null
+      result:       null
+    )
+    
+    state.end_idx = worker.__send__(state.rule, state.string, state.start_idx)
     
-    if(end_idx) {
-      processor.string = string
+    state.end_idx &? (
+      processor.string = state.string
       processor.capture_items = captures_of_worker(worker)
-      self.result = processor.process
-    }
-    if(!end_idx) {
-      self.error_idx = highest_idx_of_worker(worker)
-      pos = processor.position_of(error_idx, string)
-      self.error_row = pos.first
-      self.error_col = pos.last
-      self.error_string = \
-      "Unexpected character near line: "error_row", column: "error_col".\n" \
-        string.each_line.to_a[error_row - 1]"" \
-        (' ' * [(error_col - 1), 0].max)"^"
-    }
-    self.result
+      state.result = processor.process
+    ) ?? (
+      state.error_idx = highest_idx_of_worker(worker)
+      pos = processor.position_of(state.error_idx, state.string)
+      state.error_row = pos.first
+      state.error_col = pos.last
+    )
+    state
   }
-  
-  var end_idx
-  var result
-  
-  var error_idx
-  var error_row
-  var error_col
-  var error_string
-  raise_error: raise(SyntaxError, error_string)
 }

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

@@ -2,9 +2,42 @@
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.cscope.for_method_definition::BytecodeParser = ::Myco::Component.new([::Myco.find_constant(:BasicObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:grammar, [[:var, []]], 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)}
+  ::Myco.cscope.for_method_definition::State = ::Myco::Component.new([::Myco.find_constant(:BasicObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+    declare_meme(:string, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+    declare_meme(:start_idx, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+    declare_meme(:end_idx, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+    declare_meme(:rule, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+    declare_meme(:result, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+    declare_meme(:error_idx, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+    declare_meme(:error_row, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+    declare_meme(:error_col, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+    declare_meme(:error_string, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+    declare_meme(:raise_error, [], nil, ::Myco.cscope.dup) { |*| (::Myco.branch_op(:"&&", self.error_idx) {self.raise(
+      ::Myco.find_constant(:SyntaxError),
+      "Unexpected character with parser: #{self.rule} near line: #{self.error_row}, column: #{self.error_col}.\n#{self.string.each_line.to_a.__send__(
+        :[],
+        self.error_row.__send__(
+          :-,
+          1
+        )
+      )}#{" ".__send__(
+        :*,
+        [
+          self.error_col.__send__(
+            :-,
+            1
+          ),
+          0
+        ].max
+      )}^"
+    )})}
+  )}}
+  .tap { |__c__| __c__.__name__ = :State }
+  declare_meme(:grammar, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Grammar).new)}
+  declare_meme(:builder, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Builder).new)}
   declare_meme(:new_worker, [], nil, ::Myco.cscope.dup) { |*| (self.set_up_worker(self.prototype.new))}
+  declare_meme(:new_processor, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Processor).new({:builder => self.builder}))}
   declare_meme(:prototype, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (self.compile_prototype)}
   declare_meme(:refresh, [], nil, ::Myco.cscope.dup) { |*| (self.__send__(
     :prototype=,
@@ -22,12 +55,12 @@
   )}
   declare_meme(:compile_rule_into, [], nil, ::Myco.cscope.dup) { |proto, name, rule| (
     construct = rule.construct_rule
-    proto.dynamic_method(
+    ::Myco.find_constant(:Myco).add_dynamic_method(
+      proto,
       name,
       "(compiled parser)"
     ) { |g| (
-      instructor = ::Myco::Component.new([::Myco.find_constant(:BytecodeInstructions)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-      .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}.instance
+      instructor = ::Myco.find_constant(:BytecodeInstructions).new
       instructor.__send__(
         :g=,
         g
@@ -120,118 +153,71 @@
     )
   )}
   declare_meme(:set_up_worker, [], nil, ::Myco.cscope.dup) { |worker| (
-    worker.instance_variable_set(
+    worker.__set_ivar__(
       :@captures,
       []
     )
-    worker.instance_variable_set(
+    worker.__set_ivar__(
       :@highest_idx,
       0
     )
     worker
   )}
-  declare_meme(:captures_of_worker, [], nil, ::Myco.cscope.dup) { |worker| (worker.instance_variable_get(:@captures))}
-  declare_meme(:highest_idx_of_worker, [], nil, ::Myco.cscope.dup) { |worker| (worker.instance_variable_get(:@highest_idx))}
-  declare_meme(:new_processor, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Processor).new({:builder => self.new_builder}))}
-  declare_meme(:new_builder, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Builder).new)}
-  declare_meme(:parse, [], nil, ::Myco.cscope.dup) { |string| (
+  declare_meme(:captures_of_worker, [], nil, ::Myco.cscope.dup) { |worker| (worker.__get_ivar__(:@captures))}
+  declare_meme(:highest_idx_of_worker, [], nil, ::Myco.cscope.dup) { |worker| (worker.__get_ivar__(:@highest_idx))}
+  declare_meme(:parse, [], nil, ::Myco.cscope.dup) { |string, rule:"root", start_idx:0| (
     worker = self.new_worker
-    self.__send__(
-      :error_idx=,
-      nil
-    )
-    self.__send__(
-      :error_row=,
-      nil
-    )
-    self.__send__(
-      :error_col=,
-      nil
-    )
-    self.__send__(
-      :error_string=,
-      nil
-    )
-    self.__send__(
-      :result=,
-      nil
-    )
-    self.__send__(
+    processor = self.new_processor
+    state = ::Myco.find_constant(:State).new({
+      :string => string.to_s,
+      :rule => rule.to_sym,
+      :start_idx => start_idx.to_i,
+      :error_idx => nil,
+      :error_row => nil,
+      :error_col => nil,
+      :error_string => nil,
+      :result => nil
+    })
+    state.__send__(
       :end_idx=,
-      worker.root(
-        string,
-        0
+      worker.__send__(
+        state.rule,
+        state.string,
+        state.start_idx
       )
     )
-    processor = self.new_processor
-    self.__send__(
-      :if,
-      self.end_idx
-    ) { || (
+    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", state.end_idx) {(
       processor.__send__(
         :string=,
-        string
+        state.string
       )
       processor.__send__(
         :capture_items=,
         self.captures_of_worker(worker)
       )
-      self.__send__(
+      state.__send__(
         :result=,
         processor.process
       )
-    )}
-    self.__send__(
-      :if,
-      self.end_idx.__send__(:!)
-    ) { || (
-      self.__send__(
+    )}) {(
+      state.__send__(
         :error_idx=,
         self.highest_idx_of_worker(worker)
       )
       pos = processor.position_of(
-        self.error_idx,
-        string
+        state.error_idx,
+        state.string
       )
-      self.__send__(
+      state.__send__(
         :error_row=,
         pos.first
       )
-      self.__send__(
+      state.__send__(
         :error_col=,
         pos.last
       )
-      self.__send__(
-        :error_string=,
-        "Unexpected character near line: #{self.error_row}, column: #{self.error_col}.\n#{string.each_line.to_a.__send__(
-          :[],
-          self.error_row.__send__(
-            :-,
-            1
-          )
-        )}#{" ".__send__(
-          :*,
-          [
-            self.error_col.__send__(
-              :-,
-              1
-            ),
-            0
-          ].max
-        )}^"
-      )
     )}
-    self.result
+    state
   )}
-  declare_meme(:end_idx, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:result, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:error_idx, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:error_row, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:error_col, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:error_string, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:raise_error, [], nil, ::Myco.cscope.dup) { |*| (self.raise(
-    ::Myco.find_constant(:SyntaxError),
-    self.error_string
-  ))}
 )}}
 .tap { |__c__| __c__.__name__ = :BytecodeParser })}}.instance

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

@@ -18,7 +18,13 @@ Grammar < BasicObject, Patterns::ShorthandMethods {
   # Force evaluation of the rule tree in a way that
   # doesn't get stuck in an infinite recursion.
   construct_all_rules: {
-    rules.root.construct_rule
+    # Consider all rules with "root" in the name
+    rules.memes.each |name, meme| {
+      meme.name.to_s.include?("root") && (
+        meme.result_for(rules).construct_rule
+      )
+    }
+    
     seen_keys = []
     loop {
       new_keys = rule_table.keys - seen_keys
@@ -32,8 +38,7 @@ Grammar < BasicObject, Patterns::ShorthandMethods {
   
   [decorators]
   
-  # TODO: streamline syntax for this definition to make it more intuitive
-  token: Decorator {
+  const token: Decorator {
     apply: |meme| {
       orig_meme = meme.dup
       meme.body = &{ orig_meme.result.token(:"t_"meme.name"") }
@@ -42,16 +47,21 @@ Grammar < BasicObject, Patterns::ShorthandMethods {
     cache: true
   }
   
-  var rule: Decorator {
+  const rule: Decorator {
+    # TODO: remove need for helper method by adding parser aborts/continuations to pegleromyces
+    helper_method: |name, meme, outer_self| Rule {
+      name: name
+      inner: meme.result_for(outer_self)
+      blargy: [name, meme, outer_self]
+    }
+    
     apply: |meme| {
       name = meme.name
+      meme_self = self
       # TODO: use some kind of Decorator#wrap mechanism instead
       meme.target.declare_meme(name, [:memoize]) {
         outer_self = self
-        rule = Rule {
-          name: name
-          inner: meme.result_for(outer_self)
-        }
+        rule = meme_self.helper_method(name, meme, outer_self)
         rule_table[name] = rule
         rule
       }

data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/Grammar.my.rb

@@ -22,9 +22,12 @@
     declare_meme(:bytecode_can_capture, [], nil, ::Myco.cscope.dup) { |*| (true)}
   )}}
   .tap { |__c__| __c__.__name__ = :RuleReference }
-  declare_meme(:rule_table, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Ruby::Hash.new)}
+  declare_meme(:rule_table, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Object::Hash.new)}
   declare_meme(:construct_all_rules, [], nil, ::Myco.cscope.dup) { |*| (
-    self.rules.root.construct_rule
+    self.rules.memes.each { |name, meme| (::Myco.branch_op(:"&&", meme.name.to_s.__send__(
+      :include?,
+      "root"
+    )) {meme.result_for(self.rules).construct_rule})}
     seen_keys = []
     self.loop { || (
       new_keys = self.rule_table.keys.__send__(
@@ -42,31 +45,42 @@
     )}
   )}
   __category__(:decorators).component_eval {(
-    declare_meme(:token, [], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Decorator)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    declare_meme(:token, [[:const, []]], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Decorator)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
     .tap { |__c__| __c__.__last__ = __c__.component_eval {(
       declare_meme(:apply, [], nil, ::Myco.cscope.dup) { |meme| (
         orig_meme = meme.dup
         meme.__send__(
           :body=,
-          ::Proc.new { || (orig_meme.result.token(:"t_#{meme.name}"))}
+          ::Object::Proc.new { || (orig_meme.result.token(:"t_#{meme.name}"))}
         )
       )}
       __category__(:transforms).component_eval {(declare_meme(:cache, [], nil, ::Myco.cscope.dup) { |*| (true)})}
     )}}.instance)}
-    declare_meme(:rule, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Decorator)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    declare_meme(:rule, [[:const, []]], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Decorator)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
     .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+      declare_meme(:helper_method, [], nil, ::Myco.cscope.dup) { |name, meme, outer_self| (::Myco::Component.new([::Myco.find_constant(:Rule)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+      .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+        declare_meme(:name, [], nil, ::Myco.cscope.dup) { |*| (name)}
+        declare_meme(:inner, [], nil, ::Myco.cscope.dup) { |*| (meme.result_for(outer_self))}
+        declare_meme(:blargy, [], nil, ::Myco.cscope.dup) { |*| ([
+          name,
+          meme,
+          outer_self
+        ])}
+      )}}.instance)}
       declare_meme(:apply, [], nil, ::Myco.cscope.dup) { |meme| (
         name = meme.name
+        meme_self = self
         meme.target.declare_meme(
           name,
           [:memoize]
         ) { || (
           outer_self = self
-          rule = ::Myco::Component.new([::Myco.find_constant(:Rule)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-          .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-            declare_meme(:name, [], nil, ::Myco.cscope.dup) { |*| (name)}
-            declare_meme(:inner, [], nil, ::Myco.cscope.dup) { |*| (meme.result_for(outer_self))}
-          )}}.instance
+          rule = meme_self.helper_method(
+            name,
+            meme,
+            outer_self
+          )
           self.rule_table.__send__(
             :[]=,
             name,

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

@@ -11,7 +11,7 @@
   declare_meme(:stack, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([])}
   declare_meme(:captures, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([])}
   declare_meme(:subject, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([])}
-  declare_meme(:sequence_table, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Ruby::Hash.new)}
+  declare_meme(:sequence_table, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Object::Hash.new)}
   declare_meme(:execute, [], nil, ::Myco.cscope.dup) { |*| (self.loop { || (::Myco.branch_op(:"??", ::Myco.branch_op(:"|?", self.ip) {self.handle_fail}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.ip.__send__(
     :==,
     true

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

@@ -1,7 +1,7 @@
 
 Parser < BasicObject {
   
-  var grammar: Grammar { }
+  var grammar: Grammar.new
   var string: ""
   
   var result: null

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

@@ -2,8 +2,7 @@
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.cscope.for_method_definition::Parser = ::Myco::Component.new([::Myco.find_constant(:BasicObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:grammar, [[:var, []]], 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)}
+  declare_meme(:grammar, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Grammar).new)}
   declare_meme(:string, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ("")}
   declare_meme(:result, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (nil)}
   declare_meme(:make_sequence_table, [[:memoize, []]], nil, ::Myco.cscope.dup) { |grammar| (

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

@@ -111,7 +111,7 @@ Patterns < EmptyObject {
       var builder # The fallback delegate for methods that are not capture names
       
       method_missing: |name, *args, &block|
-        captures.fetch(name) { builder.send(name, *args, &block) }
+        captures.fetch(name) { builder.__send__(name, *args, &block) }
       
       # Implement the action for the reduction in the '!' method.
       # It will have access to the captures via method_missing.

data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/Patterns.my.rb

@@ -150,7 +150,7 @@
     .tap { |__c__| __c__.__last__ = __c__.component_eval {(
       declare_meme(:captures, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
       declare_meme(:builder, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-      declare_meme(:method_missing, [], nil, ::Myco.cscope.dup) { |name, *args, &block| (self.captures.fetch(name) { || (self.builder.send(
+      declare_meme(:method_missing, [], nil, ::Myco.cscope.dup) { |name, *args, &block| (self.captures.fetch(name) { || (self.builder.__send__(
         name,
         *args,
         &block

data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/Processor.my

@@ -27,7 +27,7 @@ Processor < BasicObject {
   # The environment for performing reduction actions to build an AST in the PEG.
   # It gives implicit access to both local captures and AST builder methods.
   var reduction_env:
-    Patterns::Reduction::Environment { }
+    Patterns::Reduction::Environment.new
   var reduction_env_cscope:
     ::Rubinius::ConstantScope.new(Patterns::Reduction::Environment) # TODO: fix
   
@@ -43,7 +43,7 @@ Processor < BasicObject {
     idx_hash = ::Ruby::Hash.new
     idx_hash[0] = 0
     count = 0
-    idx = 0
+    idx = -1
     loop {
       idx = string.index("\n", idx + 1)
       idx || break
@@ -56,7 +56,7 @@ Processor < BasicObject {
   # Given an index and string, return the row (line) and column numbers
   position_of: |idx, string| {
     nl_idx = string.rindex("\n", idx) || 0
-    row = line_map_for(string).fetch(nl_idx) + 2
+    row = line_map_for(string).fetch(nl_idx) + 1
     col = idx - nl_idx
     [row, col]
   }

data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/Processor.my.rb

@@ -38,8 +38,7 @@
     ))}
   )}}
   .tap { |__c__| __c__.__name__ = :Token }
-  declare_meme(:reduction_env, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Patterns)::Reduction::Environment], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}.instance)}
+  declare_meme(:reduction_env, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Patterns)::Reduction::Environment.new)}
   declare_meme(:reduction_env_cscope, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Rubinius::ConstantScope.new(::Myco.find_constant(:Patterns)::Reduction::Environment))}
   declare_meme(:cidx_stack, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([])}
   declare_meme(:sidx_stack, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([])}
@@ -48,14 +47,14 @@
   declare_meme(:ridx_stack, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([])}
   declare_meme(:capt_stack, [[:var, []]], nil, ::Myco.cscope.dup) { |*| ([])}
   declare_meme(:line_map_for, [[:memoize, []]], nil, ::Myco.cscope.dup) { |string| (
-    idx_hash = ::Ruby::Hash.new
+    idx_hash = ::Object::Hash.new
     idx_hash.__send__(
       :[]=,
       0,
       0
     )
     count = 0
-    idx = 0
+    idx = -1
     self.loop { || (
       idx = string.index(
         "\n",
@@ -84,7 +83,7 @@
     )) {0}
     row = self.line_map_for(string).fetch(nl_idx).__send__(
       :+,
-      2
+      1
     )
     col = idx.__send__(
       :-,
@@ -95,7 +94,7 @@
       col
     ]
   )}
-  declare_meme(:push_layer, [], nil, ::Myco.cscope.dup) { |*| (self.capt_stack.push(::Ruby::Hash.new))}
+  declare_meme(:push_layer, [], nil, ::Myco.cscope.dup) { |*| (self.capt_stack.push(::Object::Hash.new))}
   declare_meme(:pop_layer, [], nil, ::Myco.cscope.dup) { |*| (self.capt_stack.pop)}
   declare_meme(:setup, [], nil, ::Myco.cscope.dup) { |*| (self.push_layer)}
   declare_meme(:final_captures, [], nil, ::Myco.cscope.dup) { |*| (self.pop_layer.select { |k, v| (k.__send__(

data/lib/myco/code_tools/parser/pegleromyces/spec/BasicSpec.my

@@ -0,0 +1,35 @@
+
+# Implementation from central Myco repository
+# TODO: import instead of copying this code
+
+BasicSpec < Object {
+  assert: |arg, message="expected "arg.inspect" to be truthy"|
+    arg || raise(message)
+  
+  refute: |arg, message="expected "arg.inspect" to be falsey"|
+    arg && raise(message)
+  
+  assert_equal: |a, b, message="expected "a.inspect" to equal "b.inspect""|
+    a == b || raise(message)
+  
+  refute_equal: |a, b, message="expected "a.inspect" to not equal "b.inspect""|
+    a == b && raise(message)
+  
+  assert_is_a: |a, b, message="expected "a.inspect" to be a "b.inspect""|
+    a.is_a?(b) || raise(message)
+  
+  name: to_s
+  
+  on creation: {
+    self.?tests && (
+      STDOUT.print(""self.name" ")
+      self.tests.memes.each |name, test| { test.result; STDOUT.print(".") }
+      STDOUT.print("\n")
+    )
+  }
+  
+  [decorators]
+  
+  const it:      Decorator { }
+  const specify: Decorator { }
+}

data/lib/myco/code_tools/parser/pegleromyces/spec/BasicSpec.my.rb

@@ -0,0 +1,35 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.cscope.for_method_definition::BasicSpec = ::Myco::Component.new([::Myco.find_constant(:Object)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:assert, [], nil, ::Myco.cscope.dup) { |arg, message="expected #{arg.inspect} to be truthy"| (::Myco.branch_op(:"||", arg) {self.raise(message)})}
+  declare_meme(:refute, [], nil, ::Myco.cscope.dup) { |arg, message="expected #{arg.inspect} to be falsey"| (::Myco.branch_op(:"&&", arg) {self.raise(message)})}
+  declare_meme(:assert_equal, [], nil, ::Myco.cscope.dup) { |a, b, message="expected #{a.inspect} to equal #{b.inspect}"| (::Myco.branch_op(:"||", a.__send__(
+    :==,
+    b
+  )) {self.raise(message)})}
+  declare_meme(:refute_equal, [], nil, ::Myco.cscope.dup) { |a, b, message="expected #{a.inspect} to not equal #{b.inspect}"| (::Myco.branch_op(:"&&", a.__send__(
+    :==,
+    b
+  )) {self.raise(message)})}
+  declare_meme(:assert_is_a, [], nil, ::Myco.cscope.dup) { |a, b, message="expected #{a.inspect} to be a #{b.inspect}"| (::Myco.branch_op(:"||", a.__send__(
+    :is_a?,
+    b
+  )) {self.raise(message)})}
+  declare_meme(:name, [], nil, ::Myco.cscope.dup) { |*| (self.to_s)}
+  declare_meme(:creation, [[:on, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.branch_op(:"&&", (Rubinius::Type.object_respond_to?(self, :tests).false? ? ::Myco::Void : self.tests)) {(
+    ::Myco.find_constant(:STDOUT).print("#{self.name} ")
+    self.tests.memes.each { |name, test| (
+      test.result
+      ::Myco.find_constant(:STDOUT).print(".")
+    )}
+    ::Myco.find_constant(:STDOUT).print("\n")
+  )})}
+  __category__(:decorators).component_eval {(
+    declare_meme(:it, [[:const, []]], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Decorator)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}.instance)}
+    declare_meme(:specify, [[:const, []]], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Decorator)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}.instance)}
+  )}
+)}}
+.tap { |__c__| __c__.__name__ = :BasicSpec })}}.instance

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

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