axel 0.0.1

data/app/models/axel/router.rb

@@ -0,0 +1,119 @@
+module Axel
+  class Router
+    private
+    attr_writer :path
+    attr_writer :origin_klass
+    attr_writer :method_name
+    attr_writer :parameters
+    attr_writer :options
+
+    public
+    attr_reader :path
+    attr_reader :origin_klass
+    attr_reader :method_name
+    attr_reader :parameters
+    attr_reader :options
+
+    def initialize(klass, path, name, options = {})
+      self.path = path.to_s
+      self.origin_klass = klass
+      self.method_name = name.to_s
+      self.options = options || {}
+      extract_parameters!
+    end
+
+    def define_route
+      setup_klass_method
+      self
+    end
+
+    def route(*args)
+      route_path = build_path_with_args *args
+      route_options = extract_routed_args_options args
+      run_route route_path, route_options
+    end
+
+    # The class constant used for querying and dumping the
+    # response to
+    def klass
+      klass_from_class_option || klass_from_class_name_option || origin_klass
+    end
+    private :klass
+
+    def klass_from_class_option(class_option = options[:class])
+      class_option.respond_to?(:querier) && class_option
+    end
+    private :klass_from_class_option
+
+    def klass_from_class_name_option
+      options[:class_name].present? &&
+        klass_from_class_option(options[:class_name].to_s.camelize.safe_constantize)
+    end
+    private :klass_from_class_name_option
+
+    def run_route(route_path, route_options)
+      klass.querier.without_default_path.at_path(route_path).request_options route_options
+    end
+    private :run_route
+
+    def extract_routed_args_options(args)
+      hash_options = arity > 0 && args.first.is_a?(Hash)
+      first_option = hash_options ? 1 : arity - 1
+      args[first_option..-1].to_a.extract_options!
+    end
+    private :extract_routed_args_options
+
+    # Sets up a new static method on the class that defines the
+    # route. The method actually delegates to our router with the
+    # method's name.
+    def setup_klass_method
+      origin_klass.define_singleton_method method_name do |*args|
+        self.routes[__method__].route *args
+      end
+    end
+    private :setup_klass_method
+
+    def extract_parameters!
+      if parameters.nil?
+        self.parameters = path.
+          split("/").
+          select { |s| s.start_with?(":") }.
+          map { |s| s[1..-1] }
+      else
+        true
+      end
+    end
+    private :extract_parameters!
+
+    def arity
+      parameters.count
+    end
+    private :arity
+
+    def build_path_with_args(*args)
+      param_options = args.first.is_a?(Hash) ? handle_hash(args.first) : handle_splat(args)
+      path.split("/").collect { |piece|
+        piece.match(/^:/) ? param_options[piece.to_s[1..-1]] : piece
+      }.join "/"
+    end
+    private :build_path_with_args
+
+    def handle_hash(hash)
+      hash = hash.with_indifferent_access
+      parameters.collect { |param_name| { param_name => hash[param_name] } }.
+        inject({}) { |new_hash, found| new_hash.merge found }.
+        with_indifferent_access
+    end
+    private :handle_hash
+
+    def handle_splat(splat)
+      values = splat[0...arity].map(&:to_s)
+      while values.size < arity do
+        values << ""
+      end
+      Hash[parameters.zip(values)].
+        with_indifferent_access
+    end
+    private :handle_splat
+  end
+end

data/app/models/axel/service_resource.rb

@@ -0,0 +1,4 @@
+module Axel
+  module ServiceResource
+  end
+end

data/app/models/axel/service_resource/associations.rb

