myco 0.1.0.dev → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
---- 
-SHA1: 
-  metadata.gz: 3da0c78adac1604211cf6cd16c6eacd6e714591c
-  data.tar.gz: b6444fe6690546c9ed22b96fedc9a3bb1083030e
-SHA512: 
-  metadata.gz: e9b05edc6272eee428e038f4fae2b91d73aa83c0dd7e5941c50ec5d457a88d0920fc453826161606d8374d5fae0d9fc8bc3cea6d28bb394d1586ec87cb107195
-  data.tar.gz: 8b6193c91a85706f18cb09a529e575b571b4895a4e18f9f767b4e43ff525d84f871fd5d422219b28f372bbbcb8972afe275bcc086a4b6b3a895d1501b9896a11
+---
+SHA1:
+  metadata.gz: 417744da4484853e229b10a6f5de25b140e67af1
+  data.tar.gz: 9e4e018656fef08864d79948f9ff58731fa33c65
+SHA512:
+  metadata.gz: c81eb1fd9f81a6c1c5d02d29929c9922b749e9a6833c6190b88eb996f56ad9d1ed4cb60e3edd276b8bcf6fd0f151634129f4e4754b3f591594b0e600abae0be4
+  data.tar.gz: b2db5fe48fd80b3c49aa472ed3dc89d32b3b15ff800f943760a7f36480aa2aef2851832a88cccc1eed40064a48c690471b44e0d9aa12edf27a5dd0df29d4be5e

data/LICENSE

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

data/README.md

@@ -0,0 +1,79 @@
+
+```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)
+  
+  development dependency 'bundler':  1.6
+  development dependency 'rake':    10.3
+  development dependency 'rspec':    3.0
+  development dependency 'fivemat':  1.3
+  
+  [features]
+  
+  "innovative declarative syntax layer around a familiar Ruby-like layer"
+  "ease of expression of intent" : "consistent but powerful rules"
+  todo "runtime parsing rule intercession"
+  todo "nested blocks parsed by user parsers"
+  
+  "patterns for a responsibly localized import system": ImportSystemMethods {
+    import 'some/library'
+    import as(:SomeLibrary) 'some/library'
+    private import 'some/library'
+    export as(:MyGlobalLibrary) 'my/library'
+    arbitrary user_defined import_mechanism 'special/library'
+  }
+  
+  "fluid integration with the host Ruby runtime": {
+    ruby_require('some_ruby_gem')
+    obj = SomeRubyGem::Object.new(1, 2, *rest, foo:8, bar:9)
+    
+    RubyEval """
+      Myco::SomeObject.new(foo:8, bar:9)
+    """
+  }
+  
+  rich support_for(:decorators) in: user_space
+  
+  [decorators]
+  
+  support_for: Decorator {
+    apply: |meme|
+      arguments.each |feature| { meme.supported_features.push(feature) }
+  }
+  
+  rich: Decorator {
+    [transforms]
+    richness: true
+    memoize: true
+  }
+  
+  [contributing]
+  
+  Github < RepositoryHost {
+    URL: "https://github.com/jemc/myco"
+    IssueTracker: URL + "/issues"
+  }
+  
+  contributing_process: |user, problem| {
+    issue = user.file_bug_report(problem, on: Github::IssueTracker)
+    
+    if(user.can_implement?) {
+      pr = PullRequest {
+        name: "Fix for issue #"issue.number" - "issue.description"."
+        branch: snake_case(issue.name)
+        user: user
+        
+        include fix: for(problem)
+        include tests: for(fix)
+        
+        user.file_pull_request(pr, on: Github::IssueTracker)
+      }
+    }
+  }
+}
+```

data/lib/myco/backtrace.rb

@@ -27,7 +27,7 @@ class Myco::Backtrace < Rubinius::Backtrace
       file_width = file.length + 1 + sbullet.length
       
       place = loc.instance_variable_get(:@method_module).to_s + '#'
