morpheus 0.3.4

data/lib/morpheus/mixins/url_support.rb

@@ -0,0 +1,36 @@
+module Morpheus
+  module UrlSupport
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      def url_name
+        @url_name ||= model_name.underscore
+      end
+      alias_method :singular_url_name, :url_name
+
+      def plural_url_name
+        url_name.pluralize
+      end
+
+      def set_base_url(url_name)
+        @url_name = url_name
+      end
+
+      def attributes_root
+        @attributes_root ||= model_name.underscore
+      end
+
+      def set_attributes_root(name)
+        @attributes_root = name
+      end
+
+      def set_base_model_name(name)
+        set_base_url(name)
+        set_attributes_root(name)
+      end
+
+    end
+
+  end
+end

data/lib/morpheus/mock.rb

@@ -0,0 +1,66 @@
+# The Mock class is used to mock out single instances of a remote resource.
+# It will stub any requests to /:class_name/:id.
+module Morpheus
+  class Mock
+
+    def initialize(mock_class, id, attributes = {}, options = {})
+      @mock_class = mock_class.to_s
+      @attributes = HashWithIndifferentAccess.new(attributes).merge({ 'id' => id })
+      @options    = options
+
+      @attributes.keys.each do |attribute|
+        (class << self; self; end).class_eval do
+          define_method attribute do
+            @attributes[attribute]
+          end
+
+          define_method "#{attribute}=" do |value|
+            @attributes[attribute] = value
+          end
+        end
+      end
+
+      stub_finder_methods!
+    end
+
+    def id
+      @attributes[:id]
+    end
+
+    def status
+      @options[:status] || 200
+    end
+
+    def ==(other_object)
+      HashWithIndifferentAccess.new(other_object.attributes) == @attributes && other_object.class.to_s == @mock_class
+    end
+
+    def self.mock(mock_class, id, attributes = {}, options = {})
+      new(mock_class, id, attributes, options)
+    end
+
+    def self.clear!
+      Configuration.hydra.clear_stubs
+    end
+
+    private
+
+    def stub_finder_methods!
+      stub_find_one!
+    end
+
+    def stub_find_one!
+      response = Morpheus::Response.new(:code => status, :headers => "", :body => stub_find_one_body, :time => 0.3)
+      Configuration.hydra.stub(:get, find_one_uri).and_return(response)
+    end
+
+    def stub_find_one_body
+      { :status  => status, :content => @attributes.merge({ :id => 1 }) }.to_json
+    end
+
+    def find_one_uri
+      "#{Configuration.host}/#{@mock_class.underscore.pluralize}/#{id}"
+    end
+
+  end
+end

data/lib/morpheus/reflection.rb

@@ -0,0 +1,22 @@
+module Morpheus
+  class Reflection
+    attr_reader :macro, :name, :options
+
+    def initialize(macro, name, options = {})
+      @macro, @name, @options = macro, name, options
+    end
+
+    def klass
+      @klass ||= class_name.constantize
+    end
+
+    def class_name
+      (options[:class_name] || name).to_s.singularize.camelize
+    end
+
+    def build_association(*options)
+      klass.new(*options)
+    end
+
+  end
+end

data/lib/morpheus/relation.rb

@@ -0,0 +1,57 @@
+module Morpheus
+  class Relation < ActiveSupport::BasicObject
+
+    def initialize(owner)
+      @owner  = owner
+      @target = nil
+      @params = {}
+    end
+
+    def where(attributes)
+      @params.merge!(attributes)
+      self
+    end
+
+    def limit(amount)
+      @params.merge!(:limit => amount)
+      self
+    end
+
+    def page(page_number)
+      offset = (page_number - 1) * @owner.results_per_page
+      @params.merge!(:limit => @owner.results_per_page, :offset => offset)
+      self
+    end
+
+    def all
+      loaded_target
+    end
+
+    def to_a
+      loaded_target
+    end
+
+    def to_json(*args)
+      to_a.to_json(*args)
+    end
+
+    private
+
+    def loaded_target
+      @target ||= load_target!
+    end
+
+    def load_target!
+      @owner.get(*UrlBuilder.relation(@owner, @params))
+    end
+
+    def method_missing(m, *args, &block)
+      if Array.method_defined?(m)
+        loaded_target.send(m, *args, &block)
+      else
+        loaded_target.send(m, *args, &block)
+      end
+    end
+
+  end
+end

