morpheus 0.3.6 → 0.3.7

data/.autotest

@@ -0,0 +1,12 @@
+Autotest.add_discovery { 'rspec2' }
+
+Autotest.add_hook :initialize do |at|
+  at.clear_mappings
+  ['.git', 'spec/dummy/log'].each { |exception| at.add_exception(exception) }
+
+  at.add_mapping(%r%^lib/(.*)\.rb$%) do |_, m|
+    at.files_matching %r%^spec/#{m[1]}_spec\.rb$%
+  end
+
+  at.add_mapping(%r%^spec/.*\_spec\.rb$%) { |filename, _| filename }
+end

data/.rspec

@@ -0,0 +1 @@
+--color

data/README.md

@@ -0,0 +1,77 @@
+# Morpheus
+## A RESTful API Client library built over Typhoeus
+* The project is working toward a DSL that is very ActiveResource/ActiveRecord-like with some features stolen from other great libraries like DataMapper.
+* We started working on this at a point when we felt we were pushing ActiveResource to its limits.
+* We wanted a little more flexibility in terms of API coupling.
+* We have plans to make Morpheus as flexible as possible in terms of query interface, and resource representation.
+* Additionally, Morpheus is built on top of Typhoeus and will be building in intuitive interfaces for working with parallel requests.
+
+    ```Ruby
+    class Dummy < Morpheus::Base
+      property :name
+      property :created_at
+      property :has_smarts
+
+      belongs_to :thingy
+      has_many :thingamabobs
+      has_one :doohickey
+    end
+    ```
+
+## Creating new resources
+* Morpheus uses ActiveModel and so has an interface that tries to not stray too far from the similar ActiveRecord interface.
+
+    ```Ruby
+    @dummy = Dummy.new(
+      :name       => 'Dumb',
+      :has_smarts => false,
+      :thingy_id  => 2)     # => #<Dummy:0x1016858d8>
+    @dummy.new_record?      # => true
+    @dummy.save             # => POST http://example.com/dummies
+    ```
+
+## Finding existing resources
+* Resources can be retrieved with as little as their classname and unique identifier.
+
+    ```Ruby
+    @dummy = Dummy.find(1) # => GET http:example.com/dummies/1
+    @dummy.new_record?     # => false
+    @dummy.name            # => 'Dumb'
+    ```
+
+## Updating existing resources
+* Resources can be updated just in the same way you would expect from a Active* library.
+
+    ```Ruby
+    @dummy.name = 'Dumber'                        # => 'Dumber'
+    @dummy.save                                   # => PUT http://example.com/dummies/1
+    @dummy.update_attributes(:has_smarts => true) # => PUT http://example.com/dummies/1
+    ```
+
+## Associations
+* Morpheus was originally conceived at a point when we needed ActiveResource with a little more.
+* Associations are a bit of that 'little more'.
+
+    ```Ruby
+    @dummy.thingy       # => GET http://example.com/thingies/2
+    @dummy.thingamabobs # => GET http://example.com/thingamabobs?dummy_id=1
+    @dummy.doohickey    # => GET http://example.com/doohickey?dummy_id=1
+    ```
+
+## Query Interface
+* ARel has a beautiful query interface.
+* We have ported its method-chaining style to fit our query interface.
+
+    ```Ruby
+    Dummy.all                                          # => GET http://example.com/dummies
+    Dummy.find(1,2,3)                                  # => GET http://example.com/dummies?ids=1,2,3
+
+    Dummy.where(:name => 'Dumb')                       # => GET http://example.com/dummies?name=Dumb
+    Dummy.where(:name => 'Dumb', :has_smarts => false) # => GET http://example.com/dummies?name=Dumb&has_smarts=false
+    Dummy.limit(1)                                     # => GET http://example.com/dummies?limit=1
+    Dummy.result_per_page = 25                         # => 25
+    Dummy.page(3)                                      # => GET http://example.com/dummies?limit=25&offset=50
+    ```
+
+## More about the project
+Design informed by Service-Oriented Design with Ruby and Rails by Paul Dix, [Amazon](http://www.amazon.com/Service-Oriented-Design-Rails-Addison-Wesley-Professional/dp/0321659368)

data/Rakefile

@@ -1,2 +1,18 @@
 #!/usr/bin/env rake
 require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+desc 'Default: run specs.'
+task :default => :spec
+
+desc 'Run specs'
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = './spec/**/*_spec.rb'
+end
+
+desc 'Generate code coverage'
+RSpec::Core::RakeTask.new(:coverage) do |t|
+  t.pattern = "./spec/**/*_spec.rb" # don't need this, it's default.
+  t.rcov = true
+  t.rcov_opts = ['--exclude', 'spec']
+end

data/lib/morpheus.rb

@@ -59,8 +59,8 @@ end
 
 # The Railtie loads the LogSubscriber for printing output to the Rails log, and
 # Associations which plug-in to ActiveRecord to link associated resources.
-require 'morpheus/client/railtie' if defined?(Rails)
-require 'morpheus/client/inflections'
+require 'morpheus/client/railtie'     if defined?(Rails)
+require 'morpheus/client/inflections' if defined?(ActiveSupport)
 
 # There are some Typhoeus patches contained here.
 require 'ext/typhoeus'

data/lib/morpheus/base.rb

@@ -41,7 +41,7 @@ module Morpheus
       end
     end
 
-    def ==(comparison_object)      
+    def ==(comparison_object)
       comparison_object.equal?(self) ||
         (comparison_object.instance_of?(self.class) && comparison_object.id == id && !comparison_object.new_record?)
     end

data/lib/morpheus/client/inflections.rb

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

data/lib/morpheus/configuration.rb

@@ -1,48 +1,46 @@
 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
+  module Configuration
+    extend 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

data/lib/morpheus/errors.rb

@@ -14,7 +14,7 @@ module Morpheus
   # 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

data/lib/morpheus/mixins/associations.rb

@@ -5,7 +5,9 @@ module Morpheus
     autoload :HasManyAssociation,   'morpheus/associations/has_many_association'
     autoload :HasOneAssociation,    'morpheus/associations/has_one_association'
 
-    extend ActiveSupport::Concern
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
 
     module ClassMethods
 

data/lib/morpheus/mixins/attributes.rb

@@ -1,6 +1,9 @@
 module Morpheus
   module Attributes
-    extend ActiveSupport::Concern
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
 
     module ClassMethods
 
@@ -40,94 +43,90 @@ module Morpheus
 
     end
 
-    module InstanceMethods
+    def attributes
+      @attributes ||= self.class.default_attributes.dup
+    end
 
-      def attributes
-        @attributes ||= self.class.default_attributes.dup
-      end
+    def read_attribute_for_validation(key)
+      attributes[key]
+    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 typecast(attribute, value)
-        TypeCaster.cast(value, self.class.typecast_attributes[attribute.to_sym])
+    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
-
-      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
+      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
+    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
+    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
-            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
+            target = reflection.build_association(a_value)
           end
-          send("#{attribute}=", target)
+          association_object << target
+        end
+      elsif reflection.macro == :belongs_to
+        if value.instance_of? reflection.klass
+          target = value
         else
-          if value.instance_of? reflection.klass
-            target = value
+          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
-          send("#{attribute}=", target)
         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
+    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
-          when :valid
-            @valid = value
-          else
-            update_attribute(key, value)
           end
+        when :valid
+          @valid = value
+        else
+          update_attribute(key, value)
         end
-        self
       end
-      private :merge_attributes
-
+      self
     end
+    private :merge_attributes
 
   end
 end

data/lib/morpheus/mixins/conversion.rb

@@ -1,21 +1,17 @@
 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_model
+      self
+    end
 
-      def to_key
-        attributes.keys if persisted?
-      end
+    def to_param
+      id.to_s unless new_record?
+    end
 
+    def to_key
+      attributes.keys if persisted?
     end
+
   end
 end