morpheus 0.3.4

data/lib/morpheus/client/associations.rb

@@ -0,0 +1,47 @@
+module Morpheus
+  module Client
+    module Associations
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+
+        def belongs_to_resource(association, options = {})
+          define_method association do
+            instance_variable_get("@#{association}") ||
+              instance_variable_set("@#{association}", Morpheus::Associations::BelongsToAssociation.new(self, association, :options => options))
+          end
+
+          define_method "#{association}=" do |target|
+            instance_variable_set("@#{association}", Morpheus::Associations::BelongsToAssociation.new(self, association, :target => target, :options => options))
+            send("#{association}_id=", target.id)
+          end
+
+        end
+
+        def has_many_resources(association, options = {})
+          define_method association do
+            instance_variable_get("@#{association}") ||
+              instance_variable_set("@#{association}", Morpheus::Associations::HasManyAssociation.new(self, association, :options => options))
+          end
+
+          define_method "#{association}=" do |target|
+            instance_variable_set("@#{association}", Morpheus::Associations::HasManyAssociation.new(self, association, :target => target, :options => options))
+          end
+        end
+
+        def has_one_resource(association, options = {})
+          define_method association do
+            instance_variable_get("@#{association}") ||
+              instance_variable_set("@#{association}", Morpheus::Associations::HasOneAssociation.new(self, association, :options => options))
+          end
+
+          define_method "#{association}=" do |target|
+            instance_variable_set("@#{association}", Morpheus::Associations::HasOneAssociation.new(self, association, :target => target, :options => options))
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/morpheus/client/inflections.rb

@@ -0,0 +1,3 @@
+ActiveSupport::Inflector.inflections do |inflect|
+  inflect.singular /^(.+)ss$/i, '\1ss'
+end

data/lib/morpheus/client/log_subscriber.rb

@@ -0,0 +1,64 @@
+module Morpheus
+  module Client
+    class LogSubscriber < ActiveSupport::LogSubscriber
+
+      def initialize
+        super
+        @odd_or_even = false
+      end
+
+      def request(event)
+        debug "  #{event.payload[:response].cached? ? cached_request(event) : uncached_request(event)}"
+      end
+
+      def uncached_request(event)
+        duration          = event.payload[:response].time * 1000
+        request_statement = "#{event.payload[:class].to_s} #{event.payload[:method].to_s.upcase} (#{duration}ms)"
+        if odd?
+          request_statement = color(request_statement, MAGENTA, true)
+          payload           = color(payload(event), nil, true)
+        else
+          request_statement = color(request_statement, CYAN, true)
+          payload           = payload(event)
+        end
+
+        response_color = case event.payload[:response].code
+        when 200..299 then GREEN
+        when 400..599 then RED
+        else               YELLOW
+        end
+        response_statement = color("[#{event.payload[:response].code}]", response_color, true)
+
+        "#{request_statement} #{response_statement} #{payload}"
+      end
+
+      def cached_request(event)
+        duration          = event.duration
+        request_statement = "CACHE (#{duration}ms)"
+        if odd?
+          request_statement = color(request_statement, MAGENTA, true)
+          payload           = color(payload(event), nil, true)
+        else
+          request_statement = color(request_statement, CYAN, true)
+          payload           = payload(event)
+        end
+        "#{request_statement} #{payload}"
+      end
+
+      def payload(event)
+        payload  = "#{event.payload[:url]}"
+        payload << " #{event.payload[:params].inspect}" unless event.payload[:params].blank?
+        payload
+      end
+
+      def logger
+        Morpheus::Configuration.logger
+      end
+
+      def odd?
+        @odd_or_even = !@odd_or_even
+      end
+
+    end
+  end
+end

data/lib/morpheus/client/railtie.rb

@@ -0,0 +1,25 @@
+module Morpheus
+  module Client
+    class Railtie < Rails::Railtie
+
+      if defined?(ActiveRecord)
+        ActiveRecord::Base.send(:include, Morpheus::Client::Associations)
+        ActiveRecord::Base.send(:include, Morpheus::UrlSupport)
+      end
+
+      initializer "morpheus.client.configure_request_cache" do |app|
+        app.middleware.use Morpheus::RequestQueue
+        app.middleware.use Morpheus::RequestCache
+      end
+
+      initializer "morpheus.configure_logger", :after => :initialize_logger do |app|
+        Morpheus::Configuration.logger = Rails.logger
+      end
+
+      initializer "morpheus.client.log_subscriber", :after => "morpheus.configure_logger" do
+        Morpheus::Client::LogSubscriber.attach_to :morpheus
+      end
+
+    end
+  end
+end

data/lib/morpheus/configuration.rb

