myco 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5c9a3ec14044d47105eb0c1448e65c08cebedfd9
-  data.tar.gz: b24c8a056f1df9e441dccc851b1eca9bd4293ad1
+  metadata.gz: e8031fe74a54c47a6c344eef7a2c5e13855bf2bc
+  data.tar.gz: c2f129e293c295731e643372d5add7704fdf9252
 SHA512:
-  metadata.gz: 59af162beb7b9ce35677eceba813cd1fbf35f73ce4630bac4e0afd87636f09a0e5973c1a3e7f600d99bcf07cffea296c915aa87d73f37360f0ac0f98d1c770b3
-  data.tar.gz: 37ad5495fa33dd8fa6afb55eff7fa27a221a138f61dcc30d053984c67ad340d3121af3b9b535f152c78f31bea4f6f7d8f7e445fb0887aeee86d7f64259d6ef9d
+  metadata.gz: 4fb206f4849977fcfe676b435b76de6d0145cc96507456fde0071f63b291f5743deeac07729f3d30717a58ac94acf55465266d32599395e76fc4e17249f18a7f
+  data.tar.gz: 2735f64a252ba18ab5b43ddb62e0f3b96772902146dcc645a9dfb1754d99eb0609a8449d06469e45600b82908702b3c9219f3032f54cebaf7df8acfbba0d03ac

data/lib/myco/bootstrap/add_method.rb

@@ -0,0 +1,38 @@
+
+module Myco
+  # In Myco, try to always use Myco.add_method instead of Rubinius.add_method
+  # to bypass all of the Ruby-specific logic therein.
+  
+  def self.add_method mod, name, executable
+    mod.method_table.store(name, executable, :public)
+    Rubinius::VM.reset_method_cache(mod, name)
+  end
+  
+  # TODO: override Module#define_method in Component to use this?
+  # TODO: override Module#thunk_method in Component to use this?
+  # TODO: override Module#dynamic_method in Component to use this?
+  
+  # Use instead of Module#thunk_method
+  def self.add_thunk_method mod, name, value
+    add_method(mod, name, Rubinius::Thunk.new(value))
+  end
+  
+  # Use instead of Module#dynamic_method
+  def self.add_dynamic_method mod, name, file="(dynamic)", line=1
+    g = Rubinius::ToolSets::Runtime::Generator.new
+    g.name = name.to_sym
+    g.file = file.to_sym
+    g.set_line Integer(line)
+
+    yield g
+
+    g.close
+    g.use_detected
+    g.encode
+
+    code = g.package Rubinius::CompiledCode
+    code.scope = Rubinius::ConstantScope.new(mod, Rubinius::ConstantScope.new(Myco))
+
+    add_method(mod, name, code)
+  end
+end

data/lib/myco/bootstrap/component.rb

@@ -8,7 +8,7 @@ module Myco
     
     attr_reader :parent
     attr_reader :parent_meme
-    attr_reader :categories
+    attr_reader :main
     
     attr_reader :constant_scope
     
@@ -53,12 +53,15 @@ module Myco
       this.instance_eval {
         @super_components = super_components
         @parent      = parent
+        @main        = self
         @filename    = filename
         @line        = line
         @basename    = File.basename @filename
         @dirname     = File.dirname  @filename
-        @categories  = { main: this }
         @parent_meme = parent_meme
+        @categories  = Rubinius::LookupTable.new
+        
+        Myco.add_thunk_method(self, :__component__, self)
       }
       
       all_categories = Hash.new { |h,k| h[k] = Array.new }
@@ -67,33 +70,44 @@ module Myco
         this.include other
         
         if other.is_a? Component
-          other.categories.each do |name, cat|
-            all_categories[name] << cat
+          other.each_category do |name, cat|
+            all_categories[name] << cat unless name == :main
           end
         end
       end
       
       all_categories.each do |name, supers|
-        if name == :main
-          this.categories[name] = this
-        else
-          this.categories[name] = this.__new_category__ name, supers, filename, line
-        end
+        this.__new_category__(name, supers, filename, line)
       end
       
       this
     end
     
