myco 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 417744da4484853e229b10a6f5de25b140e67af1
-  data.tar.gz: 9e4e018656fef08864d79948f9ff58731fa33c65
+  metadata.gz: c7120707eb3cf4f2630bbda7bddbf88a64956cb9
+  data.tar.gz: 6fe624e6aab7c551c6b9d313acc7dcdf9c37eeff
 SHA512:
-  metadata.gz: c81eb1fd9f81a6c1c5d02d29929c9922b749e9a6833c6190b88eb996f56ad9d1ed4cb60e3edd276b8bcf6fd0f151634129f4e4754b3f591594b0e600abae0be4
-  data.tar.gz: b2db5fe48fd80b3c49aa472ed3dc89d32b3b15ff800f943760a7f36480aa2aef2851832a88cccc1eed40064a48c690471b44e0d9aa12edf27a5dd0df29d4be5e
+  metadata.gz: 90a9b6c2b8c7d9523cb71d9740e314c743565d9a9128c8c7bd273335be190fc87f76e45b82fec69f0a530bb24342ba60d11a1ca8d14b3bc4784945454408aa83
+  data.tar.gz: 771063aed886cd75ea2a88cf1d5222f04a5a2fa49bbd55e2497bb9e1453a3df2f4de034ca055adc8bcc7dec88d2a4a69b6ef7ff1e376248d705f8dda22763a83

data/README.md

