seat-belt 0.10.0

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/seatbelt.rb

@@ -0,0 +1,37 @@
+require "seatbelt/dependencies"
+require "seatbelt/version"
+require "seatbelt/seatbelt"
+
+module Seatbelt
+
+  METHOD_EXCLUDE_DIRECTIVES = %w{ :: }
+
+  # Internal: Checks a directive if allowed. Raises a DirectiveNotAllowedError
+  # if directive is not allowed.
+  #
+  # directive - the directive String to check.
+  #
+  # Returns nothing
+  def self.check_directive(directive)
+    if directive.in?(METHOD_EXCLUDE_DIRECTIVES)
+      raise Seatbelt::Errors::DirectiveNotAllowedError
+    end
+  end
+
+
+  # Public: Configures the Gate. Needs a block.
+  #
+  # Example:
+  #
+  #   Seatbelt.configure_gate do |config|
+  #     config.method_directive_instance  = "|"
+  #     config.method_directive_class     = "~"
+  #   end
+  #
+  # Returns nothing.
+  def self.configure_gate
+    yield GateConfig if block_given?
+  end
+
+end
+

data/lib/seatbelt/collections/collection.rb

@@ -0,0 +1,56 @@
+module Seatbelt
+  module Collections
+
+    # Public: The datastructure used as primitive  in
+    # Seatbelt::Collections::Collection
+    #
+    class Array < ::Array; end
+
+    # Public: The base collection attribute type that is used in 'has_many'
+    # associations.
+    #
+    # Needs a corrosponding model.
+    # See Seatbelt::Dcoument::Associations for further details.
+    class Collection < Array#Virtus::Attribute::Collection
+
+      # Public: Initializes the collections primitive to allow later type
+      # checking.Adds a method 'acceptable_item_name' to the primitive, that
+      # is later called at the time of type checking to match the allowed class.
+      #
+      # klass - The associatzed klass that is insertable into the collection.
+      #
+      def self.initialize_primitive(klass)
+        class_eval <<-RUBY, __FILE__, __LINE__
+          def acceptable_item_name
+            return "#{klass.name}"
+          end
+        RUBY
+      end
+
+      # Public: Adds an object to the 'has_many' association.
+      #
+      # item - An instance of the model class used within the collection
+      #        or an Hash with attribute key/value pairs.
+      #
+      # Example
+      #   region.hotels << {:name => "Radisson London Stansted"}
+      #   region.hotels << super_hotel_in_dubai
+      #
+      # Raises Seatbelt::Errors::TypeMissmatchError if unexpected object
+      # is passed.
+      def <<(item)
+        case item.class.name
+        when acceptable_item_name then super(item)
+        when "Hash" then
+          begin
+            super(Module.const_get(acceptable_item_name).new(item))
+          end
+        else
+          raise Seatbelt::Errors::TypeMissmatchError.
+                                  new(acceptable_item_name,
+                                      item.class.name)
+        end
+      end
+    end
+  end
+end

data/lib/seatbelt/core.rb

@@ -0,0 +1,15 @@
+require 'seatbelt/core/lookup_table'
+require 'seatbelt/core/pool'
+require 'seatbelt/core/property'
+require 'seatbelt/core/interface'
+require 'seatbelt/core/ghost_tunnel'
+require 'seatbelt/core/synthesizeable'
+require 'seatbelt/core/implementation'
+require 'seatbelt/core/gate'
+require 'seatbelt/core/eigenmethod'
+require 'seatbelt/core/eigenmethod_proxy'
+require 'seatbelt/core/terminal'
+require 'seatbelt/core/callee'
+require 'seatbelt/core/proxy'
+require 'seatbelt/core/ext/core_ext'
+require 'seatbelt/core/iterators/method_config'

data/lib/seatbelt/core/callee.rb

