seat-belt 0.10.0

data/lib/seatbelt/errors.rb

@@ -0,0 +1 @@
+require 'seatbelt/errors/errors'

data/lib/seatbelt/errors/errors.rb

@@ -0,0 +1,150 @@
+module Seatbelt
+
+  # Public: Various errors used with Seatbelt.
+  #
+  module Errors
+
+    # Public: Will be raised if there are too much or too few arguments passed
+    # to a method.
+    # Only declared for design purposes.
+    #
+    class ArgumentsMissmatchError < ::ArgumentError; end
+
+
+    # Public: Will be raised within Seatbelt::Pool::Api#api_method if no meta
+    # method name is passed.
+    #
+    class MissingMetaMethodName < ::StandardError
+      def message
+        "You have to specifiy a meta-method name!"
+      end
+    end
+
+
+    # Public: Will be raised if a meta method definition will be inserted into
+    # the class lookuptable but already exists.
+    #
+    class MetaMethodDuplicateError < ::StandardError
+      def message
+        "The meta-method you want to define is ambigious."
+      end
+    end
+
+
+    # Public: Will be raised if a meta method is defined but not implemented in
+    # the remote class.
+    #
+    class MethodNotImplementedError < ::NoMethodError; end
+
+
+    # Public: Will be raised if a method directive for configurating the Gate is
+    # used but the directive is not allowed for usage.
+    #
+    class DirectiveNotAllowedError < ::StandardError
+      def message
+        "The directive you want to use is not allowed."
+      end
+    end
+
+
+    # Public: Will be raised if a method isn't implemented at a class or class
+    # instance.
+    #
+    class NoMethodError < MethodNotImplementedError; end
+
+
+    # Public: Will be raised if a method requires a block but isn't passed to
+    # the method.
+    #
+    class ApiMethodBlockRequiredError < ::StandardError
+      def message
+        "The method you want to call requires a block."
+      end
+    end
+
+    # Public: Will be raised if a model is assigned to a 'has_many' association
+    # and the models class isn't of required type.
+    class TypeMissmatchError < ::StandardError
+      attr_accessor :awaited, :got
+
+      # Public: Initialize a TypeMissmatchError.
+      #
+      # awaited - The awaited objects class name
+      # got     - The actual assigned objects class name.
+      def initialize(awaited, got)
+        @awaited = awaited
+        @got = got
+      end
+
+      # The exception message in an understandable form.
+      #
+      # Returns the error message.
+      def to_s
+        msg = "An instance of #{awaited} awaited but "
+        msg += "get an instance of #{got}."
+        return msg
+      end
+    end
+
+    # Public: Will be raised if a question/query is called and no tape with
+    # implementation is found.
+    #
+    class NoTapeFoundForQueryError < ::StandardError
+      def message
+        "There is no tape implemented for answering this question."
+      end
+    end
+
+    # Public: Will be raised if a tape should be used in multiple tape decks.
+    #
+    class MultipleTapeUsageDetectedError < ::StandardError
+      def message
+        "A tape can't be used in multiple tape decks."
+      end
+    end
+
+    # Public: Will be raised if a synthseizer did not implement the
+    # synthesizable_attributes method.
+    class SynthesizeableAttributesNotImplementedError < ::StandardError
+      def message
+        "Your synthesizer has to implement #synthesizable_attributes."
+      end
+    end
+
+    # Public: Will be raised if an object is tried to call that does not exist
+    # at runtime.
+    class ObjectDoesNotExistError < ::StandardError
+      def message
+        "The object you called does not exist."
+      end
+    end
+
+    class ArgumentMissmatchError < ArgumentError; end
+
+    # Public: Will be raised if a property is tried to define on a class level
+    # interface.
+    class PropertyOnClassLevelDefinedError < ::StandardError
+      def message
+        <<-MESSAGE.gsub(/^\s+/, "")
+          You try to define a property at class level interface. That is not
+            supported by now but maybe in future version.
+        MESSAGE
+      end
+    end
+
+    class PropertyNotDefinedYetError < ::StandardError
+
+      def initialize(property_name)
+        @property_name = property_name
+      end
+
+      def to_s
+        <<-MESSAGE.gsub(/^\s+/, "")
+          You try to define a property as accessible that is not defined yet.
+          Use define_property :#{@property_name} to define your property first.
+        MESSAGE
+      end
+    end
+
+  end
+end

