bunraku 3.0.0

data/lib/bunraku/class_ext.rb

@@ -0,0 +1,37 @@
+class Module
+  def context(name, &block)
+    if const_defined?(name)
+      context_class = const_get(name)
+    else
+      context_class = Class.new
+      const_set(name, context_class)
+      context_class.module_eval do
+        include Bunraku::Context
+      end
+      def context_class.role(name, &block)
+        if const_defined?(name)
+          role_class = const_get(name)
+        else
+          role_class = Class.new
+          const_set(name, role_class)
+          role_class.module_eval do
+            include Bunraku::Role
+            extend Bunraku::RoleExtensions
+          end
+        end
+        role_class.module_eval(&block)
+      end
+    end
+    context_class.module_eval(&block)
+  end
+end
+
+class Class
+  def as_context
+    include Bunraku::Context
+  end
+  def as_role
+    include Bunraku::Role
+    extend Bunraku::RoleExtensions
+  end
+end

data/lib/bunraku/core.rb

@@ -0,0 +1,257 @@
+
+=begin
+Interfaces for external objects 
+=end
+module Bunraku
+  module Context
+    def bind(&spec_block)
+      BindExecuter.new(self, spec_block)
+    end
+    def unbind
+      context = self
+      self.class.constants.each do |const_name|
+        role_list = Utils.get_role_list(context, const_name)
+        next unless role_list
+        role_list.delete_if do |role_holder|
+          role_holder.unbind
+          true
+        end
+      end
+      nil
+    end
+    private
+    def method_missing(name, *args)
+      role_class = Utils.get_role_class(self, name)
+      return super(name, *args) unless role_class
+      role_list_name = Utils.role_list_name(name)
+      unless instance_variables.include? role_list_name
+        instance_variable_set(role_list_name, [])
+      end
+      role_list = instance_variable_get(role_list_name)
+      return RoleBinder.new(self, role_list, role_class)
+    end
+  end
+  
+  module Role
+    protected
+    def context
+      ContextProxy.new(@role_holder.context)
+    end
+    def core
+      @role_holder.core
+    end
+    private
+    def set_role_holder(role_holder)
+      @role_holder = role_holder
+    end
+    def method_missing(name, *args)
+      m = @role_holder.get_super_method(name.to_sym)
+      return m.call(*args) if m
+      super(name, *args)
+    end
+  end
+  
+  class RoleBinder
+    def initialize(context, role_list, role_class)
+      @context = context
+      @role_list = role_list
+      @role_class = role_class
+    end
+    def bind(obj, &block)
+      role_holder = @role_list.detect do |role_holder|
+        role_holder.target == obj
+      end
+      unless role_holder
+        role = @role_class.new
+        role_holder = RoleHolder.new(@context, role, obj)
+        role_holder.bind
+        @role_list << role_holder
+      end
+      block.call(role_holder) if block
+      @role_class.requires_test(role_holder)
+      nil
+    end
+    def unbind(obj)
+      @role_list.delete_if do |role_holder|
+        if role_holder.target == obj
+          role_holder.unbind
+          true
+        else
+          false
+        end
+      end
+    end
+  end
+  
+  class RoleHolder
+    CORE_GETTER = :__bunraku_core_get
+    def initialize(context, role, target)
+      @context = context
+      @role = role
+      @target = target
+      @target_mod = Module.new
+      @target.extend(@target_mod)
+      @methods = {}
+      @core_getter = nil
+    end
+    attr :context
+    attr :role
+    attr :target
+    
+    def replace_to(role_method_name, target_method_name)
+      @methods[role_method_name.to_sym] = @target.method(target_method_name)
+    end
+    
+    def def_method(name, &body)
+      tmpname = "__temp__" + name.to_s
+      @target_mod.instance_eval do
+        public
+        define_method(tmpname, &body)
+      end
+      @methods[name] = @target.method(tmpname)
+      @target_mod.instance_eval do
+        undef_method(tmpname)
+      end
+    end
+    
+    def get_method(name)
+      name = name.to_sym
+      return @role.method(name) if @role.methods.include?(name.to_s)
+      return @methods[name] if @methods[name]
+      return @target.method(name) if @target.methods.include?(name.to_s)
+      nil
+    end
+    
+    def get_super_method(name)
+      name = name.to_sym
+      return @methods[name] if @methods[name]
+      return @target.method(name) if @target.methods.include?(name.to_s)
+      #return @role.method(name) if @role.methods.include?(name.to_s)
+      nil
+    end
+    
+    def core
+      return CoreProxy.new(self) if @core_getter == nil
+      core_holder = @core_getter.call()
+      if core_holder != nil
+        return HolderProxy.new(core_holder)
+      else
+        return CoreProxy.new(self)
+      end
+    end
+    
+    def get_core
+      proc do
+        return self if @target != nil
+        return nil if @core_getter == nil
+        return @core_getter.call()
+      end
+    end
+    
+    def bind
+      role_holder = self
+      @role.instance_eval do 
+        set_role_holder(role_holder)
+      end
+      begin
+        @core_getter = @target.instance_eval do
+          send(CORE_GETTER)
+        end
+      rescue
+      end
+      @target_mod.instance_eval do
+        private
+        define_method(CORE_GETTER) do
+          role_holder.get_core
+        end
+        define_method(:method_missing) do |name, *args|
+          m = role_holder.get_method(name.to_sym)
+          return m.call(*args) if m
+          super(name, *args)
+        end
+      end
+      # override processing
+      @role.class.each_overrides do |method|
+        @methods[method] = @target.method(method)
+        @target_mod.instance_eval do
+          define_method(method) do |*args|
+            m = role_holder.get_method(method)
+            return m.call(*args) if m
+            super(*args)
+          end
+        end
+      end
+      
+      @role.init_role if @role.methods.include?("init_role")
+    end
+    
+    def unbind
+      @target_mod.instance_eval do
+        private
+        define_method(CORE_GETTER) do
+          super()
+        end
+        define_method(:method_missing) do |name, *args|
+          super(name, *args)
+        end
+      end
+      @target = nil
+      @methods = {}
+    end
+  end
+
+  module RoleExtensions
+    def requires(&block)
+      @requires = [] unless instance_variables.include? "@requires"
+      @requires << block
+    end
+    
+    def override(method)
+      @overrides = [] unless instance_variables.include? "@overrides"
+      @overrides << method.to_sym
+    end
+    
+    def requires_test(holder)
+      return true unless instance_variables.include? "@requires"
+      req = RoleRequires.new(holder)
+      @requires.each do |block|
+        block.call(req)
+      end
+      raise BindRoleError.new(req.errors) unless req.errors.empty?
+    end
+    
+    def each_overrides(&block)
+      @overrides.each(&block) if instance_variables.include? "@overrides"
+    end
+  end
+
+  class RoleRequires
+    def initialize(holder)
+      @holder = holder
+      @errors = []
+    end
+    attr :errors
+    
+    def method?(name)
+      unless @holder.get_method(name.to_sym)
+        @errors << "require method: #{name.to_s}" 
+      end
+      nil
+    end
+  end
+  
+  class BindExecuter
+    def initialize(context, spec)
+      @context = context
+      @spec = spec
+    end
+    def call(&block)
+      context = @context
+      @spec.call(context)
+      result = block.call()
+      context.unbind
+      result
+    end
+  end
+end
+