-      place += loc.describe_method
+      place += loc.method.name.to_s
       place_width = place.length + 1 + ebullet.length
       
       padding = @width - file_width - place_width

data/lib/myco/bootstrap/component.rb

@@ -1,12 +1,13 @@
 
 module Myco
-  class Component < Module
+  module Component
+    include MemeBindable
+    
     attr_accessor :__last__
     attr_accessor :__name__
     
     attr_reader :parent
     attr_reader :parent_meme
-    attr_reader :memes
     attr_reader :categories
     
     attr_reader :constant_scope
@@ -45,29 +46,36 @@ module Myco
         line     ||= location.line
       end
       
-      this = super()
+      this = Class.new Instance
+      # TODO: avoid extending here to avoid touching/making the singleton_class
+      this.extend self
       
       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 }
+        @categories  = { main: 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 }
+        raise TypeError, "Got non-Component in supers for new Component: "\
+          "#{super_components.inspect}" \
+              unless other.is_a? Component
+        
+        this.include other
+        other.categories.each do |name, cat|
+          all_categories[name] << cat
+        end
       end
       
       all_categories.each do |name, supers|
-        if name.nil?
+        if name == :main
           this.categories[name] = this
         else
           this.categories[name] = this.__new_category__ name, supers, filename, line
@@ -77,6 +85,11 @@ module Myco
       this
     end
     
+    # Get a reference to the main Component from main or from any inner Category
+    def main
+      self < Category ? parent : self
+    end
+    
     def __category__ name
       @categories[name] ||= __new_category__(name)
     end
@@ -92,50 +105,76 @@ module Myco
       category = Component.new super_cats, self, filename, line
       category.__name__ = name
       category_instance = category.instance
-      declare_meme(name) { category_instance }
-      @memes[name].cache = true
+      meme = declare_meme(name) { category_instance }
+      meme.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
+      if @instance
         yield @instance if block_given?
-        @instance.__signal__ :creation if @instance.respond_to? :__signal__
       else
+        @instance = allocate
+        @instance.instance_variable_set(:@component, self)
         yield @instance if block_given?
+        @instance.__signal__ :creation if @instance.respond_to? :__signal__
       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 }
-      }
+    # Override Module#include to bypass type checks of others
+    def include *others
+      others.reverse_each do |other|
+        Rubinius::Type.include_modules_from(other, self.origin)
+        Rubinius::Type.infect(self, other)
+        other.__send__ :included, self
+      end
+      self
+    end
+    
+    # Extend the given object with this component's features
+    # Called on object.extend(component)
+    def extend_object object
+      singleton_class = Rubinius::Type.object_singleton_class(object)
+      Rubinius::Type.include_modules_from(self, singleton_class.origin)
+      Rubinius::Type.infect(singleton_class, self)
+      object
+    end
+    
+    # Create a child component of self to act as the component of the object,
+    # which is allowed to be a Ruby object (not a Myco::Instance).
+    # 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
+    
+    # Create an untracked instance of this component and
+    # 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 }
+      instance
+    end
+    
+    # Like module_eval, but it also shifts the ConstantScope of the block
+    def component_eval &block
+      block_env = block.block
+      cscope = Rubinius::ConstantScope.new(self, block_env.constant_scope)
+      if defined? ::Myco::FileToplevel && self < ::Myco::FileToplevel
+        cscope.set_myco_file
+      elsif defined? ::Myco::Category && self < ::Myco::Category
+        cscope.set_myco_category
+      else
+        cscope.set_myco_component
+      end
+      result = block_env.call_under(self, cscope, true, self)
+      result
     end
   end
   

data/lib/myco/bootstrap/find_constant.rb

@@ -7,6 +7,11 @@ module Rubinius
     attr_reader :myco_category
     attr_reader :myco_meme
     