@@ -0,0 +1,80 @@
+module Axel
+  module ServiceResource
+    module Associations
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      def method_missing(method_name, *args, &block)
+        if self.class.associations_respond_to?(method_name)
+          cache_association method_name do
+            self.class.association(method_name).run_method(self, method_name, *args, &block)
+          end
+        else
+          super
+        end
+      end
+
+      def respond_to?(method_name, include_private = false)
+        self.class.associations_respond_to?(method_name) || super
+      end
+
+      def reset_association_cache!
+        @association_cache = {}
+      end
+
+      def association_cache
+        @assocation_cache ||= {}
+      end
+      private :association_cache
+
+      def cache_association(name, &block)
+        association_cache[name] ||= block.call
+      end
+      private :cache_association
+
+      module ClassMethods
+        def belongs_to(relation_name, options = {})
+           belongs_to_associations[relation_name] =
+             Axel::Associations::BelongsTo.new(self, relation_name, options)
+        end
+
+        def has_many(relation_name, options = {})
+           has_many_associations[relation_name] =
+             Axel::Associations::HasMany.new(self, relation_name, options)
+        end
+
+        def has_one(relation_name, options = {})
+           has_one_associations[relation_name] =
+             Axel::Associations::HasOne.new(self, relation_name, options)
+        end
+
+        def associations_respond_to?(method_name)
+          !!association(method_name)
+        end
+
+        def association(method_name)
+          associations.values.find { |association| association.handles_method? method_name }
+        end
+
+        private
+
+        def associations
+          belongs_to_associations.merge(has_many_associations).merge(has_one_associations)
+        end
+
+        def has_one_associations
+          @__has_one_associations ||= {}.with_indifferent_access
+        end
+
+        def belongs_to_associations
+          @__belongs_to_associations ||= {}.with_indifferent_access
+        end
+
+        def has_many_associations
+          @__has_many_associations ||= {}.with_indifferent_access
+        end
+      end
+    end
+  end
+end

data/app/models/axel/service_resource/attributes.rb

@@ -0,0 +1,23 @@
+module Axel
+  module ServiceResource
+    UnknownAttributeError = Class.new(StandardError)
+    module Attributes
+      def assign_attributes(new_attributes)
+        return unless new_attributes
+
+        new_attributes.each do |k, v|
+          if respond_to?("#{k}=")
+            send("#{k}=", v)
+          else
+            raise(UnknownAttributeError, "unknown attribute: #{k}")
+          end
+        end
+      end
+
+      def update_attributes(attributes)
+        assign_attributes(attributes)
+        save
+      end
+    end
+  end
+end

data/app/models/axel/service_resource/automatic_resource.rb

@@ -0,0 +1,23 @@
+module Axel
+  module ServiceResource
+    module AutomaticResource
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        # Name the resource. Used if you call your class Foo but the API
+        # Proxy know it as "Bar". This will resolve that configuration
+        # disconnect
+        def resource_name(name = nil)
+          @_resource_name = name.to_s.underscore.pluralize if name
+          @_resource_name || self.name.split("::").last.underscore.pluralize
+        end
+
+        # Resource object that holds configuration information about the service
+        # and path
+        def resource
+          Axel.resources[resource_name]
+        end
+      end
+    end
+  end
+end

data/app/models/axel/service_resource/base.rb

@@ -0,0 +1,47 @@
+module Axel
+  module ServiceResource
+    class Base < Typhoid::Resource
+      extend Axel::CascadableAttribute
+      include Inspects
+      include Queries
+      include Routes
+      include AutomaticResource
+      include TyphoidExtensions
+      include Requesters
+      include Associations
+      include Attributes
+
+      # Standard fields that should be on almost all objects
+      # coming in
+      field :id
+      field :uri
+
+      delegate :paged?,
+        :total_pages,
+        to: :metadata
+
+      def initialize(params = {})
+        super (params || {}).with_indifferent_access
+      end
+
+      # Grab the classlevel block that defines parameters to pass with
+      # a reload and evaluate that within this instance
+      def reload_params
+        {}
+      end
+      private :reload_params
+
+      def reload
+        reset_association_cache!
+        request_and_load do
+          self.class.manual_request :get, reload_uri, reload_params
+        end
+      end
+
+      def reload_uri
+        request_uri
+      end
+      private :reload_uri
+    end
+  end
+end

data/app/models/axel/service_resource/builder.rb