@@ -1,12 +1,12 @@
+[![Build Status](https://travis-ci.org/jemc/myco.svg?branch=master)](https://travis-ci.org/jemc/myco)
 
 ```myco
 Myco < Ruby, QML, Ioke {
   primary author: "Joe Eli McIlvain"
   
-  latest gem version: 0.1.0
   development status: [:alpha, :experimental]
   
-  dependency "Rubinius VM": git(:master)
+  dependency "Rubinius VM"
   
   development dependency 'bundler':  1.6
   development dependency 'rake':    10.3

data/lib/myco/bootstrap/component.rb

@@ -161,6 +161,11 @@ module Myco
       kwargs.each { |key,val| instance.send :"#{key}=", val }
       instance
     end
+  end
+  
+  # TODO: use a better approach than this monkey-patch
+  class ::Module
+    include ::Myco::MemeBindable
     
     # Like module_eval, but it also shifts the ConstantScope of the block
     def component_eval &block

data/lib/myco/bootstrap.my.rb

@@ -0,0 +1,18 @@
+::Myco::Component.new([
+  ::Myco::FileToplevel
+], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  ::Myco::RubyEval = ::Myco::Component.new([
+    ::Myco.find_constant(:EmptyObject)
+  ], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+    declare_meme(:from_string, [], nil, ::Myco.cscope.dup) { |string| (
+      ::Kernel.instance_method(:eval).bind(self).call(string)
+    )}
+  )}}
+  .tap { |__c__| __c__.__name__ = :RubyEval }
+  ::Myco::Component.new([
+    ::Myco.find_constant(:RubyEval)
+  ], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}.instance.from_string("  Myco.eval_file(\"core/Category.my\",        [Myco::CoreLoadPath])\n  Myco.eval_file(\"core/BasicDecorators.my\", [Myco::CoreLoadPath])\n  Myco.eval_file(\"core/BasicObject.my\",     [Myco::CoreLoadPath])\n  Myco.eval_file(\"core/Decorator.my\",       [Myco::CoreLoadPath])\n  Myco.eval_file(\"core/Object.my\",          [Myco::CoreLoadPath])\n  Myco.eval_file(\"core/FileToplevel.my\",    [Myco::CoreLoadPath])\n  \n  # Below are not necessary for bootstrapping; TODO: move out of RubyEval\n  Myco.eval_file(\"core/Switch.my\",          [Myco::CoreLoadPath])\n")
+)}}.instance

data/lib/myco/command/inoculate.my

@@ -14,10 +14,12 @@ BasicCommand {
     ?? destinations.each |dest| {
       config.dest = dest
       
-      run_operation(:copy, files(config.source, 'bin'))
-      run_operation(:copy, files(config.source, 'lib', '.rb'))
-      run_operation(:copy, files(config.source, 'lib', '.my'))
-      run_operation(:myrb, files(config.dest,   'lib', '.my'))
+      run_operation(:copy, files(config.source, '*.md'))
+      run_operation(:copy, files(config.source, 'LICENSE'))
+      run_operation(:copy, files(config.source, 'bin/*'))
+      run_operation(:copy, files(config.source, 'lib/**/*.rb'))
+      run_operation(:copy, files(config.source, 'lib/**/*.my'))
+      run_operation(:myrb, files(config.dest,   'lib/**/*.my'))
       
       if(config.verbose) {
         prog = Rubinius::Globals[:"$PROGRAM_NAME"]
@@ -43,10 +45,8 @@ BasicCommand {
   operation_is_unnecessary: |source, dest|
     File.file?(dest) && File.mtime(dest) >= File.mtime(source)
   
-  files: |prefix, subdir, ext=''| {
-    prefix && (subdir = File.join(prefix, subdir))
-    Dir.glob(File.join(subdir, "**", "*"ext""))
-  }
+  files: |prefix, glob|
+    Dir.glob(prefix &? File.join(prefix, glob) ?? glob)
   
   [operations]
   

data/lib/myco/command/inoculate.my.rb

@@ -0,0 +1,202 @@
+::Myco::Component.new([
+  ::Myco::FileToplevel
+], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:"../tools/BasicCommand.my", [
+    [:import, []]
+  ], nil, ::Myco.cscope.dup) { |*| nil}
+  ::Myco::Component.new([
+    ::Myco.find_constant(:BasicCommand)
+  ], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+    declare_meme(:banner, [], nil, ::Myco.cscope.dup) { |*| (
+      "Usage: myco inoculate [options]"
+    )}
+    declare_meme(:shell, [], nil, ::Myco.cscope.dup) { |*a, &b| (
+      ::Myco.find_constant(:Kernel).instance_method(:system).bind(self).call(
+        *a,
+        &b
+      )
+    )}
+    declare_meme(:run, [], nil, ::Myco.cscope.dup) { |*argv| (
+      destinations = self.options_parse(*argv)
+      ::Myco.branch_op(:"??", ::Myco.branch_op(:"|?", destinations.size.__send__(
+        :==,
+        1
+      )) {self.show_help}) {destinations.each { |dest| (
+        self.config.__send__(
+          :dest=,
+          dest
+        )
+        self.run_operation(
+          :copy,
+          self.files(
+            self.config.source,
+            "*.md"
+          )
+        )
+        self.run_operation(
+          :copy,
+          self.files(
+            self.config.source,
+            "LICENSE"
+          )
+        )
+        self.run_operation(
+          :copy,
+          self.files(
+            self.config.source,
+            "bin/*"
+          )
+        )
+        self.run_operation(
+          :copy,
+          self.files(
+            self.config.source,
+            "lib/**/*.rb"
+          )
+        )
+        self.run_operation(
+          :copy,
+          self.files(
+            self.config.source,
+            "lib/**/*.my"
+          )
+        )
+        self.run_operation(
+          :myrb,
+          self.files(
+            self.config.dest,
+            "lib/**/*.my"
+          )
+        )
+        self.__send__(
+          :if,
+          self.config.verbose
+        ) { || (
+          prog = ::Myco.find_constant(:Rubinius)::Globals.__send__(
+            :[],
+            :$PROGRAM_NAME
+          )
+          self.puts("DONE #{prog} #{::Myco.find_constant(:ARGV).join(" ")}")
+        )}
+      )}}
+    )}
+    declare_meme(:run_operation, [], nil, ::Myco.cscope.dup) { |opcode, source_list| (
+      source_list.each { |source| (
+        dest = self.transforms.send(
+          opcode,
+          source
+        )
+        self.__send__(
+          :unless,
+          self.operation_is_unnecessary(
+            source,
+            dest
+          )
+        ) { || (
+          self.__send__(
+            :if,
+            self.config.verbose
+          ) { || (
+            self.puts("#{opcode.upcase} #{source}")
+            self.puts("  => #{dest}")
+          )}
+          self.operations.send(
+            opcode,
+            source,
+            dest
+          )
+        )}
+      )}
+    )}
+    declare_meme(:operation_is_unnecessary, [], nil, ::Myco.cscope.dup) { |source, dest| (
+      ::Myco.branch_op(:"&&", ::Myco.find_constant(:File).__send__(
+        :file?,
+        dest
+      )) {::Myco.find_constant(:File).mtime(dest).__send__(
+        :>=,
+        ::Myco.find_constant(:File).mtime(source)
+      )}
+    )}
+    declare_meme(:files, [], nil, ::Myco.cscope.dup) { |prefix, glob| (
+      ::Myco.find_constant(:Dir).glob(::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", prefix) {::Myco.find_constant(:File).join(
+        prefix,
+        glob
+      )}) {glob})
+    )}
+    __category__(:operations).component_eval {(
+      declare_meme(:copy, [], nil, ::Myco.cscope.dup) { |source, dest| (
+        self.shell("mkdir -p #{::Myco.find_constant(:File).dirname(dest)} && cp #{source} #{dest}")
+      )}
+      declare_meme(:myrb, [], nil, ::Myco.cscope.dup) { |source, dest| (
+        ::Myco.find_constant(:Myco)::CodeLoader::MycoLoader.new(source).__send__(:emit_rb!)
+      )}
+    )}
+    __category__(:transforms).component_eval {(
+      declare_meme(:copy, [], nil, ::Myco.cscope.dup) { |filename| (
+        ::Myco.find_constant(:File).join(
+          self.config.dest,
+          filename
+        )
+      )}
+      declare_meme(:myrb, [], nil, ::Myco.cscope.dup) { |filename| (
+        "#{filename}.rb"
+      )}
+    )}
+    __category__(:config).component_eval {(
+      declare_meme(:source, [
+        [:var, []]
+      ], nil, ::Myco.cscope.dup) { |*| nil}
+      declare_meme(:dest, [
+        [:var, []]
+      ], nil, ::Myco.cscope.dup) { |*| nil}
+      declare_meme(:verbose, [
+        [:var, []]
+      ], nil, ::Myco.cscope.dup) { |*| nil}
+    )}
+    __category__(:options).component_eval {(
+      declare_meme(:"-d", [], nil, ::Myco.cscope.dup) { |*| (
+        ::Myco::Component.new([
+          ::Myco.find_constant(:Option)
+        ], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+        .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+          declare_meme(:description, [], nil, ::Myco.cscope.dup) { |*| (
+            "The destination directory to clone material into."
+          )}
+          declare_meme(:long_form, [], nil, ::Myco.cscope.dup) { |*| (
+            "--dest"
+          )}
+          declare_meme(:argument, [], nil, ::Myco.cscope.dup) { |*| (
+            "STRING"
+          )}
+          declare_meme(:do, [], nil, ::Myco.cscope.dup) { |arg| (
+            self.parent.config.__send__(
+              :dest=,
+              arg
+            )
+          )}
+        )}}.instance
+      )}
+      declare_meme(:"-v", [], nil, ::Myco.cscope.dup) { |*| (
+        ::Myco::Component.new([
+          ::Myco.find_constant(:Option)
+        ], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+        .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+          declare_meme(:description, [], nil, ::Myco.cscope.dup) { |*| (
+            "Show details about material cloning operations."
+          )}
+          declare_meme(:long_form, [], nil, ::Myco.cscope.dup) { |*| (
+            "--verbose"
+          )}
+          declare_meme(:do, [], nil, ::Myco.cscope.dup) { |arg| (
+            self.parent.config.__send__(
+              :verbose=,
+              true
+            )
+          )}
+        )}}.instance
+      )}
+    )}
+  )}}.instance
+)}}.instance

data/lib/myco/command.my.rb

@@ -0,0 +1,77 @@
+::Myco::Component.new([
+  ::Myco::FileToplevel
+], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:"tools/BasicCommand.my", [
+    [:import, []]
+  ], nil, ::Myco.cscope.dup) { |*| nil}
+  ::Myco::Component.new([
+    ::Myco.find_constant(:BasicCommand)
+  ], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+    declare_meme(:banner, [], nil, ::Myco.cscope.dup) { |*| (
+      "Usage: myco [subcommand] [options] [files]"
+    )}
+    declare_meme(:creation, [
+      [:on, []]
+    ], nil, ::Myco.cscope.dup) { |*| (
+      self.run(*::Myco.find_constant(:ARGV))
+    )}
+    declare_meme(:run, [], nil, ::Myco.cscope.dup) { |*argv| (
+      files = self.options_parse(*argv)
+      ::Myco.branch_op(:"&&", files) {files.uniq.each { |file| (
+        ::Myco.find_constant(:Myco).eval_file(
+          file,
+          [
+            ::Dir.pwd
+          ]
+        )
+      )}}
+    )}
+    __category__(:options).component_eval {(
+      declare_meme(:"-E", [], nil, ::Myco.cscope.dup) { |*| (
+        ::Myco::Component.new([
+          ::Myco.find_constant(:Option)
+        ], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+        .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+          declare_meme(:description, [], nil, ::Myco.cscope.dup) { |*| (
+            "Evaluate a string of declarative Myco"
+          )}
+          declare_meme(:long_form, [], nil, ::Myco.cscope.dup) { |*| (
+            "--eval"
+          )}
+          declare_meme(:argument, [], nil, ::Myco.cscope.dup) { |*| (
+            "STRING"
+          )}
+          declare_meme(:do, [], nil, ::Myco.cscope.dup) { |arg| (
+            ::Myco.find_constant(:Myco).eval(arg)
+          )}
+        )}}.instance
+      )}
+      declare_meme(:"-e", [], nil, ::Myco.cscope.dup) { |*| (
+        ::Myco::Component.new([
+          ::Myco.find_constant(:Option)
+        ], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+        .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+          declare_meme(:description, [], nil, ::Myco.cscope.dup) { |*| (
+            "Evaluate a string of procedural Myco inside an Object"
+          )}
+          declare_meme(:long_form, [], nil, ::Myco.cscope.dup) { |*| (
+            "--eval-meme"
+          )}
+          declare_meme(:argument, [], nil, ::Myco.cscope.dup) { |*| (
+            "STRING"
+          )}
+          declare_meme(:do, [], nil, ::Myco.cscope.dup) { |arg| (
+            ::Myco.find_constant(:Myco).eval("Object { on creation: { #{arg} } }")
+          )}
+        )}}.instance
+      )}
+    )}
+    __category__(:commands).component_eval {(
+      declare_meme(:inoculate, [], nil, ::Myco.cscope.dup) { |*| (
+        ::Myco.find_constant(:Myco).eval_file("command/inoculate.my")
+      )}
+    )}
+  )}}.instance
+)}}.instance

data/lib/myco/core/BasicDecorators.my.rb

@@ -0,0 +1,129 @@
+::Myco::Component.new([
+  ::Myco::FileToplevel
+], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  ::Myco::BasicDecorators = ::Myco::Component.new([
+    ::Myco::EmptyObject
+  ], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+    __category__(:decorators).component_eval {(
+      declare_meme(:storage, [], 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| (
+            meme.target.declare_meme(:"#{meme.name}=") { |new_value, *args| (
+              meme.set_result_for(
+                self,
+                new_value,
+                *args
+              )
+            )}
+          )}
+          __category__(:transforms).component_eval {(
+            declare_meme(:cache, [], nil, ::Myco.cscope.dup) { |*| (
+              true
+            )}
+          )}
+        )}}.instance
+      )}
+      declare_meme(:var, [], 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 {(
+          __category__(:transforms).component_eval {(
+            declare_meme(:var, [], nil, ::Myco.cscope.dup) { |*| (
+              true
+            )}
+          )}
+        )}}.instance
+      )}
+      declare_meme(:memoize, [], 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 {(
+          __category__(:transforms).component_eval {(
+            declare_meme(:cache, [], nil, ::Myco.cscope.dup) { |*| (
+              true
+            )}
+          )}
+        )}}.instance
+      )}
+      declare_meme(:sclass, [], 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 {(
+          __category__(:transforms).component_eval {(
+            declare_meme(:target, [], nil, ::Myco.cscope.dup) { |meme| (
+              meme.target.singleton_class
+            )}
+          )}
+        )}}.instance
+      )}
+      declare_meme(:before, [], 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.target.memes.__send__(
+              :[],
+              meme.name
+            )
+            wrap_meme = meme.dup
+            meme.__send__(
+              :body=,
+              ::Myco.find_constant(:Proc).new { |*a, &b| (
+                wrap_meme.result_for(
+                  self,
+                  *a,
+                  &b
+                )
+                orig_meme.result_for(
+                  self,
+                  *a,
+                  &b
+                )
+              )}
+            )
+          )}
+        )}}.instance
+      )}
+      declare_meme(:after, [], 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.target.memes.__send__(
+              :[],
+              meme.name
+            )
+            wrap_meme = meme.dup
+            meme.__send__(
+              :body=,
+              ::Myco.find_constant(:Proc).new { |*a, &b| (
+                result = orig_meme.result_for(
+                  self,
+                  *a,
+                  &b
+                )
+                wrap_meme.result_for(
+                  self,
+                  *a,
+                  &b
+                )
+                result
+              )}
+            )
+          )}
+        )}}.instance
+      )}
+    )}
+  )}}
+  .tap { |__c__| __c__.__name__ = :BasicDecorators }
+)}}.instance

data/lib/myco/core/BasicObject.my.rb

@@ -0,0 +1,50 @@
+::Myco::Component.new([
+  ::Myco::FileToplevel
+], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  ::Myco::BasicObject = ::Myco::Component.new([
+    ::Myco::EmptyObject,
+    ::Myco::BasicDecorators
+  ], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+    declare_meme(:if, [], nil, ::Myco.cscope.dup) { |cond, &blk| (
+      ::Myco.branch_op(:"&&", cond) {blk.call}
+    )}
+    declare_meme(:unless, [], nil, ::Myco.cscope.dup) { |cond, &blk| (
+      ::Myco.branch_op(:"||", cond) {blk.call}
+    )}
+    declare_meme(:switch, [], nil, ::Myco.cscope.dup) { |input, comparator=:==| (
+      ::Myco.find_constant(:Switch).new({
+        :input => input,
+        :comparator => comparator
+      })
+    )}
+    declare_meme(:raise, [], nil, ::Myco.cscope.dup) { |*args| (
+      ::Kernel.instance_method(:raise).bind(self).call(*args)
+    )}
+    declare_meme(:loop, [], nil, ::Myco.cscope.dup) { |&block| (
+      ::Kernel.instance_method(:loop).bind(self).call(&block)
+    )}
+    declare_meme(:break, [], nil, ::Myco.cscope.dup) { |*| (
+      self.raise(::StopIteration)
+    )}
+    declare_meme(:puts, [], nil, ::Myco.cscope.dup) { |*args| (
+      ::Myco.find_constant(:STDOUT).puts(*args)
+    )}
+    declare_meme(:p, [], nil, ::Myco.cscope.dup) { |*args| (
+      ::Myco.find_constant(:STDOUT).puts(args.map { |a| (
+        a.inspect
+      )}.join(", "))
+    )}
+    declare_meme(:ruby_require, [], nil, ::Myco.cscope.dup) { |arg| (
+      ::Myco.find_constant(:Object).send(
+        :require,
+        arg
+      )
+    )}
+  )}}
+  .tap { |__c__| __c__.__name__ = :BasicObject }
+  ::Myco::Instance::BasicObject = (
+    ::Myco::BasicObject
+  )
+)}}.instance

data/lib/myco/core/Category.my.rb

@@ -0,0 +1,18 @@
+::Myco::Component.new([
+  ::Myco::FileToplevel
+], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  ::Myco::Category = ::Myco::Component.new([
+    ::Myco::EmptyObject
+  ], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+    declare_meme(:method_missing, [], nil, ::Myco.cscope.dup) { |sym, *a, &b| (
+      self.parent.send(
+        sym,
+        *a,
+        &b
+      )
+    )}
+  )}}
+  .tap { |__c__| __c__.__name__ = :Category }
+)}}.instance

data/lib/myco/core/Decorator.my.rb

@@ -0,0 +1,52 @@
+::Myco::Component.new([
+  ::Myco::FileToplevel
+], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  ::Myco::Decorator = ::Myco::Component.new([
+    ::Myco::BasicObject
+  ], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+    declare_meme(:apply, [], nil, ::Myco.cscope.dup) { |meme, *args| nil}
+    __category__(:transforms).component_eval {(
+      declare_meme(:apply, [], nil, ::Myco.cscope.dup) { |meme, *args| (
+        (self.respond_to?(:target).false? ? ::Myco::Void : self.target(meme)).tap { |x| (
+          meme.__send__(
+            :target=,
+            x
+          )
+        )}
+        (self.respond_to?(:name).false? ? ::Myco::Void : self.name(meme)).tap { |x| (
+          meme.__send__(
+            :name=,
+            x
+          )
+        )}
+        (self.respond_to?(:body).false? ? ::Myco::Void : self.body(meme)).tap { |x| (
+          meme.__send__(
+            :body=,
+            x
+          )
+        )}
+        (self.respond_to?(:cache).false? ? ::Myco::Void : self.cache(meme)).tap { |x| (
+          meme.__send__(
+            :cache=,
+            x
+          )
+        )}
+        (self.respond_to?(:var).false? ? ::Myco::Void : self.var(meme)).tap { |x| (
+          meme.__send__(
+            :var=,
+            x
+          )
+        )}
+        (self.respond_to?(:expose).false? ? ::Myco::Void : self.expose(meme)).tap { |x| (
+          meme.__send__(
+            :expose=,
+            x
+          )
+        )}
+      )}
+    )}
+  )}}
+  .tap { |__c__| __c__.__name__ = :Decorator }
+)}}.instance

data/lib/myco/core/FileToplevel.my.rb

@@ -0,0 +1,42 @@
+::Myco::Component.new([
+  ::Myco::FileToplevel
+], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  ::Myco::FileToplevel = ::Myco::Component.new([
+    ::Myco::Object
+  ], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+    declare_meme(:dirname, [], nil, ::Myco.cscope.dup) { |*| (
+      self.component.instance_variable_get("@dirname")
+    )}
+    declare_meme(:basename, [], nil, ::Myco.cscope.dup) { |*| (
+      self.component.instance_variable_get("@basename")
+    )}
+    declare_meme(:filename, [], nil, ::Myco.cscope.dup) { |*| (
+      self.component.instance_variable_get("@filename")
+    )}
+    __category__(:decorators).component_eval {(
+      declare_meme(:import, [], 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, *args| (
+            load_paths = [
+              meme.target.instance.dirname
+            ]
+            scope = meme.target.constant_scope
+            component = ::Myco.find_constant(:Myco).eval_file(
+              meme.name.to_s,
+              load_paths,
+              false,
+              scope
+            )
+            meme.target.include(component)
+          )}
+        )}}.instance
+      )}
+    )}
+  )}}
+  .tap { |__c__| __c__.__name__ = :FileToplevel }
+)}}.instance

data/lib/myco/core/Object.my.rb

@@ -0,0 +1,55 @@
+::Myco::Component.new([
+  ::Myco::FileToplevel
+], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  ::Myco::Object = ::Myco::Component.new([
+    ::Myco::BasicObject
+  ], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+    declare_meme(:__signal__, [], nil, ::Myco.cscope.dup) { |name, *args, &block| (
+      self.component.ancestors.reverse.each { |other| (
+        ::Myco.branch_op(:"&&", other.__send__(
+          :is_a?,
+          ::Myco.find_constant(:Component)
+        )) {(
+          inst = ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.component.__send__(
+            :==,
+            other
+          )) {self}) {other.instance}
+          (((inst.respond_to?(:decorators).false? ? ::Myco::Void : inst.decorators).respond_to?(:on).false? ? ::Myco::Void : (inst.respond_to?(:decorators).false? ? ::Myco::Void : inst.decorators).on).respond_to?(:signal_handlers).false? ? ::Myco::Void : ((inst.respond_to?(:decorators).false? ? ::Myco::Void : inst.decorators).respond_to?(:on).false? ? ::Myco::Void : (inst.respond_to?(:decorators).false? ? ::Myco::Void : inst.decorators).on).signal_handlers(name)).each { |meme| (
+            meme.result_for(
+              self,
+              *args,
+              &block
+            )
+          )}
+        )}
+      )}
+    )}
+    __category__(:decorators).component_eval {(
+      declare_meme(:on, [
+        [:var, []]
+      ], 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(:signal_handlers, [
+            [:storage, []]
+          ], nil, ::Myco.cscope.dup) { |*| (
+            ::Myco.find_constant(:Array).new
+          )}
+          declare_meme(:apply, [], nil, ::Myco.cscope.dup) { |meme| (
+            self.signal_handlers(meme.name).push(meme)
+          )}
+          __category__(:transforms).component_eval {(
+            declare_meme(:expose, [], nil, ::Myco.cscope.dup) { |*| (
+              false
+            )}
+          )}
+        )}}.instance
+      )}
+    )}
+  )}}
+  .tap { |__c__| __c__.__name__ = :Object }
+)}}.instance

data/lib/myco/core/Switch.my.rb

@@ -0,0 +1,74 @@
+::Myco::Component.new([
+  ::Myco::FileToplevel
+], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  ::Myco::Switch = ::Myco::Component.new([
+    ::Myco::Object
+  ], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+    declare_meme(:input, [
+      [:var, []]
+    ], nil, ::Myco.cscope.dup) { |*| (
+      ::Myco::Void
+    )}
+    declare_meme(:output, [
+      [:var, []]
+    ], nil, ::Myco.cscope.dup) { |*| (
+      ::Myco::Void
+    )}
+    declare_meme(:matched, [
+      [:var, []]
+    ], nil, ::Myco.cscope.dup) { |*| (
+      false
+    )}
+    declare_meme(:comparator, [
+      [:var, []]
+    ], nil, ::Myco.cscope.dup) { |*| (
+      :==
+    )}
+    declare_meme(:when, [], nil, ::Myco.cscope.dup) { |expected, &blk| (
+      ::Myco.branch_op(:"||", self.matched) {::Myco.branch_op(:"&&", self.input.send(
+        self.comparator,
+        expected
+      )) {::Myco.branch_op(:"&&", self.__send__(
+        :matched=,
+        true
+      )) {self.__send__(
+        :output=,
+        blk.call(self.input)
+      )}}}
+      self
+    )}
+    declare_meme(:when_true, [], nil, ::Myco.cscope.dup) { |&blk| (
+      ::Myco.branch_op(:"||", self.matched) {::Myco.branch_op(:"&&", self.input) {::Myco.branch_op(:"&&", self.__send__(
+        :matched=,
+        true
+      )) {self.__send__(
+        :output=,
+        blk.call(self.input)
+      )}}}
+      self
+    )}
+    declare_meme(:when_false, [], nil, ::Myco.cscope.dup) { |&blk| (
+      ::Myco.branch_op(:"||", self.matched) {::Myco.branch_op(:"||", self.input) {::Myco.branch_op(:"&&", self.__send__(
+        :matched=,
+        true
+      )) {self.__send__(
+        :output=,
+        blk.call(self.input)
+      )}}}
+      self
+    )}
+    declare_meme(:else, [], nil, ::Myco.cscope.dup) { |&blk| (
+      ::Myco.branch_op(:"||", self.matched) {::Myco.branch_op(:"&&", self.__send__(
+        :matched=,
+        true
+      )) {self.__send__(
+        :output=,
+        blk.call(self.input)
+      )}}
+      self
+    )}
+  )}}
+  .tap { |__c__| __c__.__name__ = :Switch }
+)}}.instance

data/lib/myco/tools/BasicCommand.my.rb

@@ -0,0 +1,84 @@
+::Myco::Component.new([
+  ::Myco::FileToplevel
+], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  ::Myco.cscope.for_method_definition.const_set(:BasicCommand, ::Myco::Component.new([
+    ::Myco.find_constant(:Object)
+  ], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+    declare_meme(:banner, [], nil, ::Myco.cscope.dup) { |*| (
+      ""
+    )}
+    declare_meme(:width, [], nil, ::Myco.cscope.dup) { |*| (
+      30
+    )}
+    declare_meme(:options_config, [], nil, ::Myco.cscope.dup) { |*| (
+      nil
+    )}
+    declare_meme(:options_parse, [], nil, ::Myco.cscope.dup) { |*argv| (
+      command = ::Myco.branch_op(:"&&", argv.first) {self.commands.memes.__send__(
+        :[],
+        argv.first.to_sym
+      )}
+      ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", command) {(
+        command.result.run(*argv.slice(::Range.new(
+          1,
+          -1
+        )))
+        nil
+      )}) {self.options_parser.parse(argv)}
+    )}
+    declare_meme(:options_parser, [], nil, ::Myco.cscope.dup) { |*| (
+      parser = ::Myco.find_constant(:Rubinius)::Options.new(
+        self.banner,
+        self.width,
+        self.options_config
+      )
+      self.options.memes.each { |name, meme| (
+        meme.result.register_in_parser(
+          parser,
+          name
+        )
+      )}
+      parser.help
+      parser
+    )}
+    declare_meme(:show_help, [], nil, ::Myco.cscope.dup) { |*| (
+      self.puts(self.options_parser.to_s)
+    )}
+    ::Myco.cscope.for_method_definition.const_set(:Option, ::Myco::Component.new([
+      ::Myco.find_constant(:Object)
+    ], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+      declare_meme(:parser, [
+        [:var, []]
+      ], nil, ::Myco.cscope.dup) { |*| nil}
+      declare_meme(:register_in_parser, [], nil, ::Myco.cscope.dup) { |parser, name| (
+        self.__send__(
+          :parser=,
+          parser
+        )
+        args = [
+          name,
+          ::Myco.branch_op(:"??", (self.respond_to?(:argument).false? ? ::Myco::Void : self.argument)) {nil},
+          self.long_form,
+          self.description
+        ]
+        args = args.compact
+        args = args.map { |arg| (
+          arg.to_s
+        )}
+        parser.on(*args) { |arg| (
+          self.__send__(
+            :do,
+            arg
+          )
+        )}
+      )}
+    )}})
+    .tap { |__c__| __c__.__name__ = :Option }
+    __category__(:options).component_eval {nil}
+    __category__(:commands).component_eval {nil}
+  )}})
+  .tap { |__c__| __c__.__name__ = :BasicCommand }
+)}}.instance

data/lib/myco/tools/mycompile.my.rb

@@ -0,0 +1,136 @@
+::Myco::Component.new([
+  ::Myco::FileToplevel
+], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:"OptionParser.my", [
+    [:import, []]
+  ], nil, ::Myco.cscope.dup) { |*| nil}
+  ::Myco::Component.new([
+    ::Myco.find_constant(:Object)
+  ], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+    declare_meme(:options, [
+      [:var, []]
+    ], nil, ::Myco.cscope.dup) { |*| (
+      ::Myco::Component.new([
+        ::Myco.find_constant(:OptionParser)
+      ], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+      .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+        declare_meme(:results, [
+          [:var, []]
+        ], nil, ::Myco.cscope.dup) { |*| (
+          nil
+        )}
+        __category__(:options).component_eval {(
+          declare_meme(:"-A", [], nil, ::Myco.cscope.dup) { |*| (
+            ::Myco::Component.new([
+              ::Myco.find_constant(:Option)
+            ], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+            .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+              declare_meme(:description, [], nil, ::Myco.cscope.dup) { |*| (
+                "Print an ascii graph of the AST"
+              )}
+              declare_meme(:long_form, [], nil, ::Myco.cscope.dup) { |*| (
+                "--print-ast"
+              )}
+              declare_meme(:do, [], nil, ::Myco.cscope.dup) { |*| (
+                self.__send__(
+                  :results=,
+                  ::Myco.find_constant(:Myco)::ToolSet::Compiler::ASTPrinter,
+                  :print_ast
+                )
+              )}
+            )}}.instance
+          )}
+          declare_meme(:"-S", [], nil, ::Myco.cscope.dup) { |*| (
+            ::Myco::Component.new([
+              ::Myco.find_constant(:Option)
+            ], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+            .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+              declare_meme(:description, [], nil, ::Myco.cscope.dup) { |*| (
+                "Print the AST as an S-expression"
+              )}
+              declare_meme(:long_form, [], nil, ::Myco.cscope.dup) { |*| (
+                "--print-sexp"
+              )}
+              declare_meme(:do, [], nil, ::Myco.cscope.dup) { |*| (
+                self.__send__(
+                  :results=,
+                  ::Myco.find_constant(:Myco)::ToolSet::Compiler::SexpPrinter,
+                  :print_ast
+                )
+              )}
+            )}}.instance
+          )}
+          declare_meme(:"-B", [], nil, ::Myco.cscope.dup) { |*| (
+            ::Myco::Component.new([
+              ::Myco.find_constant(:Option)
+            ], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+            .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+              declare_meme(:description, [], nil, ::Myco.cscope.dup) { |*| (
+                "Print bytecode for compiled methods"
+              )}
+              declare_meme(:long_form, [], nil, ::Myco.cscope.dup) { |*| (
+                "--print-bytecode"
+              )}
+              declare_meme(:do, [], nil, ::Myco.cscope.dup) { |*| (
+                self.__send__(
+                  :results=,
+                  true,
+                  :print_bytecode
+                )
+              )}
+            )}}.instance
+          )}
+          declare_meme(:"-e", [], nil, ::Myco.cscope.dup) { |*| (
+            ::Myco::Component.new([
+              ::Myco.find_constant(:Option)
+            ], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+            .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+              declare_meme(:argument, [], nil, ::Myco.cscope.dup) { |*| (
+                "STRING"
+              )}
+              declare_meme(:description, [], nil, ::Myco.cscope.dup) { |*| (
+                "Compile STRING"
+              )}
+              declare_meme(:long_form, [], nil, ::Myco.cscope.dup) { |*| (
+                "--evaluate"
+              )}
+              declare_meme(:do, [], nil, ::Myco.cscope.dup) { |arg| (
+                self.__send__(
+                  :results=,
+                  arg,
+                  :string
+                )
+              )}
+            )}}.instance
+          )}
+        )}
+      )}}.instance
+    )}
+    declare_meme(:run, [], nil, ::Myco.cscope.dup) { |*argv| (
+      self.options.parse(argv)
+      print_ast = ::Myco.branch_op(:"||", self.options.results(:print_ast)) {false}
+      string = ::Myco.branch_op(:"||", self.options.results(:string)) {""}
+      compiler = ::Myco::ToolSet::Compiler
+      compiler = compiler.new(
+        :string,
+        :compiled_code
+      )
+      parser = compiler.parser
+      parser.root(::Myco::ToolSet::AST::Script)
+      parser.input(
+        string,
+        "(mycompile)",
+        1
+      )
+      self.__send__(
+        :if,
+        print_ast
+      ) { || (
+        compiler.parser.print(print_ast)
+      )}
+      compiler.run
+    )}
+  )}}.instance
+)}}.instance

data/lib/myco/version.rb

@@ -1,6 +1,6 @@
 
 module Myco
-  MYCO_VERSION = '0.1.0'
+  MYCO_VERSION = '0.1.1'
   
   MYCO_REQUIRED_GEMS = [
     ['rubinius-toolset',   '~> 2.3'],

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: myco
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Joe McIlvain
@@ -11,187 +11,173 @@ cert_chain: []
 date: 2015-02-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.3'
-  name: rubinius-toolset
+  type: :runtime
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.3'
-  type: :runtime
+  name: rubinius-toolset
   prerelease: false
-- !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.2'
-  name: rubinius-melbourne
+        version: '2.3'
+- !ruby/object:Gem::Dependency
+  type: :runtime
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.2'
-  type: :runtime
+  name: rubinius-melbourne
   prerelease: false
-- !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.2'
-  name: rubinius-processor
+- !ruby/object:Gem::Dependency
+  type: :runtime
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.2'
-  type: :runtime
+  name: rubinius-processor
   prerelease: false
-- !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.2'
-  name: rubinius-compiler
+- !ruby/object:Gem::Dependency
+  type: :runtime
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.2'
-  type: :runtime
+  name: rubinius-compiler
   prerelease: false
-- !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.2'
-  name: rubinius-ast
+- !ruby/object:Gem::Dependency
+  type: :runtime
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.2'
-  type: :runtime
+  name: rubinius-ast
   prerelease: false
-- !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
-  name: kpeg
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  type: :development
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
-  type: :development
+  name: kpeg
   prerelease: false
-- !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.6'
-  name: bundler
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  type: :development
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.6'
-  type: :development
+  name: bundler
   prerelease: false
-- !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.3'
-  name: rake
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  type: :development
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.3'
-  type: :development
+  name: rake
   prerelease: false
-- !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.9'
-  name: pry
+        version: '10.3'
+- !ruby/object:Gem::Dependency
+  type: :development
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.9'
-  type: :development
+  name: pry
   prerelease: false
-- !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.4'
-  name: pry-rescue
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  type: :development
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.4'
-  type: :development
+  name: pry-rescue
   prerelease: false
-- !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
-  name: rspec
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  type: :development
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
-  type: :development
+  name: rspec
   prerelease: false
-- !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
-  name: rspec-its
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
-  type: :development
-  prerelease: false
+        version: '3.0'
 - !ruby/object:Gem::Dependency
-  requirement: !ruby/object:Gem::Requirement
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
   name: fivemat
-  version_requirements: !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
-  type: :development
-  prerelease: false
 description: An experimental language on the Rubinius VM
 email: joe.eli.mac@gmail.com
 executables:
@@ -205,6 +191,7 @@ files:
 - lib/myco.rb
 - lib/myco/backtrace.rb
 - lib/myco/bootstrap.my
+- lib/myco/bootstrap.my.rb
 - lib/myco/bootstrap.rb
 - lib/myco/bootstrap/component.rb
 - lib/myco/bootstrap/empty_object.rb
@@ -215,15 +202,23 @@ files:
 - lib/myco/bootstrap/void.rb
 - lib/myco/code_loader.rb
 - lib/myco/command.my
+- lib/myco/command.my.rb
 - lib/myco/command/inoculate.my
+- lib/myco/command/inoculate.my.rb
 - lib/myco/core/BasicDecorators.my
+- lib/myco/core/BasicDecorators.my.rb
 - lib/myco/core/BasicObject.my
+- lib/myco/core/BasicObject.my.rb
 - lib/myco/core/Category.my
+- lib/myco/core/Category.my.rb
 - lib/myco/core/Decorator.my
+- lib/myco/core/Decorator.my.rb
 - lib/myco/core/FileToplevel.my
-- lib/myco/core/Myco.my
+- lib/myco/core/FileToplevel.my.rb
 - lib/myco/core/Object.my
+- lib/myco/core/Object.my.rb
 - lib/myco/core/Switch.my
+- lib/myco/core/Switch.my.rb
 - lib/myco/eval.rb
 - lib/myco/misc.rb
 - lib/myco/parser.rb
@@ -286,8 +281,9 @@ files:
 - lib/myco/parser/ast/to_ruby/void_literal.rb
 - lib/myco/parser/peg_parser.rb
 - lib/myco/tools/BasicCommand.my
-- lib/myco/tools/Generator.my
+- lib/myco/tools/BasicCommand.my.rb
 - lib/myco/tools/mycompile.my
+- lib/myco/tools/mycompile.my.rb
 - lib/myco/toolset.rb
 - lib/myco/version.rb
 homepage: https://github.com/jemc/myco/
@@ -315,3 +311,4 @@ signing_key:
 specification_version: 4
 summary: An experimental language on the Rubinius VM
 test_files: []
+has_rdoc: 

data/lib/myco/core/Myco.my

@@ -1,4 +0,0 @@
-
-Myco << {
-  sclass foo: 88
-}

data/lib/myco/tools/Generator.my

@@ -1,18 +0,0 @@
-
-Myco::Generator < Object {
-  
-}
-
-Myco::Generator {
-  
-  task: rand ** rand
-  
-  work: 100000.times { task }
-  
-  on creation: {
-    ruby_require('rubinius/profiler')
-    prof = Rubinius::Profiler::Instrumenter.new
-    prof.profile { work }
-    prof.show
-  }
-}