data/lib/morpheus/request.rb

@@ -0,0 +1,41 @@
+module Morpheus
+  class Request < Typhoeus::Request
+    attr_reader :path, :params, :method
+
+    def initialize(path, options = {})
+      if options[:method] == :put
+        options[:method] = :post
+        options[:params].merge!(:_method => :put)
+      end
+      
+      options[:username] = Configuration.username if Configuration.username
+      options[:password] = Configuration.password if Configuration.password
+
+      super(Configuration.host + path, options)
+    end
+
+    def cache_key
+      [method, url, params].hash
+    end
+
+    def response=(response)
+      RequestCache.cache[cache_key] = response
+      response.tag_for_caching!
+      super
+    end
+
+    def response
+      RequestQueue.run! if RequestQueue.has_request?(self)
+      RequestCache.cache[cache_key] || super
+    end
+
+    def self.enqueue(method, path, params)
+      options = { :method => method }
+      options.merge!(:params => params) if params
+      new(path, options).tap do |request|
+        RequestQueue.enqueue(request)
+      end
+    end
+
+  end
+end

data/lib/morpheus/request_cache.rb

@@ -0,0 +1,18 @@
+module Morpheus
+  class RequestCache
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      self.class.cache.clear
+      @app.call(env)
+    end
+
+    def self.cache
+      @cache ||= {}
+    end
+
+  end
+end

data/lib/morpheus/request_queue.rb

@@ -0,0 +1,44 @@
+module Morpheus
+  class RequestQueue
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      self.class.queue.clear
+      @app.call(env)
+    end
+
+    class << self
+
+      def enqueue(request)
+        queue << request
+      end
+
+      def queue
+        @queue ||= []
+      end
+
+      def uncached_queue
+        queue.collect { |request| request if RequestCache.cache[request.cache_key].nil? }.compact
+      end
+
+      def hydra
+        Configuration.hydra
+      end
+
+      def run!
+        uncached_queue.each { |request| hydra.queue(request) }
+        hydra.run
+        queue.clear
+      end
+
+      def has_request?(request)
+        queue.include?(request)
+      end
+
+    end
+
+  end
+end

data/lib/morpheus/response.rb

@@ -0,0 +1,24 @@
+module Morpheus
+  class Response < Typhoeus::Response
+
+    def initialize(params = {}, cached = false)
+      super(params)
+      @cached = cached
+    end
+
+    def cached?
+      !!@cached.tap do
+        @cached = tagged_for_caching?
+      end
+    end
+    
+    def tag_for_caching!
+      @tagged_for_caching = true
+    end
+    
+    def tagged_for_caching?
+      @tagged_for_caching ||= false
+    end
+
+  end
+end

data/lib/morpheus/response_parser.rb

