myco 0.1.0.dev

checksums.yaml

@@ -0,0 +1,7 @@
+--- 
+SHA1: 
+  metadata.gz: 3da0c78adac1604211cf6cd16c6eacd6e714591c
+  data.tar.gz: b6444fe6690546c9ed22b96fedc9a3bb1083030e
+SHA512: 
+  metadata.gz: e9b05edc6272eee428e038f4fae2b91d73aa83c0dd7e5941c50ec5d457a88d0920fc453826161606d8374d5fae0d9fc8bc3cea6d28bb394d1586ec87cb107195
+  data.tar.gz: 8b6193c91a85706f18cb09a529e575b571b4895a4e18f9f767b4e43ff525d84f871fd5d422219b28f372bbbcb8972afe275bcc086a4b6b3a895d1501b9896a11

data/LICENSE

@@ -0,0 +1,2 @@
+Copyright 2014 Joe McIlvain.
+All rights reserved.

data/bin/myco

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/myco'
+
+Myco.rescue do
+  Myco.eval_file("../lib/myco/command.my")
+end

data/lib/myco/backtrace.rb

@@ -0,0 +1,56 @@
+
+class Rubinius::Backtrace
+  def self.backtrace locations
+    ::Myco::Backtrace.new(locations || [Rubinius::Location::Missing.new])
+  end
+end
+
+
+class Myco::Backtrace < Rubinius::Backtrace
+  def initialize(*)
+    super
+    @gem_color = "\033[0;36m"
+    @gem_paths = [Rubinius::GEMS_PATH, Rubinius::RUNTIME_PATH]
+  end
+  
+  def show(sep="\n", show_color=true)
+    show_color &&= @colorize
+    clear = show_color ? "\033[0m" : ""
+    bold  = show_color ? "\033[1m" : ""
+    sbullet = "{"
+    ebullet = "}"
+    
+    @locations.map do |loc|
+      file = (loc.position(Dir.getwd) || "").sub /(\:\d+)$/, ' \1'
+      color = show_color ? color_from_loc(file, false) : ""
+      color = @gem_color if try_gem_path file
+      file_width = file.length + 1 + sbullet.length
+      
+      place = loc.instance_variable_get(:@method_module).to_s + '#'
+      place += loc.describe_method
+      place_width = place.length + 1 + ebullet.length
+      
+      padding = @width - file_width - place_width
+      padding += @width until padding >= 0
+      
+      file_line  = bold + color + sbullet + ' ' + clear + color + file
+      place_line = color + bold + place + ' ' + ebullet + clear
+      
+      output = file_line + ' '*padding + place_line
+      output = nil if file == "(myco_internal) :1"
+      output
+    end.compact.reverse.join sep
+  end
+  
+  # If file is in one of the GEM_PATHs, mutate the string and return true
+  def try_gem_path file
+    @gem_paths.each do |gem_path|
+      if file.start_with? gem_path and not gem_path.empty?
+        file.sub! File.join(gem_path, 'gems'), ''
+        file.sub! %r{/[^/]*/}, ''
+        return true
+      end
+    end
+    return false
+  end
+end

data/lib/myco/bootstrap/component.rb

