myco 0.1.9 → 0.1.10

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

@@ -1,144 +0,0 @@
-
-Common << {
-  Parser < BasicObject {
-    State < BasicObject {
-      var string
-      var start_idx
-      var end_idx
-      var rule
-      var result
-      
-      var error_idx
-      var error_row
-      var error_col
-      
-      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 debug_mode: false
-    
-    var grammar: Grammar.new
-    var builder: null
-    
-    new_worker: set_up_worker(prototype.new)
-    new_processor: Processor.new(builder: builder)
-    
-    var prototype: compile_prototype
-    
-    refresh: self.prototype = compile_prototype
-    
-    compile_prototype: {
-      proto = Component.new
-      grammar.construct_all_rules
-      grammar.rule_table.each |name, rule| {
-        compile_rule_into(proto, name, rule)
-      }
-      proto
-    }
-    
-    compile_rule_into: |proto, name, rule| {
-      construct = rule.inner.construct
-      
-      Myco.add_dynamic_method(proto, name, "(compiled parser)") |g| {
-        g.extend(BytecodeHelpers)
-        g.debug_mode = self.debug_mode
-        g.rule_start
-        construct.bytecode(g)
-        g.rule_finish
-      }
-    }
-    
-    compile_generator: |name, file, line=1, &block| {
-      g = Myco::ToolSet::Generator.new
-      g.name = name
-      g.file = file
-      g.set_line(line)
-      
-      block.call(g)
-      
-      g.ret
-      g.close
-      g.use_detected
-      g
-    }
-    
-    compile_code: |name, file, line=1, &block| {
-      g = compile_generator(name, file, line, &block)
-      g.encode
-      g.package(Rubinius::CompiledCode)
-    }
-    
-    save_prototype: |filename| {
-      code = compile_code(:__script__, :"(snippet)") |g| {
-        g.push_cpath_top; g.find_const(:Class)
-        g.create_block(compile_generator(:__block__, :"(snippet)") |g| {
-          prototype.instance_methods.each |name| {
-            code = prototype.instance_method(name).executable
-            if(code.is_a?(Rubinius::CompiledCode)) {
-              g.push_rubinius
-                g.push_literal(name)
-                g.push_literal(code)
-                g.push_scope
-                g.push_variables; g.send(:method_visibility, 0)
-              g.send(:add_defn_method, 4)
-            }
-          }
-        })
-        g.send_with_block(:new, 0)
-      }
-      
-      Myco::ToolSet::CompiledFile.dump(code, filename, Rubinius::Signature, Rubinius::RUBY_LIB_VERSION)
-    }
-    
-    load_prototype: |filename| {
-      loader = Myco::CodeLoader::BytecodeLoader.new(filename)
-      loader.bind_to(call_depth:1)
-      self.prototype = loader.load
-    }
-    
-    set_up_worker: |worker| {
-      worker.__set_ivar__(:"@captures", [])
-      worker.__set_ivar__(:"@highest_idx", 0)
-      worker
-    }
-    
-    captures_of_worker: |worker|
-      worker.__get_ivar__(:"@captures")
-    
-    highest_idx_of_worker: |worker|
-      worker.__get_ivar__(:"@highest_idx")
-    
-    
-    # Match and process the given string using the current grammar
-    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
-      )
-      
-      state.end_idx = worker.__send__(state.rule, state.string, state.start_idx)
-      
-      state.end_idx &? (
-        processor.string = state.string
-        processor.capture_items = captures_of_worker(worker)
-        grammar.?tokenizer && (processor.tokenizer = grammar.tokenizer)
-        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
-    }
-  }
-}

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