@@ -0,0 +1,80 @@
+module Morpheus
+  class ResponseParser
+
+    def initialize(owner, request, metadata)
+      @requesting_class = owner
+      @request          = request
+      @response         = request.response
+      @metadata         = metadata
+    end
+
+    def self.parse(owner, request, metadata)
+      parser = new(owner, request, metadata)
+
+      ActiveSupport::Notifications.instrument('request.morpheus', :url => request.url, :params => request.params, :method => request.method, :class => owner, :response => request.response) do
+        @parsed_response = parser.parse
+      end
+      RequestCache.cache.clear unless request.method == :get
+      @parsed_response
+    end
+
+    def parse
+      case @response.code
+      when 200..299
+        build_from_response
+      when 404
+        raise_not_found
+      when 422
+        build_from_response
+      when 500..599
+        raise ServerError
+      when 0
+        raise RemoteHostConnectionFailure
+      else
+        raise InvalidResponseCode, "Response had error code: #{@response.code}"
+      end
+    end
+
+    private
+
+    def content
+      @content ||= Yajl::Parser.parse(@response.body).try(:[], 'content')
+    end
+    
+    def response_errors
+      @response_errors ||= Yajl::Parser.parse(@response.body).try(:[], 'errors')
+    end
+
+    def build_from_response
+      if content
+        if Array === content
+          content.collect do |attributes|
+            obj = build_object_with_attributes(attributes)
+          end
+        else
+          obj = build_object_with_attributes(content)
+        end
+      end
+    end
+    
+    def build_object_with_attributes(attributes)
+      if attributes.keys.include?('type')
+        attributes['type'].constantize.new(attributes)
+      else
+        @requesting_class.new.send(:merge_attributes, attributes)
+      end
+    end
+
+    def raise_not_found
+      case
+      when @metadata[:ids]
+        raise ResourceNotFound, "Couldn't find all #{@requesting_class.to_s.pluralize} with IDs (#{@metadata[:ids].join(', ')})"
+      when @metadata[:id]
+        raise ResourceNotFound, "Couldn't find #{@requesting_class} with ID=#{@metadata[:id]}"
+      else
+        raise ResourceNotFound, "No resource was found at #{@request.url} #{response_errors.inspect if response_errors}"
+      end
+    end
+
+  end
+end

data/lib/morpheus/type_caster.rb

@@ -0,0 +1,80 @@
+module Morpheus
+  class TypeCaster
+
+    class << self
+
+      def cast(value, typecast_class)
+        case typecast_class
+        when NilClass
+          value
+        when :string
+          parse_string(value)
+        when :integer
+          parse_integer(value)
+        when :datetime
+          parse_datetime(value)
+        when :date
+          parse_date(value)
+        when :time
+          parse_time(value)
+        when :boolean
+          parse_boolean(value)
+        else
+          raise UnrecognizedTypeCastClass, "Can't typecast to #{typecast_class}!"
+        end
+      end
+
+      private
+
+      def parse_string(value)
+        value.to_s
+      end
+
+      def parse_integer(value)
+        if value.respond_to?(:to_i)
+          value.to_i
+        else
+          case value
+          when TrueClass  then 1
+          when FalseClass then 0
+          when Date       then value.to_time.utc.to_i
+          end
+        end
+      end
+
+      def parse_datetime(value)
+        if value.respond_to?(:to_datetime)
+          value.to_datetime
+        else
+          DateTime.parse(value) unless [TrueClass, FalseClass, NilClass, Fixnum].include?(value.class)
+        end
+      rescue ArgumentError
+        nil
+      end
+
+      def parse_date(value)
+        if value.respond_to?(:to_time)
+          parse_time(value).try(:to_date)
+        else
+          Date.parse(value) unless [TrueClass, FalseClass, NilClass, Fixnum].include?(value.class)
+        end
+      end
+
+      def parse_time(value)
+        if value.respond_to?(:to_time)
+          value.to_time
+        else
+          Time.parse(value) unless [TrueClass, FalseClass, NilClass, Fixnum].include?(value.class)
+        end
+      rescue ArgumentError
+        nil
+      end
+
+      def parse_boolean(value)
+        !["nil", nil, "false", false, "0", 0].include?(value)
+      end
+
+    end
+
+  end
+end

data/lib/morpheus/url_builder.rb