@@ -0,0 +1,142 @@
+
+module Myco
+  class Component < Module
+    attr_accessor :__last__
+    attr_accessor :__name__
+    
+    attr_reader :parent
+    attr_reader :parent_meme
+    attr_reader :memes
+    attr_reader :categories
+    
+    attr_reader :constant_scope
+    
+    def to_s
+      if defined?(::Myco::Category) && (self < ::Myco::Category)
+        "#{parent.to_s}[#{@__name__}]"
+      elsif @__name__
+        @__name__.to_s
+      else
+        "#{@super_components.map(&:to_s).join(',')}" \
+          "(#{@basename}:#{@line.to_s} 0x#{object_id.to_s 16})"
+      end
+    end
+    
+    def self.new super_components=[], parent=nil, filename=nil, line=nil
+      locations = Rubinius::VM.backtrace(1,false)
+      
+      # Walk backwards on the backtrace until a lexical parent meme is found
+      i = 0
+      parent_meme = nil
+      current = nil
+      while true
+        current = locations[i]
+        break unless current
+        parent_meme = current.constant_scope.myco_meme
+        break if parent_meme
+        i += 1
+      end
+      @constant_scope = current.constant_scope if current
+      
+      # Get the filename and line from the VM if not specified
+      if !filename || !line
+        location = locations.first
+        filename ||= location.file
+        line     ||= location.line
+      end
+      
+      this = super()
+      
+      this.instance_eval {
+        @super_components = super_components
+        @memes       = { }
+        @parent      = parent
+        @filename    = filename
+        @line        = line
+        @basename    = File.basename @filename
+        @dirname     = File.dirname  @filename
+        @categories  = { nil => this }
+        @parent_meme = parent_meme
+      }
+      
+      all_categories = Hash.new { |h,k| h[k] = Array.new }
+      
+      super_components.each do |other|
+        this.include other if other
+        other.categories.each { |name, cat| all_categories[name] << cat }
+      end
+      
+      all_categories.each do |name, supers|
+        if name.nil?
+          this.categories[name] = this
+        else
+          this.categories[name] = this.__new_category__ name, supers, filename, line
+        end
+      end
+      
+      this
+    end
+    
+    def __category__ name
+      @categories[name] ||= __new_category__(name)
+    end
+    
+    def __new_category__ name, super_cats=[Category], filename=nil, line=nil
+      # Get the filename and line from the VM if not specified
+      if !filename || !line
+        location = Rubinius::VM.backtrace(2,false).first
+        filename ||= location.file
+        line     ||= location.line
+      end
+      
+      category = Component.new super_cats, self, filename, line
+      category.__name__ = name
+      category_instance = category.instance
+      declare_meme(name) { category_instance }
+      @memes[name].cache = true
+      
+      category
+    end
+    
+    def declare_meme name, decorations=[], body=nil, scope=nil, varscope=nil, &blk
+      body.scope = scope.dup if scope && body.respond_to?(:scope=)
+      meme = Meme.new self, name, body, &blk
+      
+      decorations.each do |decoration, arguments|
+        search_component = self<Category ? parent : self
+        decorators = search_component.categories[:decorators].instance
+        
+        raise KeyError, "Unknown decorator for #{self}##{name}: #{decoration}" \
+          unless decorators.respond_to?(decoration)
+        decorator = decorators.send(decoration)
+        decorator.transforms.apply meme, *arguments
+        decorator.apply meme, *arguments
+      end
+      meme.bind
+      
+      meme
+    end
+    
+    def instance
+      if !@instance
+        @instance = Instance.new(self)
+        @instance.extend self
+        yield @instance if block_given?
+        @instance.__signal__ :creation if @instance.respond_to? :__signal__
+      else
+        yield @instance if block_given?
+      end
+      
+      @instance
+    end
+    
+    def new parent=nil, **kwargs
+      loc = Rubinius::VM.backtrace(1,false).first
+      
+      Component.new([self], parent, loc.file, loc.line).instance { |instance|
+        kwargs.each { |key,val| instance.send :"#{key}=", val }
+      }
+    end
+  end
+  
+end

data/lib/myco/bootstrap/empty_object.rb

@@ -0,0 +1,4 @@
+
+module Myco
+  EmptyObject = Component.new
+end

data/lib/myco/bootstrap/file_toplevel.rb

@@ -0,0 +1,5 @@
+
+module Myco
+  # This empty, barebones component will be replaced after bootstrapping.
+  FileToplevel = Component.new
+end

data/lib/myco/bootstrap/find_constant.rb

@@ -0,0 +1,86 @@
+
+# TODO: Move monkey patch to different file
+module Rubinius
+  class ConstantScope
+    attr_reader :myco_file
+    attr_reader :myco_component
+    attr_reader :myco_category
+    attr_reader :myco_meme
+    
+    def myco_levels
+      @myco_levels ||= (parent ? parent.myco_levels.dup : [])
+    end
+    
+    def set_myco_file
+      raise "myco_file already set for thie ConstantScope" \
+        if @myco_file
+      @myco_component = self.module
+      @myco_file      = self.module
+      
+      @myco_file.instance_variable_set(:@constant_scope, self)
+      
+      myco_levels << @myco_file
+    end
+    
+    def set_myco_component
+      raise "myco_component already set for thie ConstantScope" \
+        if @myco_component
+      @myco_component = self.module
+      @myco_file      = parent.myco_file
+      
+      myco_levels << @myco_component
+    end
+    
+    def set_myco_category
+      raise "myco_category already set for thie ConstantScope" \
+        if @myco_category
+      @myco_category  = self.module
+      @myco_component = parent.myco_component
+      @myco_file      = parent.myco_file
+      
+      myco_levels << @myco_category
+    end
+    
+    def set_myco_meme value
+      raise "myco_meme already set for thie ConstantScope" \
+        if @myco_meme
+      @myco_meme      = value
+    end
+  end
+end
+
+module Myco
+  
+  def self.find_constant(name, scope)
+    name = ::Rubinius::Type.coerce_to_constant_name name
+    
+    category  = scope.myco_category
+    component = scope.myco_component
+    file      = scope.myco_file
+    
+    # TODO: optimize this constant search
+    # (it currently searches each ancestor of each nested component scope)
+    bucket = nil
+    scope.myco_levels.detect { |level|
+      bucket = find_constant_bucket_in_module(level, name)
+    }
+    bucket ? bucket.constant : ::Rubinius::Type.const_get(::Myco, name)
+  end
+  
+  def self.find_constant_bucket_in_module(mod, name, inherit=true)
+    current, constant = mod, nil
+    
+    while current and ::Rubinius::Type.object_kind_of? current, Module
+      if bucket = current.constant_table.lookup(name)
+        return bucket
+      end
+      
+      return nil unless inherit
+      
+      current = current.direct_superclass
+    end
+    
+    return nil
+  end
+
+end