@@ -0,0 +1,35 @@
+module Seatbelt
+
+  # Public: Handles passing the call of API Methods to the Terminal.
+  module Callee
+    extend self
+
+    # Public: Handles the calling of a API method (instance and class scope).
+    #
+    # klass     - The class or instance of the class containing the API method
+    # options   - A options Hash to refine required values
+    #             :lookup_tbl   - The class lookup table instance.
+    #             :scope        - The scope the API method should be called on.
+    #             :method_name  - The API method's name
+    # *args     - argument list of the API method
+    # &block    - An optional block passed to the API method
+    #
+    # Returns the return value of the API methods implementation method if
+    # the method configuration was found at the lookup table.
+    def handle(klass, options, *args, &block)
+      lookup_tbl  = options[:lookup_tbl]
+      scope       = options[:scope]
+      method_name = options[:method_name]
+
+      api_method_config = lookup_tbl.
+                          find_method(method_name, scope: scope)
+      arity = api_method_config[method_name][:arity]
+      if api_method_config[method_name][:block_required]
+        if block.nil?
+          raise Seatbelt::Errors::ApiMethodBlockRequiredError
+        end
+      end
+      Seatbelt::Terminal.call(method_name, klass, arity, *args, &block)
+    end
+  end
+end

data/lib/seatbelt/core/eigenmethod.rb

@@ -0,0 +1,150 @@
+module Seatbelt
+
+  # Public: A configuration class that contains the implementation method
+  # directives and attributes.
+  class Eigenmethod
+
+    attr_accessor :scope_level,
+                  :namespace,
+                  :implemented_as,
+                  :method,
+                  :method_implementation_type,
+                  :arity,
+                  :delegated
+
+    attr_writer   :receiver
+
+
+    # Public: The receiver of the implementation method. This is always an
+    # instance whether it defines a class method or instance method
+    # implementation.
+    #
+    # Returns receivers instance.
+    def receiver
+      @receiver
+    end
+
+
+    # Implementation type at remote class (API class) side.
+    #
+    # Returns true if an instance method is implemented, otherwise false.
+    def instance_level?
+      self.scope_level.eql?(:instance)
+    end
+
+    # Implementation type at remote class (API class) side.
+    #
+    # Returns true if a class method is implemented, otherwise false.
+    def class_level?
+      not self.instance_level?
+    end
+
+    # Implementation type at the implementation class side.
+    #
+    # Returns true if a class method is implemented, otherwise false.
+    def class_method_implementation?
+      self.method_implementation_type.eql?(:class)
+    end
+
+    # Implementation type at the implementation class side.
+    #
+    # Returns true if an instance method is implemented, otherwise false.
+    def instance_method_implementation?
+      not class_method_implementation?
+    end
+
+
+    # Public: Calls the implementation method of an API method call.
+    #
+    # *args   - argument list for the implementation method.
+    # &block  - A block if needed.
+    #
+    # Returns the evaluated value.
+    def call(*args, &block)
+      return __send_class_level(*args, &block) if class_level?
+      return __send_instance_level(*args, &block) if instance_level?
+    end
+
+    def [](attr)
+      self.send(attr)
+    end
+
+    alias_method :has_key?, :respond_to?
+    alias_method :scope,    :scope_level
+    alias_method :scope=,   :scope_level=
+
+
+    # Creates the corrosponding class on the receiver and defines the proxy
+    # tunnel on the receivers proxy object.
+    #
+    # klass_object - The API Class or an instance of the API class.
+    #
+    def init_klass_on_receiver(klass_object)
+      if instance_level?
+      __generate_proxy_object(@callee, klass_object)
+      end
+      if class_level?
+        if class_method_implementation?
+           __generate_proxy_object(receiver, klass_object)
+        else
+          if method_implementation_type.eql?(:instance)
+            @callee = callee.new if @callee.respond_to?(:new)
+            @callee.instance_variable_set(:@proxy,Seatbelt::Proxy.new)
+            __generate_proxy_object(callee, klass_object)
+          end
+        end
+      end
+    end
+
+    # Accessor of the api method implementation call object.
+    def callee
+      @callee
+    end
+
+    def __generate_proxy_object(receiver_, klass_object)
+      runner = lambda do |receiver_scope|
+        receiver_scope.send(:proxy_object).instance_variable_set(:@klass, klass_object)
+        receiver_scope.send(:proxy_object).class_eval code
+        receiver_scope.class.send(:define_method, :proxy) do
+          return self.proxy_object
+        end
+        #p receiver_scope.send(:proxy_object)
+        return receiver_scope
+      end
+      runner.call(receiver_)
+    end
+
+    def code
+      <<-RUBY
+        def klass
+          return instance_variable_get(:@klass)
+        end
+        private :klass
+      RUBY
+    end
+
+    def __send_class_level(*args, &block)
+      if class_method_implementation?
+        object = receiver
+      else
+        object = callee
+      end
+      object.send(@method, *args, &block)
+    end
+
+    def __send_instance_level(*args, &block)
+      if method.respond_to?(:bind)
+        value = method.bind(callee).call(*args, &block)
+      else
+        value = callee.send(method, *args, &block)
+      end
+    end
+
+    private :__send_instance_level,
+            :__send_class_level,
+            :__generate_proxy_object,
+            :code,
+            :callee
+
+  end
+end