@@ -0,0 +1,49 @@
+module Morpheus
+  class Configuration
+
+    class << self
+      
+      attr_accessor :username, :password
+
+      # Sets and gets the remote host service domain.
+      # The domain must be set before any requests can be made.
+      attr_writer :host
+      def host
+        @host || raise(Morpheus::ConfigurationError, "The request HOST has not been set. Please set the host using Morpheus::Configuration.host = 'http://www.example.com'")
+      end
+
+      # Links to the underlying libcurl request pool.
+      # Allows for concurrent requests.
+      def hydra
+        Typhoeus::Hydra.hydra
+      end
+
+      def hydra=(hydra)
+        Typhoeus::Hydra.hydra = hydra
+      end
+
+      # Handles the default logger that is used by the LogSubscriber
+      def logger
+        @logger ||= ::Logger.new(STDOUT)
+      end
+
+      def logger=(logger)
+        @logger = logger
+      end
+
+      # Can be set or unset to allow for test suite mocking.
+      def allow_net_connect=(allowed)
+        Typhoeus::Hydra.allow_net_connect = allowed
+      end
+
+      # Allow net connections by default.
+      allow_net_connect = true
+
+      def allow_net_connect?
+        Typhoeus::Hydra.allow_net_connect?
+      end
+
+    end
+
+  end
+end

data/lib/morpheus/errors.rb

@@ -0,0 +1,32 @@
+module Morpheus
+  # Occurs when a configuration issue occurs, like when the remote host is not set.
+  class ConfigurationError < ::StandardError
+  end
+
+  # Occurs when a request from a remote host is made while Morpheus::Configuration.allow_net_connect is set to false.
+  class NetConnectNotAllowedError < ::StandardError
+    attr_accessor :request
+    def initialize(_request=nil)
+      self.request= _request
+    end
+  end
+
+  # Occurs when the remote host is unreachable.
+  class RemoteHostConnectionFailure < ::StandardError
+  end
+  
+  # Occurs when there is a server error resulting in a 500 response code
+  class ServerError < ::StandardError
+  end
+
+  # Occurs when the requested resource returns a 404 error, indicating that it could not be found.
+  class ResourceNotFound < ::StandardError
+  end
+
+  # Occurs when the typecast type is not one of the known values.
+  class UnrecognizedTypeCastClass < ::StandardError
+  end
+
+  class InvalidResponseCode < ::StandardError
+  end
+end

data/lib/morpheus/filter.rb

@@ -0,0 +1,18 @@
+module Morpheus
+  class Filter
+
+    def initialize(name, &block)
+      @name  = name
+      @block = block
+    end
+
+    def name
+      @name
+    end
+
+    def call(element)
+      @block.call(element)
+    end
+
+  end
+end

data/lib/morpheus/mixins/associations.rb

@@ -0,0 +1,55 @@
+module Morpheus
+  module Associations
+    autoload :Association,          'morpheus/associations/association'
+    autoload :BelongsToAssociation, 'morpheus/associations/belongs_to_association'
+    autoload :HasManyAssociation,   'morpheus/associations/has_many_association'
+    autoload :HasOneAssociation,    'morpheus/associations/has_one_association'
+
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      def belongs_to(association, options = {})
+        attribute_id_sym  = "#{association}_id".to_sym
+
+        property attribute_id_sym
+
+        create_reflection(:belongs_to, association, options)
+
+        define_method association do
+          instance_variable_get("@#{association}") ||
+            instance_variable_set("@#{association}", BelongsToAssociation.new(self, association, :options => options))
+        end
+
+        define_method "#{association}=" do |target|
+          instance_variable_set("@#{association}", BelongsToAssociation.new(self, association, :target => target, :options => options))
+          send("#{association}_id=", target.id)
+        end
+      end
+
+      def has_many(association, options = {})
+        create_reflection(:has_many, association, options)
+
+        define_method association do
+          instance_variable_get("@#{association}") ||
+            instance_variable_set("@#{association}", HasManyAssociation.new(self, association, :options => options))
+        end
+      end
+
+      def has_one(association, options = {})
+        create_reflection(:has_one, association, options)
+
+        define_method association do
+          instance_variable_get("@#{association}") ||
+            instance_variable_set("@#{association}", HasOneAssociation.new(self, association, :options => options))
+        end
+
+        define_method "#{association}=" do |target|
+          instance_variable_set("@#{association}", HasOneAssociation.new(self, association, :target => target, :options => options))
+        end
+      end
+
+    end
+
+  end
+end

data/lib/morpheus/mixins/attributes.rb

