myco 0.1.0.dev → 0.1.0

data/lib/myco/code_loader.rb

@@ -0,0 +1,332 @@
+
+module Myco
+  
+  class CodeLoader
+    
+    class << self
+      attr_accessor :emit_rb  # Whether to cache generated ruby code to disk.
+      attr_accessor :emit_rbc # Whether to cache rubinius bytecode to disk.
+      attr_accessor :precedence # Order of precedence for file types.
+    end
+    self.emit_rb = false # Do not emit ruby code by default.
+    self.emit_rbc = true # Do cache rubinius bytecode by default.
+    
+    # Use cached rubinius bytecode files if they are up to date.
+    # Use Myco files otherwise.
+    # Use generated ruby files only when Myco files cannot be found or loaded.
+    self.precedence = [:rbc, :myco, :rb]
+    
+    # TODO: a more elegant solution than env vars
+    # Emit ruby if env var indicates
+    # Load from ruby exclusively if env var indicates
+    self.emit_rb    = true    if ENV['MYCO_TO_RUBY'] == 'PRE'
+    self.precedence = [:myco] if ENV['MYCO_TO_RUBY'] == 'PRE'
+    
+    # Try to resolve the given file path
+    # in the current working directory or in the given load paths.
+    def self.resolve_file path, load_paths=[]
+      tmp_path = File.expand_path(path)
+      use_path = File.file?(tmp_path) && tmp_path
+      load_paths.each { |load_path|
+        break if use_path
+        tmp_path = File.expand_path(path, load_path)
+        use_path = File.file?(tmp_path) && tmp_path
+      }
+      
+      use_path
+    end
+    
+    # Select a loader and file path for the given path,
+    # considering the currently selected order of precedence for file types.
+    def self.loader_for_file path, load_paths=[]
+      use_path = resolve_file(path, load_paths)
+      
+      # TODO: This logic could be refactored to look cleaner
+      if use_path
+        # Try to find an implementation with higher precedence than :myco
+        # With a file that has been modified at least as recently as
+        # the resolved file in use_path.
+        ref_mtime = File.mtime(use_path)
+        precedence.each { |type|
+          begin
+            if type==:myco
+              return loader_for(type, use_path)
+            else
+              alt_path = use_path + ".#{type}"
+              if File.file?(alt_path) && (File.mtime(alt_path) >= ref_mtime)
+                return loader_for(type, alt_path)
+              end
+            end
+          rescue NotImplementedError # Skip loader if not implemented
+          end
+        }
+      else
+        # Try to find any implementation other than :myco, in precedence order.
+        precedence.each { |type|
+          if type != :myco
+            alt_path = resolve_file(path + ".#{type}", load_paths)
+            if alt_path && File.file?(alt_path)
+              return loader_for(type, alt_path)
+            end
+          end
+        }
+      end
+      
+      raise ArgumentError, "Couldn't resolve file: #{path.inspect} \n" \
+                           "in load_paths: #{load_paths.inspect}" \
+    end
+    
+    # Return a loader of the given type with the given arguments
+    def self.loader_for type, *args
+      case type
+      when :myco; MycoLoader.new(*args)
+      when :rbc;  BytecodeLoader.new(*args)
+      when :rb;   RubyLoader.new(*args)
+      else;       raise NotImplementedError
+      end
+    end
+    
+    # Load from the given path and load_paths and call
+    # under the given ConstantScope, VariableScope, and receiver.
+    # If cscope or vscope or receiver are nil, they are pulled from
+    # the given call_depth, corresponding to one of the calling frames.
+    # 
+    def self.load path, load_paths=[], call_depth:1, **kwargs
+      begin
+        loader = loader_for_file(path, load_paths)
+        loader.bind_to(call_depth:call_depth+1, **kwargs)
+        loader.compile
+        loader.emit_rb!  if self.emit_rb
+        loader.emit_rbc! if self.emit_rbc
+        loader.load
+      rescue Rubinius::InvalidRBC
+        retry
+      end
+    end
+    
+    class AbstractLoader
+      attr_accessor :filename, :line
+      attr_accessor :constant_scope, :variable_scope, :receiver
+      
+      attr_accessor :string
+      attr_accessor :ast
+      attr_accessor :generator
+      attr_accessor :compiled_code
+      attr_accessor :block_environment
+      
+      def initialize filename, line = 1
+        @filename = filename
+        @line     = line
+      end
+      
+      def bind_to cscope:nil, vscope:nil, receiver:nil,
+                  call_depth:1
+        loc = Rubinius::VM.backtrace(call_depth, true).first
+        @constant_scope = cscope || loc.constant_scope
+        @variable_scope = vscope || loc.variables
+        @receiver =     receiver || loc.instance_variable_get(:@receiver)
+        
+        self
+      end
+      
+      def make_string
+        @string = File.read(filename)
+      end
+      
+      def make_ast
+        @string || make_string
+        
+        parser = parser_type.new(@filename, @line, [])
+        ast = parser.parse_string(@string)
+        
+        ast = ast_root_type.new(ast) if ast_root_type
+        ast.file = filename.to_sym
+        ast.variable_scope = @variable_scope
+        
+        @ast = ast
+      end
+      
+      def make_generator
+        @ast || make_ast
+        
+        g = generator_type.new
+        @ast.bytecode(g)
+        
+        g.close
+        g.encode
+        
+        @generator = g
+      end
+      
+      def make_compiled_code
+        @generator || make_generator
+        
+        code = @generator.package(Rubinius::CompiledCode)
+        
+        @compiled_code = code
+      end
+      
+      def make_block_environment
+        @compiled_code || make_compiled_code
+        code = @compiled_code
+        
+        code.scope = @constant_scope
+        script = Rubinius::CompiledCode::Script.new(code, @filename, true)
+        script.eval_source = @string
+        code.scope.script = script
+        
+        be = Rubinius::BlockEnvironment.new
+        be.under_context(@variable_scope, code)
+        
+        @block_environment = be
+      end
+      
+      def compile
+        @block_environment || make_block_environment
+      end
+      
+      def load
+        compile
+        @block_environment.call_on_instance(@receiver)
+      end
+      
+      def emit_rb! filename=nil
+        @ast || make_ast
+        
+        filename = emit_filename('.rb', filename)
+        return nil unless filename
+        
+        File.open(filename, "w+") { |file| file.write(@ast.to_ruby_code) }
+      end
+      
+      def emit_rbc! filename=nil
+        @compiled_code || make_compiled_code
+        
+        filename = emit_filename('.rbc', filename)
+        return nil unless filename
+        
+        compiled_file_type.dump(
+          @compiled_code, filename, Rubinius::Signature, 0
+        )
+      end
+      
+      def is_rb?;  false end
+      def is_rbc?; false end
+      
+      private
+      
+      # Return @filename, stripped of any .rbc or .rb file extension
+      def myco_filename
+        @filename.sub(/\.rbc?$/, '')
+      end
+      
+      def mkdir_p dir
+        # TODO: do manually, without depending on FileUtils
+        require 'fileutils'
+        FileUtils.mkdir_p(dir)
+      end
+      
+      # Return the filename to emit, or nil if the file is already current
+      # relative to modification time of the file at the myco_filename.
+      def emit_filename file_ext, override=nil
+        if override
+          filename = override
+        else
+          orig_filename = myco_filename
+          filename ||= orig_filename + file_ext
+          
+          if File.file?(myco_filename)
+            ref_mtime = File.mtime(myco_filename)
+            if File.file?(filename) && (File.mtime(filename) >= ref_mtime)
+              return nil
+            end
+          end
+        end
+        
+        mkdir_p(File.dirname(filename))
+        return filename
+      end
+    end
+    
+    class MycoLoader < AbstractLoader
+      def initialize *args
+        # TODO: a more elegant solution than env vars
+        raise NotImplementedError if ENV['MYCO_TO_RUBY'] == 'POST'
+        super
+      end
+      
+      def ast_root_type
+        Myco::ToolSet::AST::EvalExpression
+      end
+      
+      def parser_type
+        Myco::ToolSet::Parser
+      end
+      
+      def generator_type
+        Myco::ToolSet::Generator
+      end
+      
+      def compiled_file_type
+        Myco::ToolSet::CompiledFile
+      end
+    end
+    
+    class RubyLoader < AbstractLoader
+      def is_rb?; true end
+      
+      def emit_rb!; nil end
+      
+      def initialize *args
+        super *args
+      end
+      
+      def ast_root_type
+        Rubinius::ToolSets::Runtime::AST::EvalExpression
+      end
+      
+      def parser_type
+        Rubinius::ToolSets::Runtime::Melbourne
+      end
+      
+      def generator_type
+        Rubinius::ToolSets::Runtime::Generator
+      end
+      
+      def compiled_file_type
+        Rubinius::ToolSets::Runtime::CompiledFile
+      end
+    end
+    
+    class BytecodeLoader < AbstractLoader
+      def is_rbc?; true end
+      
+      def emit_rb!;  nil end
+      def emit_rbc!; nil end
+      
+      def initialize *args
+        # TODO: a more elegant solution than env vars
+        raise NotImplementedError if ENV['MYCO_TO_RUBY'] == 'POST'
+        super
+      end
+      
+      def make_compiled_code
+        begin
+          @compiled_code = primitive_load_file \
+            @filename, Rubinius::Signature, Rubinius::RUBY_LIB_VERSION
+        rescue Rubinius::InvalidRBC => e
+          File.delete @filename
+          raise e
+        end
+      end
+      
+      private
+      
+      def primitive_load_file(path, signature, version)
+        Rubinius.primitive :compiledfile_load
+        raise Rubinius::InvalidRBC, "Invalid RBC file: #{path}"
+      end
+    end
+  end
+  
+end