data/lib/seatbelt/core/eigenmethod_proxy.rb

@@ -0,0 +1,45 @@
+module Seatbelt
+  module EigenmethodProxy
+    extend self
+
+    # Public: Creates or duplicates a new eigenmethod object. Creates the proxy
+    # object on the Eigenmethod and adds this eigenmethod object to
+    # Terminal#luggage or just returns the duplicated or thenewly created object
+    #
+    # *args - An argument list consisting of:
+    #         proxy   - A Seatbelt::Proxy instance
+    #         options - An options hash
+    #           :eigenmethod    - the eigenmethod to duplicate
+    #           :object         - the object the eigenmethod should be bind to
+    #           :receiver       - An instance or class representation of the
+    #                             implementation class
+    #           :add_to         - Eigenmethod should added to Terminal#luggage
+    #                             (defaults to true)
+    #           :return method  - Eigenmethod should be returned
+    #
+    def set(*args)
+      options         = args.extract_options!
+      proxy           = args.pop
+      eigenmethod     = options[:eigenmethod]
+      obj             = options[:object]
+      receiver        = options[:receiver]
+      index           = Terminal.luggage.index(eigenmethod)
+      add_to_luggage  = options.fetch(:add_to, true)
+      return_method   = options.fetch(:return_method, false)
+
+      new_eigenmethod = eigenmethod.dup
+
+      ivar_callee = receiver
+      ivar_callee.instance_variable_set(:@proxy, proxy)
+      new_eigenmethod.instance_variable_set(:@callee,ivar_callee)
+      new_eigenmethod.init_klass_on_receiver(obj) if obj
+
+      if add_to_luggage
+        Terminal.luggage.delete(eigenmethod)
+        Terminal.luggage << new_eigenmethod
+      end
+
+      return new_eigenmethod if return_method
+    end
+  end
+end

data/lib/seatbelt/core/gate.rb