data/lib/bunraku/exceptions.rb

@@ -0,0 +1,10 @@
+module Bunraku
+  class BindRoleError < Exception
+    def initialize(errors)
+      @errors = errors
+    end
+    def message
+      @errors.join("\n")
+    end
+  end
+end

data/lib/bunraku/proxies.rb

@@ -0,0 +1,121 @@
+
+=begin
+Proxies are objects for using only inside role methods.
+=end
+module Bunraku
+  class ContextProxy
+    def initialize(context)
+      @context = context
+    end
+
+    def method_missing(name, *args)
+      if @context.class.constants.include?(name.to_s)
+        role = @context.class.const_get(name)
+        return RoleProxy.new(@context, name, role)
+      end
+      sname = name.to_s.singularize.to_sym
+      if @context.class.constants.include?(sname.to_s)
+        role = @context.class.const_get(sname)
+        default = if args.size == 1 then args[0] else nil end
+        return RolesProxy.new(@context, sname, role, default) if role
+      end
+      if @context.methods.include?(name.to_s)
+        return @context.send(name, *args) 
+      end
+      super(name, *args)
+    end
+
+    def eql?(o)
+      return false if o.class != self.class
+      @context == o.instance_variable_get(:@context)
+    end
+    def hash
+      @context.hash
+    end
+    def ==(o)
+      eql?(o)
+    end
+  end
+  
+  class CoreProxy
+    def initialize(role_holder)
+      @role_holder = role_holder
+    end
+    private 
+    def method_missing(name, *args)
+      m = @role_holder.get_super_method(name)
+      return m.call(*args) if m
+      super(name, *args)
+    end
+  end
+  
+  class HolderProxy
+    def initialize(role_holder)
+      @role_holder = role_holder
+    end
+    private 
+    def method_missing(name, *args)
+      m = @role_holder.get_method(name)
+      return m.call(*args) if m
+      super(name, *args)
+    end
+  end
+  
+  class RoleProxyBase
+    def initialize(context, role_name, role_class)
+      @context = context
+      @role_name = role_name
+      @role_class = role_class
+      @role_list = Utils.get_role_list(@context, @role_name)
+    end
+    def eql?(o)
+      return false if o.class != self.class
+      context_equal = (@context == o.instance_variable_get(:@context))
+      role_equal = (@role_class == o.instance_variable_get(:@role_class))
+      context_equal and role_equal
+    end
+    def hash
+      (@context.hash | @role_class.hash)
+    end
+    def ==(o)
+      eql?(o)
+    end
+  end
+  
+  class RoleProxy < RoleProxyBase
+    private
+    def method_missing(name, *args)
+      HolderProxy.new(@role_list[0]).send(name, *args)
+    end
+  end
+  
+  class RolesProxy < RoleProxyBase
+    def initialize(context, role_name, role_class, default=nil)
+      super(context, role_name, role_class)
+      @default = default
+    end
+    
+    def each(&block)
+      results = []
+      @role_list.each do |role_holder|
+        begin
+          results << block.call(HolderProxy.new(role_holder))
+        rescue
+          results << @default
+        end
+      end      
+    end
+    private
+    def method_missing(name, *args)
+      results = []
+      @role_list.each do |role_holder|
+        begin
+          results << HolderProxy.new(role_holder).send(name, *args)
+        rescue
+          results << @default
+        end
+      end
+      return results
+    end
+  end
+end

data/lib/bunraku/utils.rb

@@ -0,0 +1,21 @@
+
+module Bunraku
+  module Utils
+    def self.get_role_class(context, role_name)
+      context.class.const_get(role_name)
+    end
+    def self.role_class?(context, role_name, role_class)
+      role_class.class == Class and
+        role_class.include? Role and
+        context.instance_variables.include?(role_list_name(role_name))
+    end
+    def self.get_role_list(context, role_name)
+      role_class = get_role_class(context, role_name)
+      return nil unless role_class?(context, role_name, role_class)
+      context.instance_variable_get(role_list_name(role_name))
+    end
+    def self.role_list_name(role_name)
+      "@" + role_name.to_s
+    end
+  end
+end