+    # TODO: Can this be more graceful and more eager?
+    def myco_file
+      @myco_file ||= parent.myco_file
+    end
+    
     def myco_levels
       @myco_levels ||= (parent ? parent.myco_levels.dup : [])
     end
@@ -51,8 +56,14 @@ end
 
 module Myco
   
-  def self.find_constant(name, scope)
+  # Get the "current" ConstantScope (from the caller's perspective)
+  def self.cscope
+    Rubinius::ConstantScope.of_sender
+  end
+  
+  def self.find_constant(name, scope=nil)
     name = ::Rubinius::Type.coerce_to_constant_name name
+    scope ||= ::Rubinius::ConstantScope.of_sender
     
     category  = scope.myco_category
     component = scope.myco_component

data/lib/myco/bootstrap/instance.rb

@@ -1,6 +1,6 @@
 
 module Myco
-  class Instance < ::BasicObject
+  module InstanceMethods
     include ::Kernel
     
     # TODO: clean this up
@@ -24,10 +24,6 @@ module Myco
       p str
     end
     
-    def initialize component
-      @component = component
-    end
-    
     attr_reader :component
     
     def parent
@@ -41,12 +37,9 @@ module Myco
     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
+  
+  class Instance < ::BasicObject
+    include InstanceMethods
   end
 end

data/lib/myco/bootstrap/meme.rb

@@ -1,13 +1,54 @@
 
 module Myco
+  module MemeBindable
+    def memes
+      @memes ||= {}
+    end
+    
+    def declare_meme name, decorations=[], body=nil, cscope=nil, &blk
+      meme = Meme.new self, name
+      if cscope && blk
+        body = blk.block.dup
+        blk = nil
+        body.instance_variable_set(:@constant_scope, cscope)
+      end
+      meme.body = body || blk
+      
+      decorations = decorations.map do |decoration, arguments|
+        decorators = main.categories[:decorators]
+        decorators = decorators && decorators.instance
+        
+        unless decorators.respond_to?(decoration)
+          reason = if decorators.nil?
+            "#{self} has no [decorators] category."
+          else
+            "Known decorators in #{decorators}: " \
+            "#{decorators.component.memes.keys.inspect}."
+          end
+          raise KeyError,
+            "Unknown decorator for #{self}##{name}: '#{decoration}'. #{reason}" 
+        end
+        
+        [decorators.send(decoration), arguments]
+      end
+      decorations.each { |deco, args| deco.transforms.apply meme, *args }
+      decorations.each { |deco, args| deco.apply meme, *args }
+      
+      meme.bind
+      
+      meme
+    end
+  end
+  
   class Meme
     attr_accessor :target
     attr_accessor :name
     attr_accessor :body
     attr_accessor :cache
+    attr_accessor :var
     attr_accessor :expose
     
-    attr_reader :caches # TODO: don't expose; dynamic meth should send privately
+    attr_reader :metadata
     
     def to_s
       "#<#{self.class}:#{self.name.to_s}>"
@@ -20,10 +61,14 @@ module Myco
     def initialize target, name, body=nil, &blk
       self.target = target
       self.name   = name
-      self.body   = body || blk
+      self.body   = body if body
+      self.body   = blk  if blk
       self.cache  = false
+      self.var    = false
       self.expose = true
       
+      @metadata = {}
+      
       @caches = {}
     end
     
@@ -31,33 +76,96 @@ module Myco
       case value
       when Rubinius::Executable
         @body = value
-        @body.scope.set_myco_meme self # Set meme for lexical scope
+        @body.scope.set_myco_meme self
+      when Rubinius::BlockEnvironment
+        block_env = value
+        block_env.change_name name
+        block_env.constant_scope.set_myco_meme self
+        @body = Rubinius::BlockEnvironment::AsMethod.new block_env
       when Proc
         block_env = value.block.dup
         block_env.change_name name