@@ -0,0 +1,198 @@
+module Seatbelt
+
+  # Public: Module that provides method forward declaration named :implement.
+  #
+  module Gate
+
+    def self.included(base)
+      base.class_eval do
+        include Proxy
+        extend ImplementationCallee
+        extend Synthesizeable
+        extend ClassMethods
+        private_class_method :implementation_methods,
+                             :eigenmethods_class_level,
+                             :initialize_implementation_method,
+                             :implementation_from_superclass
+      end
+    end
+
+    module Proxy
+
+      # Public: Access the implementation class Proxy class instance.
+      # If there is no Proxy class instance defined, a new instance will
+      # be initialized.
+      #
+      # Returns the proxy class instance.
+      def proxy_object
+        @proxy
+      end
+
+    end
+
+    module ImplementationCallee
+      def mark_as_instance_implementation
+        lambda do |implementation_method, name|
+          config = implementation_method.values.pop
+          method = self.instance_method(name).bind(self.new)
+          config[:method] = method
+          implement(name, config)
+        end
+      end
+
+      def mark_as_class_implementation
+        lambda do |implementation_method, name|
+          config = implementation_method.values.pop
+          method = name.to_sym#bind(self)
+          config[:method] = method
+          config[:type] = :class
+          implement(name, config)
+        end
+      end
+    end
+
+    module ClassMethods
+      include Gate::Proxy
+      include Gate::Implementation
+      # Internal: Collection of implementation methods configurations defined
+      # with the #implement_class directive.
+      def implementation_methods
+        @impl_methods ||= []
+      end
+
+      def implementation_class_methods
+        @implementation_class_methods ||= []
+      end
+
+      def singleton_method_added(name)
+        implementation_method = implementation_class_methods.detect do |method_config|
+          name.in?(method_config.keys)
+        end
+        if implementation_method
+          mark_as_class_implementation.call(implementation_method, name)
+        end
+      end
+
+      # Public: Ruby hook to check if a method that is added to the class was
+      # defined with the #implement_class directive. If so, it calls the
+      # #implement method. For further information see their method documention.
+      #
+      # name - the method name as Symbol
+      def method_added(name)
+        initialize_implementation_method(name)
+      end
+
+      def initialize_implementation_method(name)
+        implementation_method = implementation_methods.detect do |method_config|
+          name.in?(method_config.keys)
+        end
+        if implementation_method
+          mark_as_instance_implementation.call(implementation_method, name)
+        end
+      end
+
+      def implementation_from_superclass(superclass_method, config)
+        method = self.superclass.instance_method(superclass_method).bind(self.new)
+        config[:method] = method
+        implement(superclass_method,config)
+      end
+
+      # Public: Adds a method forward declaration object to a method config
+      # stack in Seatbelt::Terminal#luggage.
+      #
+      # *args - An argument list containing:
+      #         * method -  The method name that should be forwarded (or marked
+      #                     as implementation of a remote method)
+      #         * options - A options Hash to configure to which method the
+      #                     implementation should be forwarded:
+      #                     :as - A String containing the remote class'
+      #                           namespace followed by a method directive
+      #                           identifier and the remote method name
+      #
+      # Example:
+      #
+      #   implement :support_agility, :as => "Rails::Conference#workshop"
+      #
+      # Forwards the implementation method support_agility to the instance
+      # method #workshop of the class Conference within the module Rails.
+      #
+      #   implement :check_speakers, :as => "Rails::Conference.invite_speakers"
+      #
+      # Forwards the implementation method :check_speakers to the class method
+      # #invite_speakers of the class Conference within the module Rails.
+      #
+      # This will be private in Seatbelt 1.0.
+      def implement(*args)
+        options           = args.extract_options!
+        method            = args.pop
+        remote_method     = options[:as]
+        delegated_method  = options.fetch(:delegated,false)
+        
+        method_scope  = :class     if remote_method.include?(".")
+        method_scope  = :instance  if remote_method.include?("#")
+        directive     = Seatbelt::GateConfig.method_directives[method_scope]
+        scope_chain   = remote_method.split(directive)
+        remote_method = scope_chain.pop.to_sym
+
+        namespace     = scope_chain.shift
+        type          = options.fetch(:type, :instance)
+
+        receiver      = self
+
+        method_proxy                            = Seatbelt::Eigenmethod.new
+        method_proxy.method                     = method
+        method_proxy.scope_level                = method_scope
+        method_proxy.namespace                  = namespace
+        method_proxy.implemented_as             = remote_method
+        method_proxy.receiver                   = receiver
+        method_proxy.method_implementation_type = type
+        method_proxy.delegated                  = delegated_method
+        #method_proxy.arity                      = method.arity
+
+
+
+        if method_scope.eql?(:instance)
+          method    = instance_method(method)
+          method_proxy.arity = method.arity
+        else
+          method_proxy = eigenmethods_class_level(namespace,method_proxy)
+        end
+        Terminal.luggage << method_proxy
+      end
+
+      # Internal: Defines the Eigenclass method proxy object.
+      #
+      # This is only called if an implementation class implements a class
+      # method of its API class. Adds the method proxy to the eigenclass
+      # eigenmethods bucket.
+      #
+      # namespace     - The API class name
+      # method_proxy  - The MethodProxy skeleton created by #implement
+      #
+      # Returns the method proxy.
+      def eigenmethods_class_level(namespace,method_proxy)
+        receiver          = self
+        options           = { :eigenmethod   => method_proxy,
+                              :receiver      => receiver,
+                              :add_to        => false,
+                              :return_method => true
+                            }
+        proxy             = Seatbelt::Proxy.new
+        method_proxy      = Seatbelt::EigenmethodProxy.set(proxy, options)
+        klass             = Module.const_get(method_proxy.namespace)
+
+        callee = method_proxy.instance_variable_get(:@callee)
+        method_proxy.init_klass_on_receiver(klass)
+        implementation_type = method_proxy.instance_variable_get(:@method_implementation_type)
+        if implementation_type.eql?(:instance)
+          method_proxy.arity = callee.instance_method(method_proxy.method).arity
+        else
+          method_proxy.arity = callee.method(method_proxy.method).arity
+        end
+        klass.eigenmethods << method_proxy
+        return method_proxy
+      end
+
+    end
+  end
+end