data/lib/seatbelt/gate_config.rb

@@ -0,0 +1,59 @@
+module Seatbelt
+  
+  # Public: A configuration class to configure the Gate.
+  #
+  class GateConfig
+
+    # Public: Setter to set the instance method directive. This is optional
+    # and defaults to #
+    #
+    # :: is not allowed as directive.
+    #
+    # directive - A String representing the directive.
+    #
+    def self.method_directive_instance=(directive)
+      Seatbelt.check_directive(directive)
+      @method_directive_instance = directive
+    end
+
+    # Public: Setter to set the class method directive. This is optional
+    # and defaults to .
+    #
+    # :: is not allowed as directive.
+    #
+    # directive - A String representing the directive.
+    #
+    def self.method_directive_class=(directive)
+      Seatbelt.check_directive(directive)
+      @method_directive_class = directive
+    end
+
+    # Public: Getter to retrieve te instance method directive.
+    #
+    # Returns the instance method directive if set otherwise '#'
+    def self.method_directive_instance
+      @method_directive_instance || "#"
+    end
+
+    # Public: Getter to retrieve te class method directive.
+    #
+    # Returns the class method directive if set otherwise '.'
+    def self.method_directive_class
+      @method_directive_class || "."
+    end
+
+    # Public: Hash of method directives attached to its scope.
+    #
+    # Contains :class and :instance keys and their corrosponding method
+    # directives
+    #
+    # Returns a Hash.
+    def self.method_directives
+      {
+        :class    => self.method_directive_class,
+        :instance => self.method_directive_instance
+      }
+    end
+
+  end
+end

data/lib/seatbelt/ghost.rb

@@ -0,0 +1,140 @@
+module Seatbelt
+
+  # Public: Handles calling and defining of API methods.
+  #
+  # Any class that should acts like a API Class have to include this module.
+  #
+  # class Flight
+  #   include Seatbelt::Ghost
+  #
+  #   api_method  :estimated_flight_time
+  #
+  #   api_method  :find_flights,
+  #               :scope => :class
+  # end
+  #
+  # flight = Flight.new
+  # flight.estimated_flight_time(:to => "London")
+  # Flight.find_flights(:to => "London", :from => "Frankfurt")
+  module Ghost
+
+    def self.included(base)
+      base.class_eval do
+        [Pool::Api, EigenmethodStore, ClassMethods,
+          GhostTunnel,Interface].each do |mod|
+          self.extend mod
+        end
+        include EigenmethodStore
+        include Seatbelt::Property::InstanceMethods
+
+        class << self
+
+          alias_method :_new, :new
+          # Public: Overrides the Class#new method to create the class instance
+          # eigenmethods.
+          #
+          # *args - An argumentlist passed to #initialize
+          #
+          # Returns the instance.
+          def new(*args)
+            obj = _new(*args)
+            namespace = obj.class.name
+            eigenmethods_for_scope = Terminal.
+                                     for_scope_and_namespace(:instance,
+                                                             namespace)
+            unless eigenmethods_for_scope.empty?
+              proxy = Seatbelt::Proxy.new
+              receiver = eigenmethods_for_scope.first.receiver.new
+              eigenmethods_for_scope.each do |eigenmethod|
+                options = {:eigenmethod => eigenmethod,
+                           :object      => obj,
+                           :receiver    => receiver,
+                           :return_method => true,
+                           :add_to      => false
+                          }
+                obj.eigenmethods << Seatbelt::EigenmethodProxy.set(proxy, options)
+                if obj.class.respond_to?(:synthesizers)
+                  synthesizers = obj.class.synthesizers.select do |synthesizer|
+                    synthesizer[:klass].eql?(obj.class.name)
+                  end
+                  unless synthesizers.empty?
+                    synthesizers.each do |synthesizer|
+                      synthesizer[:adapter].new(obj.class, receiver).synthesize
+                    end
+                  end
+                end
+              end
+            end
+            return obj
+          end
+        end
+
+      end
+    end
+
+    module EigenmethodStore
+
+      def eigenmethods
+        @eigenmethods ||= []
+      end
+
+    end
+
+
+    module ClassMethods
+      # Public: Calls a API class method. If the method isn't defined or
+      # found in the class lookup table a Seatbelt::Errors::NoMethodError is
+      # raised.
+      #
+      # If method is defined it passes the calling responsibility to the core
+      # Callee module.
+      #
+      # method_name - the called methods name
+      # *args       - the methods argument list
+      # &block      - the methods block (this is optional)
+      #
+      # Returns the evaluted method value.
+      def method_missing(method_name, *args, &block)
+        unless self.lookup_tbl.has?(method_name, scope: :class)
+          raise Seatbelt::Errors::NoMethodError
+        end
+        Seatbelt::Callee.handle(self,
+                                { :lookup_tbl  => self.lookup_tbl,
+                                  :scope       => :class,
+                                  :method_name => method_name
+                                },
+                                *args,
+                                &block)
+      end
+
+    end
+
+    # Public: Calls a API instance method. If the method isn't defined or
+    # found in the class lookup table a Seatbelt::Errors::NoMethodError is
+    # raised.
+    #
+    # If method is defined it passes the calling responsibility to the core
+    # Callee module.
+    #
+    # method_name - the called methods name
+    # *args       - the methods argument list
+    # &block      - the methods block (this is optional)
+    #
+    # Returns the evaluted method value.
+    def method_missing(method_name, *args, &block)
+      unless self.class.lookup_tbl.has?(method_name)
+        unless self.respond_to?(method_name)
+          raise Seatbelt::Errors::NoMethodError
+        end
+      end
+      Seatbelt::Callee.handle(self,
+                              { :lookup_tbl  => self.class.lookup_tbl,
+                                :scope       => :instance,
+                                :method_name => method_name
+                              },
+                              *args,
+                              &block)
+    end
+
+  end
+end