@@ -0,0 +1,40 @@
+module Axel
+  module ServiceResource
+    class Builder < Typhoid::Builder
+      def result
+        enveloped? ? parsed_body["result"] : parsed_body
+      end
+
+      def enveloped?
+        parsed_body.respond_to?("has_key?") && parsed_body.has_key?("metadata") && parsed_body.has_key?("result")
+      end
+
+      def array?
+        result.is_a?(Array)
+      end
+
+      def singular?
+        !array?
+      end
+
+      def metadata
+        parsed_body["metadata"] if enveloped?
+      end
+
+      def errors
+        parsed_body["errors"] if enveloped?
+      end
+
+      def compiled_payloads
+        Array(result).map { |res| { "metadata" => metadata, "errors" => errors, "result" => res } }
+      end
+
+      def build_array
+        compiled_payloads.collect { |single|
+          build_from_klass(single)
+        }
+      end
+      private :build_array
+    end
+  end
+end

data/app/models/axel/service_resource/inspects.rb

@@ -0,0 +1,17 @@
+module Axel
+  module ServiceResource
+    module Inspects
+      extend ActiveSupport::Concern
+
+      def inspect
+        Inspector.new(self, [:request_uri], [:attributes, :metadata, :remote_errors]).inspect
+      end
+
+      module ClassMethods
+        def inspect
+          Inspector.new(self, [:request_uri]).inspect
+        end
+      end
+    end
+  end
+end

data/app/models/axel/service_resource/payload_parser.rb

@@ -0,0 +1,46 @@
+module Axel
+  module ServiceResource
+    class PayloadParser
+      def initialize(payload)
+        self.payload = ActiveSupport::HashWithIndifferentAccess.new payload
+      end
+
+      def parsed
+        [payload, result, metadata, remote_errors]
+      end
+
+      private
+      attr_accessor :payload
+
+      def metadata
+        Payload::Metadata.new bare_metadata
+      end
+
+      def remote_errors
+        Payload::Errors.new bare_remote_errors
+      end
+
+      def result
+        (payload[:result] || backup_result ).with_indifferent_access
+      end
+
+      def bare_metadata
+        (payload[:metadata] || {} ).with_indifferent_access
+      end
+
+      def bare_remote_errors
+        raw = payload[:errors] || payload[:error] || {}
+        raw = { messages: raw } if raw.is_a?(Array)
+        raw.with_indifferent_access
+      end
+
+      def payload_is_enveloped?
+        payload.is_a?(Hash) && payload.has_key?(:metadata) && payload.has_key?(:result)
+      end
+
+      def backup_result
+        payload_is_enveloped? ? {} : payload
+      end
+    end
+  end
+end

data/app/models/axel/service_resource/queries.rb

@@ -0,0 +1,25 @@
+Axel::Querier # Autoloading
+module Axel
+  module ServiceResource
+    module Queries
+      extend ActiveSupport::Concern
+
+      included do
+        # Use Query methods from a Querier instance
+        class << self
+          delegate *Axel::Querier.query_methods, to: :querier
+        end
+      end
+
+      module ClassMethods
+        # Entry point to querying methods like:
+        #   #where
+        #   #path
+        #   #uri
+        def querier
+          Axel::Querier.new self
+        end
+      end
+    end
+  end
+end

data/app/models/axel/service_resource/requesters.rb

@@ -0,0 +1,49 @@
+module Axel
+  module ServiceResource
+    module Requesters
+      extend ActiveSupport::Concern
+
+      def default_request_options;end
+
+      def retrieve_default_request_options(options)
+        RequestOptions.new(compiled_default_request_options, options).compiled
+      end
+      private :retrieve_default_request_options
+
+      def compiled_default_request_options
+        (self.class.default_request_options ||{}).merge(default_request_options || {})
+      end
+      private :compiled_default_request_options
+
+      module ClassMethods
+        def default_request_options;end
+
+        def retrieve_default_request_options(options)
+          RequestOptions.new(default_request_options, options).compiled
+        end
+
+        # Make a simple request and get a response back. Will build the
+        # response into this object
+        #
+        # For options see Typhoeus::Request
+        # args can be read like this: *paths, options = {}
+        def request(uri, *args)
+          options = args.extract_options!
+          build_request(uri_join(uri, *args), retrieve_default_request_options(options)).run
+        end
+
+        # Make a request, but use the default request_uri for this object
+        def from_base(*args)
+          request request_uri, *args
+        end
+
+        # Resource endpoint for this API
+        #
+        #   base_url/organizations/1
+        def find(id, params = {})
+          from_base id, params
+        end
+      end
+    end
+  end
+end