data/lib/myco/bootstrap/instance.rb

@@ -0,0 +1,52 @@
+
+module Myco
+  class Instance < ::BasicObject
+    include ::Kernel
+    
+    # TODO: clean this up
+    prepend (::Module.new {
+      def method_missing name, *args
+        msg = "#{to_s} has no method called '#{name}'"
+        ::Kernel.raise ::NoMethodError.new(msg, name, args)
+      end
+    })
+    
+    def to_s
+      "#<#{@component.to_s}>"
+    end
+    
+    def inspect
+      to_s
+    end
+    
+    # TODO: remove (for now it makes debugging easier with RSpec)
+    def pretty_print str
+      p str
+    end
+    
+    def initialize component
+      @component = component
+    end
+    
+    attr_reader :component
+    
+    def parent
+      @component.parent && @component.parent.instance
+    end
+    
+    def parent_meme
+      @component.parent_meme
+    end
+    
+    def memes
+      @component.memes
+    end
+    
+    # Commandeer a few methods implemented in Kernel
+    %i{ extend respond_to? method_missing hash }.each do |sym|
+      define_method sym do |*args, &blk|
+        ::Kernel.instance_method(sym).bind(self).call(*args)
+      end
+    end
+  end
+end

data/lib/myco/bootstrap/meme.rb

@@ -0,0 +1,160 @@
+
+module Myco
+  class Meme
+    attr_accessor :target
+    attr_accessor :name
+    attr_accessor :body
+    attr_accessor :cache
+    attr_accessor :expose
+    
+    attr_reader :caches # TODO: don't expose; dynamic meth should send privately
+    
+    def to_s
+      "#<#{self.class}:#{self.name.to_s}>"
+    end
+    
+    def inspect
+      to_s
+    end
+    
+    def initialize target, name, body=nil, &blk
+      self.target = target
+      self.name   = name
+      self.body   = body || blk
+      self.cache  = false
+      self.expose = true
+      
+      @caches = {}
+    end
+    
+    def body= value
+      case value
+      when Rubinius::Executable
+        @body = value
+        @body.scope.set_myco_meme self # Set meme for lexical scope
+      when Proc
+        block_env = value.block.dup
+        block_env.change_name name
+        @body = Rubinius::BlockEnvironment::AsMethod.new block_env
+        value = value.dup
+        value.lambda_style!
+      else
+        raise ArgumentError,
+          "Meme body must be a Rubinius::Executable or a Proc"
+      end
+      
+      @body
+    end
+    
+    def bind
+      return if not @expose
+      
+      meme = self
+      target.memes[@name] = meme
+      
+      ##
+      # This dynamic method is nearly the same as Meme#result_for
+      # (but written from the perspective of the receiver)
+      # implemented in bytecode to avoid forwarding to another method
+      # on the call stack.
+      # TODO: move this bytecode generation to a helper method 
+      target.dynamic_method @name, '(myco_internal)' do |g|
+        g.splat_index = 0 # *args
+        
+        invoke = g.new_label
+        ret    = g.new_label
+        
+        ##
+        # meme = <this meme>
+        #
+        g.push_literal meme
+        g.set_local 1 # meme
+        g.pop
+        
+        ##
+        # caches = <this meme's @caches>
+        #
+        g.push_literal @caches
+        g.set_local 2 # caches
+        g.pop
+        
+        ##
+        # cache_key = [obj.hash, args.hash, blk.hash]
+        #
+          g.push_self;     g.send :hash, 0
+          g.push_local 0;  g.send :hash, 0 # args
+          g.push_block;    g.send :hash, 0
+        g.make_array 3
+        g.set_local 3 # cache_key
+        g.pop
+        
+        ##
+        # if meme.cache.false? || !caches.has_key?(cache_key)
+        #   return caches[cache_key]
+        # end
+        #
+        g.push_local 1 # meme
+        g.send :cache, 0
+        g.send :false?, 0
+        g.goto_if_true invoke
+        
+        g.push_local 2 # caches
+          g.push_local 3 # cache_key
+        g.send :has_key?, 1
+        g.goto_if_false invoke
+        
+        g.push_local 2 # caches
+          g.push_local 3 # cache_key
+        g.send :[], 1
+        g.goto ret
+        
+        ##
+        # result = meme.body.invoke meme.name, @target, obj, args, blk
+        #
+        invoke.set!
+        
+        g.push_local 1 # meme
+        g.send :body, 0
+          g.push_local 1; g.send :name, 0   # meme.name
+          g.push_local 1; g.send :target, 0 # meme.target
+          g.push_self
+          g.push_local 0 # args
+          g.push_block
+        g.send :invoke, 5
+        g.set_local 4 # result
+        g.pop
+        
+        ##
+        # return (caches[cache_key] = result)
+        #
+        g.push_local 2 # caches
+          g.push_local 3 # cache_key
+          g.push_local 4 # result
+        g.send :[]=, 2
+        
+        ret.set!
+        g.ret
+      end
+    end
+    
+    def result *args, &blk
+      result_for target.instance, *args, &blk
+    end
+    
+    def result_for obj, *args, &blk
+      cache_key = [obj.hash, args.hash, blk.hash]
+      if @cache && @caches.has_key?(cache_key)
+        return @caches[cache_key]
+      end
+      
+      result = @body.invoke @name, @target, obj, args, blk
+      
+      @caches[cache_key] = result
+    end
+    
+    def set_result_for obj, result, *args, &blk
+      cache_key = [obj.hash, args.hash, blk.hash]
+      @caches[cache_key] = result
+    end
+  end
+end