-    # Get a reference to the main Component from main or from any inner Category
-    def main
-      self < Category ? parent : self
+    def __get_category__ name
+      if name == :main
+        self
+      elsif @categories.key?(name)
+        @categories[name]
+      else
+        # If the category doesn't exist, look for one in the super components.
+        # This allows for categories to be implicitly inherited after the fact.
+        super_cats = []
+        @super_components.each { |sup|
+          sup.respond_to?(:__get_category__) && (
+            cat = sup.__get_category__(name)
+            cat && super_cats.push(cat)
+          )
+        }
+        super_cats.any? && __new_category__(name, super_cats, @filename, @line)
+      end
     end
     
-    def __category__ name
-      @categories[name] ||= __new_category__(name)
+    def __set_category__ name, cat
+      @categories[name] = cat
+      cat
     end
     
-    def __new_category__ name, super_cats=[Category], filename=nil, line=nil
+    def __new_category__ name, super_cats=[::Myco::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
@@ -102,12 +116,23 @@ module Myco
       end
       
       category = Component.new super_cats, self, filename, line
+      category.instance_variable_set(:@main, self)
       category.__name__ = name
       category_instance = category.instance
       meme = declare_meme(name) { category_instance }
       meme.cache = true
       
-      category
+      __set_category__(name, category)
+    end
+    
+    def __category__ name
+      __get_category__(name) || __new_category__(name)
+    end
+    
+    alias_method :category, :__category__
+    
+    def each_category &block
+      @categories.each &block
     end
     
     def instance
@@ -115,9 +140,8 @@ module Myco
         yield @instance if block_given?
       else
         @instance = allocate
-        @instance.instance_variable_set(:@component, self)
         yield @instance if block_given?
-        @instance.__signal__ :creation if @instance.respond_to? :__signal__
+        @instance.__signal__ :creation if Rubinius::Type.object_respond_to?(@instance, :__signal__)
       end
       
       @instance
@@ -149,7 +173,6 @@ module Myco
     # TODO: re-evaluate usefulness and possibly remove in favor of using extend.
     def inject_into object
       object.extend InstanceMethods unless object.is_a? InstanceMethods
-      object.instance_variable_set(:@component, self)
       extend_object object
       object
     end
@@ -158,8 +181,7 @@ module Myco
     # call setters on the instance with the values given by kwargs.
     def new **kwargs
       instance = allocate
-      instance.instance_variable_set(:@component, self)
-      kwargs.each { |key,val| instance.send :"#{key}=", val }
+      kwargs.each { |key,val| instance.__send__ :"#{key}=", val }
       instance
     end
   end

data/lib/myco/bootstrap/find_constant.rb

@@ -6,6 +6,16 @@ module Rubinius
     attr_reader :myco_component
     attr_reader :myco_category
     attr_reader :myco_meme
+    attr_reader :is_myco_level
+    
+    def inspect_list
+      this_item = "0x#{object_id.to_s(16)} #{self.module}"
+      parent ? "#{this_item}, #{parent.inspect_list}" : this_item
+    end
+    
+    def inspect
+      "#<#{self.class}:#{inspect_list}>"
+    end
     
     # TODO: Can this be more graceful and more eager?
     def myco_file
@@ -16,6 +26,13 @@ module Rubinius
       @myco_levels ||= (parent ? parent.myco_levels.dup : [])
     end
     
+    def myco_parent
+      parent = parent()
+      parent ? (
+        parent.is_myco_level ? parent : parent.myco_parent
+      ) : nil
+    end
+    
     def set_myco_file
       raise "myco_file already set for thie ConstantScope" \
         if @myco_file
@@ -25,6 +42,7 @@ module Rubinius
       @myco_file.instance_variable_set(:@constant_scope, self)
       
       myco_levels << @myco_file
+      @is_myco_level = true
     end
     
     def set_myco_component
@@ -34,6 +52,7 @@ module Rubinius
       @myco_file      = parent.myco_file
       
       myco_levels << @myco_component
+      @is_myco_level = true
     end
     
     def set_myco_category
@@ -44,6 +63,7 @@ module Rubinius
       @myco_file      = parent.myco_file
       
       myco_levels << @myco_category
+      @is_myco_level = true
     end
     
     def set_myco_meme value
@@ -51,10 +71,61 @@ module Rubinius
         if @myco_meme
       @myco_meme      = value
     end
+    
+    def get_myco_constant_ref(name)
+      @myco_constant_refs ||= Rubinius::LookupTable.new
+      @myco_constant_refs[name] ||= ::Myco::ConstantReference.new(name, self)
+    end
   end
 end
 
 module Myco
+  class ConstantReference
+    class << self
+      attr_accessor :verbose
+    end
+    
+    attr_reader :name
+    attr_reader :scope
+    
+    def initialize name, scope
+      @name  = name
+      @scope = scope
+    end
+    
+    def value
+      serial = @serial
+      new_serial = Rubinius.global_serial
+      
+      if serial && serial >= new_serial
+        @value
+      else
+        @serial = new_serial
+        @value = find_value
+      end
+    end
+    
+    def find_value
+      bucket = find_constant_bucket_in_module(scope.module, name)
+      bucket ? bucket.constant : (
+        parent = scope.myco_parent
+        parent ? parent.get_myco_constant_ref(name).value : (
+          Rubinius::Type.const_get(::Myco, name)
+        )
+      )
+    end
+    
+    def find_constant_bucket_in_module mod, name
+      current = mod
+      while current and Rubinius::Type.object_kind_of? current, Module
+        # p current if Myco::ConstantReference.verbose
+        return bucket if bucket = current.constant_table.lookup(name)
+        current = current.direct_superclass
+      end
+      
+      return nil
+    end
+  end
   
   # Get the "current" ConstantScope (from the caller's perspective)
   def self.cscope
@@ -62,29 +133,6 @@ module Myco
   end
   
   def self.find_constant(name, scope=Rubinius::ConstantScope.of_sender)
-    # 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 = mod
-    
-    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
+    scope.get_myco_constant_ref(name).value
   end
-
-end
+end

data/lib/myco/bootstrap/instance.rb

@@ -1,50 +1,121 @@
 
 module Myco
-  module InstanceMethods
-    include ::Kernel
+  module PrimitiveInstanceMethods
+    # These methods are taken from Ruby's Kernel.
+    # TODO: Audit which of these should remain.
     
-    def to_s
-      "#<#{@component.to_s}>"
+    def __set_ivar__ sym, value
+      Rubinius.primitive :object_set_ivar
+      ::Kernel.raise ::PrimitiveFailure, "Rubinius.primitive :object_set_ivar failed"
     end
     
-    def inspect
-      vars = (instance_variables - [:@component]).map { |var|
-        [var.to_s[1..-1], instance_variable_get(var).inspect].join(": ")
-      }
-      vars = vars.any? ? (" " + vars.join(", ")) : ""
-      "#<#{@component.to_s}#{vars}>"
+    def __get_ivar__ sym
+      Rubinius.primitive :object_get_ivar
+      ::Kernel.raise ::PrimitiveFailure, "Rubinius.primitive :object_get_ivar failed"
+    end
+    
+    def __ivar_defined__ sym
+      Rubinius.primitive :object_ivar_defined
+      ::Kernel.raise ::PrimitiveFailure, "Rubinius.primitive :object_ivar_defined failed"
+    end
+    
+    def __kind_of__ mod
+      Rubinius.primitive :object_kind_of
+      ::Kernel.raise ::PrimitiveFailure, "Rubinius.primitive :object_kind_of failed"
+    end
+    
+    def __class__
+      Rubinius.primitive :object_class
+      ::Kernel.raise ::PrimitiveFailure, "Rubinius.primitive :object_class failed"
+    end
+    
+    def __dup__ # TODO: remove
+      copy = Rubinius::Type.object_class(self).allocate
+      Rubinius.invoke_primitive :object_copy_object, copy, self
+      copy
+    end
+
+    def __hash__
+      Rubinius.primitive :object_hash
+      ::Kernel.raise ::PrimitiveFailure, "Rubinius.primitive :object_hash failed"
+    end
+    
+    # These methods are taken from Ruby's BasicObject.
+    # TODO: Audit which of these should remain.
+    
+    def __send__ message, *args
+      Rubinius.primitive :object_send
+      ::Kernel.raise ::PrimitiveFailure, "Rubinius.primitive :object_send failed"
+    end
+
+    def __id__
+      Rubinius.primitive :object_id
+      ::Kernel.raise ::PrimitiveFailure, "Rubinius.primitive :object_id failed"
     end
     
-    # TODO: remove (for now it makes debugging easier with RSpec)
-    def pretty_print str
-      p str
+    def __ivar_names__
+      Rubinius.primitive :object_ivar_names
+      ::Kernel.raise ::PrimitiveFailure, "Rubinius.primitive :object_ivar_names failed"
     end
     
-    attr_reader :component
+    def __equal__(other)
+      Rubinius.primitive :object_equal
+      ::Kernel.raise ::PrimitiveFailure, "Rubinius.primitive :object_equal failed"
+    end
+  end
+  
+  module InstanceMethods
+    include PrimitiveInstanceMethods
+    
+    def component
+      __component__
+    end
     
     def parent
-      @component.parent && @component.parent.instance
+      __component__.parent && __component__.parent.instance
     end
     
     def parent_meme
-      @component.parent_meme
+      __component__.parent_meme
     end
     
     def memes
-      @component.memes
+      __component__.memes
     end
   end
   
-  class Instance < ::BasicObject
+  Instance = Class.new nil do
     include InstanceMethods
     
-    # # TODO: clean this up
-    # prepend (::Module.new {
-      def method_missing name, *args
-        msg = "#{to_s} has no method called '#{name}'"
-        ::Ruby::Kernel.raise ::NoMethodError.new(msg, name, args)
-      end
-    # })
+    # These are not included in InstanceMethods because they should not shadow
+    # existing method definitions when extended into an existing object. 
+    
+    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
+      vars = __ivar_names__.map { |var|
+        [var.to_s[1..-1], __get_ivar__(var).inspect].join(": ")
+      }
+      vars = vars.any? ? (" " + vars.join(", ")) : ""
+      "#<#{__component__.to_s}#{vars}>"
+    end
+    
+    alias_method :hash,   :__hash__   # TODO: remove?
+    alias_method :equal?, :__equal__  # TODO: remove?
+    alias_method :==,     :__equal__  # TODO: remove?
     
+    def != other
+      self == other ? false : true
+    end
+    
+    alias_method :"!", :false?
   end
+  
 end

data/lib/myco/bootstrap/meme.rb

@@ -2,7 +2,7 @@
 module Myco
   module MemeBindable
     def memes
-      @memes ||= {}
+      @memes ||= Rubinius::LookupTable.new
     end
     
     def declare_meme name, decorations=[], body=nil, cscope=nil, &blk
@@ -15,11 +15,11 @@ module Myco
       meme.body = body || blk
       
       decorations = decorations.map do |decoration, arguments|
-        decorators = main.categories[:decorators]
+        decorators = main.category(:decorators)
         decorators = decorators && decorators.instance
         
-        unless decorators.respond_to?(decoration)
-          reason = if decorators.nil?
+        unless Rubinius::Type.object_respond_to?(decorators, decoration)
+          reason = if !decorators
             "#{self} has no [decorators] category."
           else
             "Known decorators in #{decorators}: " \
@@ -29,7 +29,7 @@ module Myco
             "Unknown decorator for #{self}##{name}: '#{decoration}'. #{reason}" 
         end
         
-        [decorators.send(decoration), arguments]
+        [decorators.__send__(decoration), arguments]
       end
       decorations.each { |deco, args| deco.transforms.apply meme, *args }
       decorations.each { |deco, args| deco.apply meme, *args }
@@ -76,6 +76,10 @@ module Myco
     
     def body= value
       case value
+      when Rubinius::BlockEnvironment::AsMethod
+        @body = value
+      when Rubinius::Thunk
+        @body = value
       when Rubinius::Executable
         @body = value
         @body.scope.set_myco_meme self
@@ -131,6 +135,9 @@ module Myco
       
       @target.memes[@name] = self
       
+      # TODO: consider removing
+      @target.include(::Myco::PrimitiveInstanceMethods) unless @target < ::Myco::PrimitiveInstanceMethods
+      
       if @var
         bind_var_getter
         bind_var_setter
@@ -145,7 +152,7 @@ module Myco
         bind_cache_method
         @effective_body = @target.instance_method(@name).executable
       else
-        Rubinius.add_method @name, @body, @target, :public
+        Myco.add_method(@target, @name, @body)
       end
     end
     
@@ -173,8 +180,7 @@ module Myco
       # on the call stack.
       # TODO: move this bytecode generation to a helper method 
       meme = self
-      
-      target.dynamic_method @name, '(myco_internal)' do |g|
+      Myco.add_dynamic_method target, @name, '(myco_internal)' do |g|
         g.splat_index = 0 # *args
         
         invoke = g.new_label
@@ -252,7 +258,7 @@ module Myco
       # TODO: move this bytecode generation to a helper method 
       meme = self
       
-      target.dynamic_method @name, '(myco_internal)' do |g|
+      Myco.add_dynamic_method target, @name, '(myco_internal)' do |g|
         get = g.new_label
         ret = g.new_label
         
@@ -264,14 +270,14 @@ module Myco
         g.pop
         
         ##
-        # if instance_variable_defined?(#{name})
+        # if __ivar_defined__(#{name})
         #   @#{name} = meme.body.invoke meme.name, @target, obj, [], nil
         # end
         # return @#{name}
         #
         g.push_self
         g.push_literal(:"@#{@name}")
-        g.send(:instance_variable_defined?, 1)
+        g.send(:__ivar_defined__, 1)
         g.goto_if_true(get)
         
         g.push_local 1 # meme
@@ -309,7 +315,7 @@ module Myco
       meme = self
       
       # TODO: move this bytecode generation to a helper method 
-      target.dynamic_method :"#{@name}=", '(myco_internal)' do |g|
+      Myco.add_dynamic_method target, :"#{@name}=", '(myco_internal)' do |g|
         g.total_args = 1
         g.local_count = 1
         

data/lib/myco/bootstrap/tuple.rb

@@ -0,0 +1,13 @@
+
+class ::Array
+  # Create a method named :__tuple__ that uses the access_Array_tuple primitive.
+  attr_reader_specific :tuple, :__tuple__
+end
+
+module Myco
+  class << self
+    def tuple(*ary)
+      ary.__tuple__
+    end
+  end
+end

data/lib/myco/bootstrap/undefined.rb

@@ -0,0 +1,9 @@
+
+module Myco
+  class << self
+    dynamic_method(:undefined) { |g|
+      g.push_undef
+      g.ret
+    }
+  end
+end

data/lib/myco/bootstrap/void.rb

@@ -34,7 +34,8 @@ module Myco
 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
+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
+module ::Myco::InstanceMethods; def false?; false end; def void?; false end end

data/lib/myco/bootstrap.my

@@ -1,16 +1,27 @@
 
-::Myco::RubyEval < EmptyObject {
-  from_string: |string| ::Ruby::Kernel.instance_method(:eval).bind(self).call(string)
+::Myco::RubyEval < ::Myco::EmptyObject {
+  from_string: |string| ::Ruby.__send__(:eval, string)
 }
 
-RubyEval @@@
-  Myco.eval_file("core/Category.my",        [Myco::CoreLoadPath])
-  Myco.eval_file("core/BasicDecorators.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])
-@@@
+::Myco::Category < ::Myco::EmptyObject { }
+::Myco::BasicDecorators < ::Myco::EmptyObject { }
+::Myco::BasicObject < ::Myco::EmptyObject, ::Myco::BasicDecorators { }
+::Myco::Decorator < ::Myco::BasicObject { }
+::Myco::FileToplevel < ::Myco::BasicObject { }
+
+[decorators]
+
+load: LoadDecorator # TODO: avoid this hack
+LoadDecorator: ::Myco::Decorator {
+  apply: |meme| ::Myco.eval_file(meme.name.to_s, [::Myco::CoreLoadPath])
+  [transforms]
+  apply: { }
+}
+
+[main]
+
+load "core/Category.my"
+load "core/Decorator.my"
+load "core/BasicDecorators.my"
+load "core/BasicObject.my"
+load "core/FileToplevel.my"