+        block_env.constant_scope.set_myco_meme self \
+          unless block_env.constant_scope.myco_meme
         @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"
+          "Meme body must be a Rubinius::Executable, " \
+          "Rubinius::BlockEnvironment or a Proc; got: #{value.inspect}"
       end
       
+      @effective_body = @body
+      
+      bind if @bound
       @body
     end
     
+    def target= value
+      @target = value
+      @target.extend(MemeBindable) unless @target.is_a?(MemeBindable)
+      bind if @bound
+      @target
+    end
+    
+    def cache= value
+      @cache = value
+      bind if @bound
+      @cache
+    end
+    
+    def var= value
+      @var = value
+      bind if @bound
+      @var
+    end
+    
+    def to_proc
+      Proc.__from_block__(@body.block_env)
+    end
+    
     def bind
+      @bound = true
       return if not @expose
       
-      meme = self
-      target.memes[@name] = meme
+      @target.memes[@name] = self
       
+      if @var
+        bind_var_getter
+        bind_var_setter
+        @effective_body = @target.instance_method(@name).executable
+      elsif @cache
+        bind_cache_method
+        @effective_body = @target.instance_method(@name).executable
+      else
+        Rubinius.add_method @name, @body, @target, :public
+      end
+    end
+    
+    def result *args, &blk
+      result_for target.instance, *args, &blk
+    end
+    
+    def result_for obj, *args, &blk
+      result = @effective_body.invoke @name, @target, obj, args, blk
+    end
+    
+    def set_result_for obj, result, *args, &blk
+      raise "Can't set_result_for this Meme" unless @cache
+      cache_key = [obj.hash, args.hash, blk.hash]
+      @caches[cache_key] = result
+    end
+    
+  private
+    
+    def bind_cache_method
       ##
       # 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 
+      meme = self
+      
       target.dynamic_method @name, '(myco_internal)' do |g|
         g.splat_index = 0 # *args
         
@@ -89,15 +197,10 @@ module Myco
         g.pop
         
         ##
-        # if meme.cache.false? || !caches.has_key?(cache_key)
+        # if 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
@@ -137,24 +240,69 @@ module Myco
       end
     end
     
-    def result *args, &blk
-      result_for target.instance, *args, &blk
+    def bind_var_getter
+      # TODO: move this bytecode generation to a helper method 
+      meme = self
+      
+      target.dynamic_method @name, '(myco_internal)' do |g|
+        get = g.new_label
+        ret = g.new_label
+        
+        ##
+        # meme = <this meme>
+        #
+        g.push_literal meme
+        g.set_local 1 # meme
+        g.pop
+        
+        ##
+        # if @#{:"__#{@name}_defined__"}
+        #   @#{name} = meme.body.invoke meme.name, @target, obj, [], nil
+        # end
+        # return @#{name}
+        #
+        g.push_ivar(:"__#{@name}_defined__")
+        g.goto_if_true(get)
+        
+        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.make_array 0
+          g.push_nil
+        g.send :invoke, 5
+        g.set_ivar(@name)
+        
+        g.push_true
+        g.set_ivar(:"__#{@name}_defined__")
+        g.pop
+        g.goto(ret)
+        
+        get.set!
+        g.push_ivar(@name)
+        
+        ret.set!
+        g.ret
+      end
     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]
+    def bind_var_setter
+      # TODO: move this bytecode generation to a helper method 
+      target.dynamic_method :"#{@name}=", '(myco_internal)' do |g|
+        g.total_args = 1
+        g.local_count = 1
+        
+        g.push_true
+        g.set_ivar(:"__#{@name}_defined__")
+        g.pop
+        
+        g.push_local 0 # value
+        g.set_ivar @name
+        
+        g.ret
       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.my

@@ -1,15 +1,16 @@
 
-RubyEval < EmptyObject {
+::Myco::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])
+  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.eval_file("core/Switch.my",          [Myco::CoreLoadPath])
 @@@