@@ -0,0 +1,133 @@
+module Morpheus
+  module Attributes
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      def property(name, typecast_class = nil)
+        typecast_attributes.store(name.to_sym, typecast_class)
+        default_attributes.store(name.to_sym, nil)
+
+        define_attribute_accessor(name)
+      end
+
+      def default_attributes
+        @attributes ||= HashWithIndifferentAccess.new(superclass.respond_to?(:default_attributes) ? superclass.default_attributes : {})
+      end
+
+      def typecast_attributes
+        @typecast_attributes ||= HashWithIndifferentAccess.new(superclass.respond_to?(:default_attributes) ? superclass.default_attributes : {})
+      end
+
+      def attribute_defined?(attribute)
+        default_attributes.keys.include?(attribute.to_s)
+      end
+
+      def define_attribute_accessor(method)
+        method = method.to_s.delete('=')
+        define_method("#{method}=") do |value|
+          send("#{method}_will_change!")
+          update_attribute(method, value)
+        end
+
+        define_method(method) do
+          attributes[method]
+        end
+
+        define_attribute_methods [method]
+      end
+      private :define_attribute_accessor
+
+    end
+
+    module InstanceMethods
+
+      def attributes
+        @attributes ||= self.class.default_attributes.dup
+      end
+
+      def read_attribute_for_validation(key)
+        attributes[key]
+      end
+
+      def typecast(attribute, value)
+        TypeCaster.cast(value, self.class.typecast_attributes[attribute.to_sym])
+      end
+
+      def attributes_without_basic_attributes
+        attributes_to_reject = %w( id errors valid )
+        self.class.reflections.keys.each do |key|
+          attributes_to_reject.push(key.to_s)
+        end
+        attributes.reject do |key, value|
+          attributes_to_reject.include?(key)
+        end
+      end
+
+      def update_attribute(attribute, value)
+        reflection = self.class.reflect_on_association(attribute)
+        if reflection
+          update_reflection(reflection, attribute, value)
+        else
+          attributes[attribute.to_sym] = typecast(attribute, value)
+        end
+      end
+
+      def update_reflection(reflection, attribute, value)
+        return unless value
+        if reflection.macro == :has_many # need to construct each member of array one-by-one
+          association_object = send(attribute)
+          value.each do |a_value|
+            if a_value.instance_of? reflection.klass
+              target = a_value
+            else
+              target = reflection.build_association(a_value)
+            end
+            association_object << target
+          end
+        elsif reflection.macro == :belongs_to
+          if value.instance_of? reflection.klass
+            target = value
+          else
+            if reflection.options[:polymorphic]
+              polymorphic_class = send("#{reflection.name}_type".to_sym)
+              polymorphic_class = value['type'] if value.include?('type')
+              target = polymorphic_class.constantize.new(value)
+            else
+              target = reflection.build_association(value)
+            end
+          end
+          send("#{attribute}=", target)
+        else
+          if value.instance_of? reflection.klass
+            target = value
+          else
+            target = reflection.build_association(value)
+          end
+          send("#{attribute}=", target)
+        end
+      end
+
+      def merge_attributes(new_attributes)
+        new_attributes.each do |key, value|
+          case key.to_sym
+          when :errors
+            value.each do |k, v|
+              v.each do |message|
+                errors.add(k, message)
+              end
+            end
+          when :valid
+            @valid = value
+          else
+            update_attribute(key, value)
+          end
+        end
+        self
+      end
+      private :merge_attributes
+
+    end
+
+  end
+end

data/lib/morpheus/mixins/conversion.rb

@@ -0,0 +1,21 @@
+module Morpheus
+  module Conversion
+    extend ActiveSupport::Concern
+
+    module InstanceMethods
+
+      def to_model
+        self
+      end
+
+      def to_param
+        id.to_s unless new_record?
+      end
+
+      def to_key
+        attributes.keys if persisted?
+      end
+
+    end
+  end
+end

data/lib/morpheus/mixins/filtering.rb

@@ -0,0 +1,18 @@
+module Morpheus
+  module Filtering
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      def filter(name, &block)
+        (@filters ||= []) << Filter.new(name, &block)
+      end
+
+      def find_filter(name)
+        (@filters ||= []).find { |filter| filter.name == name }
+      end
+
+    end
+
+  end
+end

data/lib/morpheus/mixins/finders.rb