@@ -0,0 +1,52 @@
+module Morpheus
+  class UrlBuilder
+
+    class << self
+
+      def find_one(klass, id)
+        "/#{klass.plural_url_name}/#{id}"
+      end
+
+      def find_some(klass, ids)
+        ["/#{klass.plural_url_name}", { :ids => ids }]
+      end
+
+      def find_all(klass)
+        "/#{klass.plural_url_name}"
+      end
+
+      def save(klass, id, parameters)
+        url_base = "/#{klass.plural_url_name}"
+        url_base << "/#{id}" if id
+        [url_base, parameters]
+      end
+
+      def belongs_to(klass, id)
+        "/#{klass.plural_url_name}/#{id}"
+      end
+
+      def has_one(primary_class, primary_key, foreign_class)
+        "/#{primary_class.plural_url_name}/#{primary_key}/#{foreign_class.singular_url_name}"
+      end
+
+      def has_many(primary_class, primary_key, foreign_class)
+        "/#{primary_class.plural_url_name}/#{primary_key}/#{foreign_class.plural_url_name}"
+      end
+
+      def relation(klass, parameters = {})
+        url_base = "/#{klass.plural_url_name}"
+        if parameters.empty?
+          url_base
+        else
+          [url_base, parameters]
+        end
+      end
+
+      def destroy(klass, id)
+        "/#{klass.plural_url_name}/#{id}"
+      end
+
+    end
+
+  end
+end

data/lib/morpheus.rb

@@ -0,0 +1,64 @@
+# We are using Yalj::Ruby for its JSON parsing hotness.
+require 'yajl/json_gem'
+
+# Typhoeus is used for HTTP requests. The libcurl library allows us to make multiple requests in parallel.
+require 'typhoeus'
+
+# ActiveModel provides validations, errors, naming...
+require 'active_model'
+
+# The bulk of the library consists of the Base class and its mix-in modules, the request/response wrappers,
+# mocking, configuration, errors, and classes managing associations, reflections, relations, and typecasting.
+module Morpheus
+  autoload :Base,           'morpheus/base'
+  autoload :Configuration,  'morpheus/configuration'
+  autoload :Filter,         'morpheus/filter'
+  autoload :Mock,           'morpheus/mock'
+  autoload :Reflection,     'morpheus/reflection'
+  autoload :Relation,       'morpheus/relation'
+  autoload :Request,        'morpheus/request'
+  autoload :RequestQueue,   'morpheus/request_queue'
+  autoload :RequestCache,   'morpheus/request_cache'
+  autoload :Response,       'morpheus/response'
+  autoload :ResponseParser, 'morpheus/response_parser'
+  autoload :TypeCaster,     'morpheus/type_caster'
+  autoload :UrlBuilder,     'morpheus/url_builder'
+
+  # Mixins provide behaviors to the Base class.
+  autoload :Associations,    'morpheus/mixins/associations'
+  autoload :Attributes,      'morpheus/mixins/attributes'
+  autoload :Conversion,      'morpheus/mixins/conversion'
+  autoload :Filtering,       'morpheus/mixins/filtering'
+  autoload :Finders,         'morpheus/mixins/finders'
+  autoload :Introspection,   'morpheus/mixins/introspection'
+  autoload :Persistence,     'morpheus/mixins/persistence'
+  autoload :Reflections,     'morpheus/mixins/reflections'
+  autoload :RequestHandling, 'morpheus/mixins/request_handling'
+  autoload :ResponseParsing, 'morpheus/mixins/response_parsing'
+  autoload :UrlSupport,      'morpheus/mixins/url_support'
+
+  # Error classes
+  autoload :ConfigurationError,          'morpheus/errors'
+  autoload :NetConnectNotAllowedError,   'morpheus/errors'
+  autoload :RemoteHostConnectionFailure, 'morpheus/errors'
+  autoload :ResourceNotFound,            'morpheus/errors'
+  autoload :UnrecognizedTypeCastClass,   'morpheus/errors'
+  autoload :ServerError,                 'morpheus/errors'
+  autoload :InvalidResponseCode,         'morpheus/errors'
+end
+
+# Associations for application objects, typically ActiveRecord, to resource
+module Morpheus
+  module Client
+    autoload :Associations,  'morpheus/client/associations'
+    autoload :LogSubscriber, 'morpheus/client/log_subscriber'
+  end
+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'
+
+# There are some Typhoeus patches contained here.
+require 'ext/typhoeus'