data/lib/myco/bootstrap/void.rb

@@ -0,0 +1,40 @@
+
+module Myco
+  class VoidClass < ::BasicObject
+    def self.new
+      @singleton ||= super
+    end
+    
+    def inspect
+      "void"
+    end
+    
+    def to_s
+      ""
+    end
+    
+    def false?
+      true
+    end
+    
+    def void?
+      true
+    end
+    
+    def method_missing *args
+      self
+    end
+    
+    def hash
+      nil.hash
+    end
+  end
+  
+  Void = VoidClass.new
+end
+
+# Patch the base classes to make them respond_to :false?
+class ::NilClass;    def false?; true  end; def void?; false end end
+class ::TrueClass;   def false?; false end; def void?; false end end
+class ::FalseClass;  def false?; true  end; def void?; false end end
+class ::BasicObject; def false?; false end; def void?; false end end

data/lib/myco/bootstrap.my

@@ -0,0 +1,15 @@
+
+RubyEval < EmptyObject {
+  from_string: |string| ::Kernel.instance_method(:eval).bind(self).call(string)
+}
+
+RubyEval @@@
+  Myco.eval_file("core/Category.my",     [Myco::CoreLoadPath])
+  Myco.eval_file("core/BasicObject.my",  [Myco::CoreLoadPath])
+  Myco.eval_file("core/Decorator.my",    [Myco::CoreLoadPath])
+  Myco.eval_file("core/Object.my",       [Myco::CoreLoadPath])
+  Myco.eval_file("core/FileToplevel.my", [Myco::CoreLoadPath])
+  
+  # Below are not necessary for bootstrapping; TODO: move out of RubyEval
+  Myco.eval_file("core/Switch.my",       [Myco::CoreLoadPath])
+@@@

data/lib/myco/bootstrap.rb

@@ -0,0 +1,10 @@
+
+require_relative 'bootstrap/find_constant'
+
+require_relative 'bootstrap/void'
+require_relative 'bootstrap/meme'
+require_relative 'bootstrap/instance'
+require_relative 'bootstrap/component'
+
+require_relative 'bootstrap/file_toplevel'
+require_relative 'bootstrap/empty_object'

data/lib/myco/command.my

@@ -0,0 +1,33 @@
+
+import "tools/OptionParser.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" }")
+    }
+  }
+  
+  run: |*argv| {
+    files = options.parse(argv)
+    files.uniq.each |file| { Myco.eval_file(file, [::Dir.pwd]) }
+  }
+  
+  on creation: run(*ARGV)
+}

data/lib/myco/core/BasicObject.my

@@ -0,0 +1,46 @@
+
+::Myco::BasicObject < ::Myco::EmptyObject {
+  # Basic conditional handling
+  if:     |cond, &blk| cond && blk.call
+  unless: |cond, &blk| cond || blk.call
+  switch: |input,comparator=:"=="|
+    Switch.new(input:input, comparator:comparator)
+  
+  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
+  }
+}

data/lib/myco/core/Category.my

@@ -0,0 +1,5 @@
+
+::Myco::Category < ::Myco::EmptyObject {
+  # Forward unknown methods to parent
+  method_missing: |sym, *a, &b| parent.send(sym, *a, &b)
+}