@@ -0,0 +1,58 @@
+module Morpheus
+  module Finders
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      def find(*args)
+        options = args.extract_options!
+        if args.length == 1
+          case args.first
+          when Integer, String
+            attributes = [UrlBuilder.find_one(self, args.first.to_i), nil, { :id => args.first.to_i }]
+            get(*attributes)
+          when Array
+            attributes = UrlBuilder.find_some(self, args.first.sort).push({ :ids => args.first })
+            get(*attributes)
+          else
+            raise ArgumentError, "Unrecognized argument (#{args.first.inspect})."
+          end
+        else
+          attributes = UrlBuilder.find_some(self, args.sort).push({ :ids => args })
+          get(*attributes)
+        end
+      end
+
+      def all
+        attributes = [UrlBuilder.find_all(self), nil, {}]
+        get(*attributes)
+      end
+
+      def first
+        limit(1).first
+      end
+
+      def where(query_attributes)
+        Relation.new(self).where(query_attributes)
+      end
+
+      def limit(amount)
+        Relation.new(self).limit(amount)
+      end
+
+      def page(page_number)
+        Relation.new(self).page(page_number)
+      end
+
+      def results_per_page
+        @results_per_page || 10
+      end
+
+      def results_per_page=(_results_per_page)
+        @results_per_page = _results_per_page
+      end
+
+    end
+
+  end
+end

data/lib/morpheus/mixins/introspection.rb

@@ -0,0 +1,25 @@
+module Morpheus
+  module Introspection
+    extend ActiveSupport::Concern
+
+    module InstanceMethods
+
+      def persisted?
+        !id.nil?
+      end
+
+      def new_record?
+        !persisted?
+      end
+
+      def destroyed?
+        false
+      end
+
+      def respond_to?(method, include_private = false)
+        attributes.include?(method) ? true : super
+      end
+
+    end
+  end
+end

data/lib/morpheus/mixins/persistence.rb

@@ -0,0 +1,46 @@
+module Morpheus
+  module Persistence
+    extend ActiveSupport::Concern
+
+    module InstanceMethods
+
+      def save(with_validations = true)
+        attributes_for_save = { self.class.attributes_root => attributes_without_basic_attributes.reject { |k,v| v.nil? } }
+
+        if with_validations
+          return false unless valid?
+        end
+
+        if new_record?
+          built_object = self.class.post(*UrlBuilder.save(self.class, nil, attributes_for_save))
+        else
+          built_object = self.class.put(*UrlBuilder.save(self.class, id, attributes_for_save))
+        end
+        built_object.instance_variables.each do |iv|
+          self.instance_variable_set(iv, built_object.instance_variable_get(iv))
+        end
+        @valid
+      end
+
+      def update_attributes(new_attributes)
+        merge_attributes(new_attributes)
+        save
+      end
+
+      def destroy
+        self.class.delete(UrlBuilder.destroy(self.class, id))
+      end
+
+    end
+
+    module ClassMethods
+
+      def create(new_attributes = {})
+        new(new_attributes).tap { |new_instance| new_instance.save }
+      end
+      alias :create! :create
+
+    end
+
+  end
+end

data/lib/morpheus/mixins/reflections.rb

@@ -0,0 +1,24 @@
+module Morpheus
+  module Reflections
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      def create_reflection(macro, name, options)
+        Reflection.new(macro, name, options).tap do |reflection|
+          reflections.merge!(name => reflection)
+        end
+      end
+
+      def reflections
+        @reflections ||= {}
+      end
+
+      def reflect_on_association(association)
+        reflections[association.to_sym].is_a?(Reflection) ? reflections[association.to_sym] : nil
+      end
+
+    end
+
+  end
+end

data/lib/morpheus/mixins/request_handling.rb

@@ -0,0 +1,34 @@
+module Morpheus
+  module RequestHandling
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      def get(path, params = nil, metadata = {}, &block)
+        request = Request.enqueue(:get, path, params)
+        request.on_complete = block if block_given?
+        response_from_request(request, metadata)
+      end
+
+      def post(path, params = nil, metadata = {}, &block)
+        request = Request.enqueue(:post, path, params)
+        request.on_complete = block if block_given?
+        response_from_request(request, metadata)
+      end
+
+      def put(path, params = nil, metadata = {}, &block)
+        request = Request.enqueue(:put, path, params)
+        request.on_complete = block if block_given?
+        response_from_request(request, metadata)
+      end
+
+      def delete(path, params = nil, metadata = {}, &block)
+        request = Request.enqueue(:delete, path, params)
+        request.on_complete = block if block_given?
+        response_from_request(request, metadata)
+      end
+
+    end
+
+  end
+end

data/lib/morpheus/mixins/response_parsing.rb

@@ -0,0 +1,27 @@
+module Morpheus
+  module ResponseParsing
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      def response_from_request(request, metadata)
+        ResponseParser.parse(self, request, metadata)
+      end
+
+    end
+
+    module InstanceMethods
+
+      def build_from_response(response)
+        content = Yajl::Parser.parse(response.body)['content']
+        if content.keys.include?('type')
+          content['type'].constantize.new.merge_attributes(content)
+        else
+          merge_attributes(content)
+        end
+      end
+      private :build_from_response
+
+    end
+  end
+end