data/lib/myco/command/inoculate.my

@@ -0,0 +1,83 @@
+
+import "../tools/BasicCommand.my"
+
+BasicCommand {
+  banner: "Usage: myco inoculate [options]"
+  
+  # TODO: move this out of here
+  shell: |*a,&b| Kernel.instance_method(:system).bind(self).call(*a,&b)
+  
+  run: |*argv| {
+    destinations = options_parse(*argv)
+    destinations.size == 1
+    |? show_help
+    ?? 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'))
+      
+      if(config.verbose) {
+        prog = Rubinius::Globals[:"$PROGRAM_NAME"]
+        puts("DONE "prog" "ARGV.join(" ")"")
+      }
+    }
+  }
+  
+  run_operation: |opcode, source_list| {
+    source_list.each |source| {
+      dest = transforms.send(opcode, source)
+      
+      unless(operation_is_unnecessary(source, dest)) {
+        if(config.verbose) {
+          puts(""opcode.upcase" "source"")
+          puts("  => "dest"")
+        }
+        operations.send(opcode, source, dest)
+      }
+    }
+  }
+  
+  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""))
+  }
+  
+  [operations]
+  
+  copy: |source, dest|
+    shell("mkdir -p "File.dirname(dest)" && cp "source" "dest"")
+  myrb: |source, dest|
+    Myco::CodeLoader::MycoLoader.new(source).emit_rb!
+  
+  [transforms]
+  
+  copy: |filename| File.join(config.dest, filename)
+  myrb: |filename| ""filename".rb"
+  
+  [config]
+  
+  var source
+  var dest
+  var verbose
+  
+  [options]
+  
+  "-d": Option {
+    description: "The destination directory to clone material into."
+    long_form: "--dest"
+    argument: "STRING"
+    do: |arg| parent.config.dest = arg
+  }
+  
+  "-v": Option {
+    description: "Show details about material cloning operations."
+    long_form: "--verbose"
+    do: |arg| parent.config.verbose = true
+  }
+}