@@ -1,221 +0,0 @@
-
-::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:Common).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 {(
-  ::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(: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(:debug_mode, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (false)}
-  declare_meme(:grammar, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Grammar).new)}
-  declare_meme(:builder, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (nil)}
-  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=,
-    self.compile_prototype
-  ))}
-  declare_meme(:compile_prototype, [], nil, ::Myco.cscope.dup) { |*| (
-    proto = ::Myco.find_constant(:Component).new
-    self.grammar.construct_all_rules
-    self.grammar.rule_table.each { |name, rule| (self.compile_rule_into(
-      proto,
-      name,
-      rule
-    ))}
-    proto
-  )}
-  declare_meme(:compile_rule_into, [], nil, ::Myco.cscope.dup) { |proto, name, rule| (
-    construct = rule.inner.construct
-    ::Myco.find_constant(:Myco).add_dynamic_method(
-      proto,
-      name,
-      "(compiled parser)"
-    ) { |g| (
-      g.extend(::Myco.find_constant(:BytecodeHelpers))
-      g.__send__(
-        :debug_mode=,
-        self.debug_mode
-      )
-      g.rule_start
-      construct.bytecode(g)
-      g.rule_finish
-    )}
-  )}
-  declare_meme(:compile_generator, [], nil, ::Myco.cscope.dup) { |name, file, line=1, &block| (
-    g = ::Myco.find_constant(:Myco)::ToolSet::Generator.new
-    g.__send__(
-      :name=,
-      name
-    )
-    g.__send__(
-      :file=,
-      file
-    )
-    g.set_line(line)
-    block.call(g)
-    g.ret
-    g.close
-    g.use_detected
-    g
-  )}
-  declare_meme(:compile_code, [], nil, ::Myco.cscope.dup) { |name, file, line=1, &block| (
-    g = self.compile_generator(
-      name,
-      file,
-      line,
-      &block
-    )
-    g.encode
-    g.package(::Myco.find_constant(:Rubinius)::CompiledCode)
-  )}
-  declare_meme(:save_prototype, [], nil, ::Myco.cscope.dup) { |filename| (
-    code = self.compile_code(
-      :__script__,
-      :"(snippet)"
-    ) { |g| (
-      g.push_cpath_top
-      g.find_const(:Class)
-      g.create_block(self.compile_generator(
-        :__block__,
-        :"(snippet)"
-      ) { |g| (self.prototype.instance_methods.each { |name| (
-        code = self.prototype.instance_method(name).executable
-        self.__send__(
-          :if,
-          code.__send__(
-            :is_a?,
-            ::Myco.find_constant(:Rubinius)::CompiledCode
-          )
-        ) { || (
-          g.push_rubinius
-          g.push_literal(name)
-          g.push_literal(code)
-          g.push_scope
-          g.push_variables
-          g.send(
-            :method_visibility,
-            0
-          )
-          g.send(
-            :add_defn_method,
-            4
-          )
-        )}
-      )})})
-      g.send_with_block(
-        :new,
-        0
-      )
-    )}
-    ::Myco.find_constant(:Myco)::ToolSet::CompiledFile.dump(
-      code,
-      filename,
-      ::Myco.find_constant(:Rubinius)::Signature,
-      ::Myco.find_constant(:Rubinius)::RUBY_LIB_VERSION
-    )
-  )}
-  declare_meme(:load_prototype, [], nil, ::Myco.cscope.dup) { |filename| (
-    loader = ::Myco.find_constant(:Myco)::CodeLoader::BytecodeLoader.new(filename)
-    loader.bind_to({:call_depth => 1})
-    self.__send__(
-      :prototype=,
-      loader.load
-    )
-  )}
-  declare_meme(:set_up_worker, [], nil, ::Myco.cscope.dup) { |worker| (
-    worker.__set_ivar__(
-      :@captures,
-      []
-    )
-    worker.__set_ivar__(
-      :@highest_idx,
-      0
-    )
-    worker
-  )}
-  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
-    processor = self.new_processor
-    state = ::Myco.find_constant(:State).new({
-      :string => string.to_s,
-      :rule => rule.to_sym,
-      :start_idx => start_idx.to_i
-    })
-    state.__send__(
-      :end_idx=,
-      worker.__send__(
-        state.rule,
-        state.string,
-        state.start_idx
-      )
-    )
-    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", state.end_idx) {(
-      processor.__send__(
-        :string=,
-        state.string
-      )
-      processor.__send__(
-        :capture_items=,
-        self.captures_of_worker(worker)
-      )
-      ::Myco.branch_op(:"&&", (Rubinius::Type.object_respond_to?(self.grammar, :tokenizer).false? ? ::Myco::Void : self.grammar.tokenizer)) {processor.__send__(
-        :tokenizer=,
-        self.grammar.tokenizer
-      )}
-      state.__send__(
-        :result=,
-        processor.process
-      )
-    )}) {(
-      state.__send__(
-        :error_idx=,
-        self.highest_idx_of_worker(worker)
-      )
-      pos = processor.position_of(
-        state.error_idx,
-        state.string
-      )
-      state.__send__(
-        :error_row=,
-        pos.first
-      )
-      state.__send__(
-        :error_col=,
-        pos.last
-      )
-    )}
-    state
-  )}
-)}}
-.tap { |__c__| __c__.__name__ = :Parser })})}}.instance

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

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

@@ -1,35 +0,0 @@
-
-::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/Grammar.test.my

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