data/lib/seatbelt/models.rb

@@ -0,0 +1,9 @@
+require 'seatbelt/models/hotel'
+require 'seatbelt/models/flight'
+require 'seatbelt/models/airport'
+require 'seatbelt/models/offer'
+require 'seatbelt/models/region_offer'
+require 'seatbelt/models/picture'
+require 'seatbelt/models/travel_request'
+require 'seatbelt/models/travel_response'
+require 'seatbelt/models/region_response'

data/lib/seatbelt/seatbelt.rb

@@ -0,0 +1,10 @@
+require 'seatbelt/core'
+require 'seatbelt/synthesizer'
+require 'seatbelt/gate_config'
+require 'seatbelt/ghost'
+require 'seatbelt/tape'
+require 'seatbelt/tape_deck'
+require 'seatbelt/document'
+require 'seatbelt/errors'
+require 'seatbelt/collections/collection'
+require 'seatbelt/translator'

data/lib/seatbelt/synthesizer.rb

@@ -0,0 +1,3 @@
+require 'seatbelt/synthesizers/synthesizer'
+require 'seatbelt/synthesizers/document'
+require 'seatbelt/synthesizers/mongoid'

data/lib/seatbelt/synthesizers/document.rb

@@ -0,0 +1,16 @@
+module Seatbelt
+  module Synthesizers
+
+    # Public: A Synthesizer that syncs a Seatbelt::Document based implementation
+    # class with a Seatbelt::Document proxy object
+    class Document
+      include Seatbelt::Synthesizer
+
+      # The attributes to synthesize as Array.
+      def synthesizable_attributes
+        synthesizable_object.attributes.keys
+      end
+
+    end
+  end
+end

data/lib/seatbelt/synthesizers/mongoid.rb

@@ -0,0 +1,16 @@
+module Seatbelt
+  module Synthesizers
+
+    # Public: A Synthesizer that syncs a Mongoid::Document based implementation
+    # class with a Seatbelt::Document proxy object
+    class Mongoid
+      include Seatbelt::Synthesizer
+
+      # The attributes to synthesize as Array.
+      def synthesizable_attributes
+        synthesizable_object.fields.keys.map(&:to_sym)
+      end
+
+    end
+  end
+end

data/lib/seatbelt/synthesizers/synthesizer.rb