data/lib/myco/command.my

@@ -1,33 +1,33 @@
 
-import "tools/OptionParser.my"
+import "tools/BasicCommand.my"
 
-Object {
-  var options: OptionParser {
-    storage results: null
-    
-    banner: "Usage: myco [options] [files]"
-    
-    [options]
-    
-    "-E": Option {
-      description: "Evaluate a string of declarative Myco"
-      long_form: "--eval"
-      argument: "STRING"
-      do: |arg| Myco.eval(arg)
-    }
-    
-    "-e": Option {
-      description: "Evaluate a string of procedural Myco inside an Object"
-      long_form: "--eval-meme"
-      argument: "STRING"
-      do: |arg| Myco.eval("Object { on creation: "arg" }")
-    }
-  }
+BasicCommand {
+  banner: "Usage: myco [subcommand] [options] [files]"
+  
+  on creation: run(*ARGV)
   
   run: |*argv| {
-    files = options.parse(argv)
-    files.uniq.each |file| { Myco.eval_file(file, [::Dir.pwd]) }
+    files = options_parse(*argv)
+    files && files.uniq.each |file| { Myco.eval_file(file, [::Dir.pwd]) }
   }
   
-  on creation: run(*ARGV)
+  [options]
+  
+  "-E": Option {
+    description: "Evaluate a string of declarative Myco"
+    long_form: "--eval"
+    argument: "STRING"
+    do: |arg| Myco.eval(arg)
+  }
+  
+  "-e": Option {
+    description: "Evaluate a string of procedural Myco inside an Object"
+    long_form: "--eval-meme"
+    argument: "STRING"
+    do: |arg| Myco.eval("Object { on creation: { "arg" } }")
+  }
+  
+  [commands]
+  
+  "inoculate": Myco.eval_file("command/inoculate.my")
 }

data/lib/myco/core/BasicDecorators.my

@@ -0,0 +1,62 @@
+
+::Myco::BasicDecorators < ::Myco::EmptyObject {
+  [decorators]
+  
+  # The 'storage' decorator acts like a set of var decorators
+  # TODO: consolidate with 'var'
+  storage: Decorator {
+    # Create a corresponding "writer" meme to go with this "reader" meme
+    apply: |meme| {
+      meme.target.declare_meme(:""meme.name"=") |new_value, *args| {
+        meme.set_result_for(self, new_value, *args)
+      }
+    }
+    
+    [transforms]
+    cache: true # Enable caching of the value to act as storage
+  }
+  
+  # The 'var' decorator creates an instance variable getter and setter:
+  var: Decorator {
+    [transforms]
+    var: true
+  }
+  
+  # The 'memoize' decorator enables caching of the result
+  memoize: Decorator {
+    [transforms]
+    cache: true
+  }
+  
+  # The 'sclass' decorator makes the component's singleton class the target
+  sclass: Decorator {
+    [transforms]
+    target: |meme| meme.target.singleton_class
+  }
+  
+  # The 'before' decorator defines a wrapper that runs before the existing meme
+  before: Decorator {
+    apply: |meme| {
+      orig_meme = meme.target.memes[meme.name]
+      wrap_meme = meme.dup
+      meme.body = Proc.new |*a,&b| {
+        wrap_meme.result_for(self,*a,&b)
+        orig_meme.result_for(self,*a,&b)
+      }
+    }
+  }
+  
+  # The 'after' decorator defines a wrapper that runs after the existing meme
+  after: Decorator {
+    apply: |meme| {
+      orig_meme = meme.target.memes[meme.name]
+      wrap_meme = meme.dup
+      meme.body = Proc.new |*a,&b| {
+        result = \
+        orig_meme.result_for(self,*a,&b)
+        wrap_meme.result_for(self,*a,&b)
+        result
+      }
+    }
+  }
+}

data/lib/myco/core/BasicObject.my

@@ -1,46 +1,24 @@
 
-::Myco::BasicObject < ::Myco::EmptyObject {
+::Myco::BasicObject < ::Myco::EmptyObject, ::Myco::BasicDecorators {
   # Basic conditional handling
   if:     |cond, &blk| cond && blk.call
   unless: |cond, &blk| cond || blk.call
   switch: |input,comparator=:"=="|
     Switch.new(input:input, comparator:comparator)
   
+  # TODO: alias more efficiently
+  # alias(::Kernel, :raise) raise
+  # alias(::Kernel, :loop) loop
+  raise: |*args| ::Kernel.instance_method(:raise).bind(self).call(*args)
+  loop: |&block| ::Kernel.instance_method(:loop).bind(self).call(&block)
+  break: raise(::StopIteration)
+  
   puts: |*args| STDOUT.puts(*args)
   p:    |*args| STDOUT.puts(args.map |a| { a.inspect }.join(', '))
   
   ruby_require: |arg| Object.send(:require, arg)
-  
-  [decorators]
-  
-  # The 'var' decorator creates what is effectively an instance variable by:
-  # 1) enabling caching, keeping the given block from being re-run,
-  #    unless run from an inheriting object (which would get its own "copy")
-  # 2) TODO: prohibiting sending of any arguments
-  # 3) creating a "writer" function in addition to the "reader"
-  var: Decorator {
-    # Create a corresponding "writer" meme to go with this "reader" meme
-    apply: |meme| {
-      meme.target.declare_meme(:""meme.name"=") |new_value| {
-        meme.set_result_for(self, new_value)
-      }
-    }
-    
-    [transforms]
-    cache: true # Enable caching of the value to act as storage
-  }
-  
-  # The 'storage' decorator acts like a set of var decorators
-  # TODO: consolidate with 'var'
-  storage: Decorator {
-    # Create a corresponding "writer" meme to go with this "reader" meme
-    apply: |meme| {
-      meme.target.declare_meme(:""meme.name"=") |new_value, *args| {
-        meme.set_result_for(self, new_value, *args)
-      }
-    }
-    
-    [transforms]
-    cache: true # Enable caching of the value to act as storage
-  }
 }
+
+# Because ::Myco::Instance is a ::BasicObject, we must shadow ::BasicObject here
+::Myco::Instance::BasicObject: ::Myco::BasicObject
+

data/lib/myco/core/Decorator.my

@@ -13,6 +13,7 @@
     self .? name(meme)   .tap |x| { meme.name    = x }
     self .? body(meme)   .tap |x| { meme.body    = x }
     self .? cache(meme)  .tap |x| { meme.cache   = x }
+    self .? var(meme)    .tap |x| { meme.var     = x }
     self .? expose(meme) .tap |x| { meme.expose  = x }
   }
 }

data/lib/myco/core/FileToplevel.my

@@ -11,9 +11,6 @@
   # importing the constants defined therein into the current namespace.
   import: Decorator {
     apply: |meme, *args| {
-      # TODO: shouldn't have to use meme.target here;
-      # should be able to use 'parent' to reach the outer objects
-      # while still referring to distinct instances rather than the originals.
       load_paths = [meme.target.instance.dirname]
       scope = meme.target.constant_scope
       component = Myco.eval_file(meme.name.to_s, load_paths, false, scope)

data/lib/myco/core/Myco.my

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

data/lib/myco/core/Object.my

@@ -3,10 +3,12 @@
   # Send the named signal to all handlers for this object
   __signal__: |name, *args, &block| {
     component.ancestors.reverse.each |other| {
-      inst = (component == other) && self || other.instance
-      inst.?decorators.?on.?signal_handlers(name).each |meme| {
-        meme.result_for(self, *args, &block)
-      }
+      other.is_a?(Component) && (
+        inst = (component == other) &? self ?? other.instance
+        inst.?decorators.?on.?signal_handlers(name).each |meme| {
+          meme.result_for(self, *args, &block)
+        }
+      )
     }
   }
   

data/lib/myco/eval.rb

@@ -2,7 +2,8 @@
 module Myco
   
   # Most of method is stolen from Rubinius implementation of Kernel#eval
-  def self.eval(string, scope=nil, filename=nil, lineno=nil)
+  # TODO: remove in favor of CodeLoader
+  def self.eval(string, scope=nil, filename=nil, lineno=nil, type=:myco)
     string = StringValue(string)
     filename = StringValue(filename) if filename
     lineno = Rubinius::Type.coerce_to lineno, Fixnum, :to_i if lineno
@@ -20,34 +21,32 @@ module Myco
     existing_scope = binding.constant_scope
     binding.constant_scope = existing_scope.dup
     
-    c = Myco::ToolSet::Compiler
-    be = c.construct_block string, binding, filename, lineno
+    compiler_class = case type
+    when :myco; Myco::ToolSet::Compiler
+    when :ruby; Rubinius::ToolSets::Runtime::Compiler
+    else; raise NotImplementedError
+    end
+    
+    be = compiler_class.construct_block string, binding, filename, lineno
     
     result = be.call_on_instance(binding.self)
     binding.constant_scope = existing_scope
     result
   end
   
-  # TODO: replace with proper import set of functions
+  # TODO: deprecate with proper import set of functions
   def self.eval_file path, load_paths=nil, get_last=true, scope=nil
     load_paths ||= [File.dirname(Rubinius::VM.backtrace(1).first.file)]
-    
-    tmp_path = File.expand_path(path)
-    use_path = File.file?(tmp_path) && tmp_path
-    load_paths.each do |load_path|
-      break if use_path
-      tmp_path = File.expand_path(path, load_path)
-      use_path = File.file?(tmp_path) && tmp_path
-    end
-    
-    raise ArgumentError, "Couldn't resolve file: #{path.inspect} \n" \
-                         "in load_paths: #{load_paths.inspect}" \
-      unless use_path
-    
-    file_toplevel = Myco.eval File.read(use_path), scope, use_path, 1
+    file_toplevel = CodeLoader.load(path, load_paths, cscope:scope, call_depth:1)
     get_last ? file_toplevel.component.__last__ : file_toplevel.component
   end
   
+  def self.file_to_ruby use_path
+    parser = Myco::ToolSet::Parser.new(use_path, 1, [])
+    ast = parser.parse_string File.read(use_path)
+    ast.to_ruby_code
+  end
+  
   def self.rescue
     begin
       yield