@@ -0,0 +1,146 @@
+module Seatbelt
+
+  # Public: The Synthesizer base module which provides attribute based
+  # synthesizing between a proxy and an implementation object.
+  #
+  # To create a Synthesizer include this module in a plain Ruby class and
+  # implement the #synthesizable_attributes method.
+  #
+  # Example
+  #
+  #   class BookSynthesizer
+  #     include Seatbelt::Synthesizer
+  #
+  #     def synthesizable_attributes
+  #       [:title, :publisher]
+  #     end
+  #   end
+  #
+  #
+  #   class Book
+  #     include Seatbelt:Document
+  #     include Seatbelt::Ghost
+  #
+  #     attribute :title,     String
+  #     attribute :publisher, String
+  #     attribute :author,    String
+  #
+  #     api_method :sell
+  #   end
+  #
+  #   class ImplementationBook < ActiveRecord::Base
+  #     include Seatbelt::Gate
+  #
+  #     synthesize :from    => "Book",
+  #                :adapter => "BookSynthesizer"
+  #   end
+  module Synthesizer
+
+    attr_reader :synthesizable_object
+
+    # Public: Initializes the Synthesizer.
+    #
+    # from_klass            - The API Class
+    # synthesizable_object  - The implementation class instance
+    def initialize(from_klass, synthesizable_object)
+      @klass                = from_klass
+      @synthesizable_object = synthesizable_object
+    end
+
+    # Public: Defines the attribute based synthesize mechanism by redefining the
+    # getter and setter methods of the implementation class instance.
+    #
+    def synthesize
+      unless self.respond_to?(:synthesizable_attributes)
+        raise Seatbelt::Errors::SynthesizeableAttributesNotImplementedError
+      end
+      if @synthesizable_object.class.respond_to?(:synthesize_map)
+        if @synthesizable_object.class.synthesize_map.empty?
+          __synthesize_without_map
+        else
+          __synthesize_with_map
+        end
+      else
+        __synthesize_without_map
+      end
+    end
+
+    # Defines synthesizing with the same proxy object attributes and
+    # implementation class instance attributes.
+    #
+    def __synthesize_without_map
+      @klass.attribute_set.each do |attr|
+        attribute_name = attr.name
+        if attribute_name.in?(__synthesizable_attribute_names)
+          __redefine_setter(@synthesizable_object, attribute_name)
+          __redefine_getter(@synthesizable_object, attribute_name)
+        end
+      end
+    end
+
+    # Defines synthesizing by considering the presence of a synthesize map of
+    # proxy and implementation attributes.
+    def __synthesize_with_map
+      map = @synthesizable_object.class.synthesize_map
+      @klass.attribute_set.each do |attr|
+        attribute_name = attr.name
+        if attribute_name.in?(map.keys)
+          object_attribute_name = map[attribute_name]
+          __redefine_setter(@synthesizable_object, object_attribute_name,
+                            attribute_name)
+          __redefine_getter(@synthesizable_object, object_attribute_name,
+                            attribute_name)
+        end
+      end
+    end
+
+    def __synthesizable_attribute_names
+      if synthesizable_attributes.is_a?(Hash)
+        return synthesizable_attributes.keys
+      else
+        return synthesizable_attributes
+      end
+    end
+
+    def __redefine_getter(on_object, attribute, klass_attribute_name=nil)
+      if klass_attribute_name.nil?
+        klass_attribute_name = attribute
+      end
+      getter_code = <<-RUBY
+        class << self
+          alias_method :_#{attribute}, :#{attribute}
+          #alias_method "_#{attribute}=", "#{attribute}="
+        end
+        def #{attribute}
+          self.send("#{attribute}=", proxy.send("#{klass_attribute_name}"))
+          return self.send("_#{attribute}")
+        end
+      RUBY
+      on_object.instance_eval getter_code, __FILE__, __LINE__
+    end
+
+    def __redefine_setter(on_object, attribute, klass_attribute_name=nil)
+      if klass_attribute_name.nil?
+        klass_attribute_name = attribute
+      end
+      setter_code = <<-RUBY
+        class << self
+          #alias_method :_#{attribute}, :#{attribute}
+          alias_method "_#{attribute}=", "#{attribute}="
+        end
+
+        def #{attribute}=(value)
+          proxy.send("#{klass_attribute_name}=",value)
+          self.send("_#{attribute}=",value)
+        end
+      RUBY
+      on_object.instance_eval setter_code, __FILE__, __LINE__
+    end
+
+    private :__synthesizable_attribute_names,
+            :__redefine_getter,
+            :__redefine_setter,
+            :__synthesize_without_map,
+            :__synthesize_with_map
+  end
+end