axel 0.0.1

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

@@ -0,0 +1,64 @@
+module Axel
+  module Associations
+    class Base
+      attr_accessor :model
+      attr_accessor :relation_name
+      attr_accessor :options
+
+      def initialize(model, relation_name, options)
+        self.model = model
+        self.relation_name = relation_name.to_s
+        self.options = options || {}
+      end
+
+      def handles_method?(method_name)
+        matchers.any? { |matcher| method_name.to_s.match(matcher) }
+      end
+
+      def run_method(instance, method_name, *args, &block)
+        if included?
+          included_getter(instance, *args, &block)
+        else
+          method_chooser(method_name)[instance, *args, &block]
+        end
+      end
+
+      private
+
+      def included?
+        !!options[:included]
+      end
+
+      def build_klass
+        options[:class] || relation_name_klass
+      end
+
+      def premodule
+        model.name.split("::")[0..-2].join("::")
+      end
+
+      def relation_name_klass
+        "#{premodule}::#{relation_name.to_s.singularize.classify}".safe_constantize
+      end
+
+      def matcher_map
+        {
+          /\A#{relation_name}\z/ => :getter
+        }
+      end
+
+      def matchers
+        matcher_map.keys
+      end
+
+      def method_chooser(method_name)
+        name = matcher_map[matchers.find { |matcher| method_name.to_s.match matcher }]
+        if name
+          method(name)
+        else
+          raise NoMethodError, "Could not find an association method for `#{method_name}'"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Axel
+  module Associations
+    class BelongsTo < Base
+
+      private
+
+      def included_getter(instance, *args, &block)
+        relation_attributes = (instance.try(:attributes) || {})[relation_name]
+        build_klass.new(relation_attributes) if relation_attributes
+      end
+
+      def find_nested?
+        !!options[:find_nested]
+      end
+
+      def getter(instance, *args, &block)
+        request_options = args.extract_options!
+        if find_nested?
+          build_klass
+            .querier
+            .without_default_path
+            .at_path(route_path(instance))
+            .request_options(request_options)
+            .first
+        else
+          build_klass.find(instance.public_send(association_id_method), request_options)
+        end
+      end
+
+      def route_path(instance)
+        [URI(instance.request_uri).path, association_path(instance)].join("/")
+      end
+
+      def association_path(instance) # needs to be belongs_to, some looks has_many
+        "#{relation_name.to_s.pluralize}/#{instance.public_send(association_id_method)}"
+      end
+
+      def association_id_method
+        options[:id_attribute] || "#{relation_name.to_s.singularize.underscore}_id"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Axel
+  module Associations
+    class HasMany < Base
+
+      private
+
+      def included_getter(instance, *args, &block)
+        Array(instance.attributes[relation_name]).map { |attributes| build_klass.new(attributes) }
+      end
+
+      def getter(instance, *args, &block)
+        request_options = args.extract_options!
+        build_klass
+          .querier
+          .without_default_path
+          .at_path(route_path(instance))
+          .request_options request_options
+      end
+
+      def route_path(instance)
+        [URI(instance.request_uri).path, association_path].join("/")
+      end
+
+      def association_path # needs to be belongs_to, some looks has_many
+        options[:suffix_path].present? && options[:suffix_path] || relation_name.to_s
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Axel
+  module Associations
+    class HasOne < Base
+
+      private
+
+      def included_getter(instance, *args, &block)
+        Array(instance.attributes[relation_name]).map { |attributes| build_klass.new(attributes) }.first
+      end
+
+      def getter(instance, *args, &block)
+        request_options = args.extract_options!
+        build_klass
+          .querier
+          .without_default_path
+          .at_path(route_path(instance))
+          .request_options(request_options)
+          .first
+      end
+
+      def route_path(instance)
+        [URI(instance.request_uri).path, association_path].join("/")
+      end
+
+      def association_path # needs to be belongs_to, some looks has_many
+        options[:suffix_path].present? && options[:suffix_path] || relation_name.to_s
+      end
+    end
+  end
+end

data/app/models/axel/payload.rb

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

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

@@ -0,0 +1,107 @@
+module Axel
+  module Payload
+    class Base
+      attr_reader :attributes
+
+      delegate :fetch, to: :attributes
+
+      def self.root_node(name = nil)
+        @root_node = name if name
+        @root_node
+      end
+
+      def self.attribute(name, options = {})
+        attribute_defaults[name.to_s.to_sym] = options[:default]
+        visibility_read = options.has_key?(:read) ? options[:read] : true
+        visibility_write = options.has_key?(:write) ? options[:write] : true
+        if visibility_read
+          define_method name do
+            @attributes[name]
+          end
+          if %w[public private protected].include? visibility_read.to_s
+            send visibility_read, name
+          end
+        end
+
+        if visibility_write
+          define_method "#{name}=" do |new_value|
+            @attributes[name] = new_value
+          end
+          if %w[public private protected].include? visibility_write.to_s
+            send visibility_write, name
+          end
+        end
+      end
+
+      def self.attribute_defaults
+        @attribute_defaults ||= {}
+      end
+
+      def reset!
+        @attributes = {}
+        apply_defaults
+        self
+      end
+
+      def initialize(params = {})
+        apply_defaults
+        params = params.is_a?(Hash) ? params : {}
+        @attributes.merge! params
+      end
+
+      def []=(key, value)
+        @attributes[key] = decode(value)
+      end
+
+      def [](key)
+        @attributes[key]
+      end
+
+      def display
+        drop? ? {} : @attributes
+      end
+
+      def display?
+        true
+      end
+
+      def drop?
+        !!@drop
+      end
+
+      def drop!
+        @drop = true
+      end
+
+      def to_json
+        display? ? display.to_json : ""
+      end
+
+      def to_xml
+        display? ? display.to_xml(dasherize: false, skip_instruct: true, root: self.class.root_node) : ""
+      end
+
+      def apply_defaults
+        @attributes = self.class.attribute_defaults.with_indifferent_access
+      end
+      private :apply_defaults
+
+      def decode(input)
+        if input.is_a? String
+          begin
+            ActiveSupport::JSON.decode input
+          rescue MultiJson::DecodeError, JSON::ParserError
+            begin
+              Hash.from_xml input
+            rescue REXML::ParseException
+              input
+            end
+          end
+        else
+          input
+        end
+      end
+      private :decode
+    end
+  end
+end

data/app/models/axel/payload/errors.rb

@@ -0,0 +1,62 @@
+module Axel
+  module Payload
+    class Errors < Base
+      root_node :error
+      attribute :messages, default: []
+      attribute :status, default: 200, read: :private
+      SUCCESS_CODES = [200, 201, 202, 204]
+
+      def initialize(params = {})
+        super
+        @suppress_response_codes = !!@attributes[:suppress_response_codes]
+      end
+
+      def exception
+        RemoteError.new(self) unless success?
+      end
+
+      def success?
+        SUCCESS_CODES.include?(status_code.to_i) && messages.empty?
+      end
+
+      def messages=(messages)
+        @attributes[:messages] = [messages].flatten.compact
+      end
+
+      def status=(status)
+        @attributes[:status] = status
+      end
+
+      def header_status
+        suppress_response_codes? ? 200 : status_code
+      end
+
+      def <<(message)
+        @attributes[:messages] << message
+      end
+
+      def display
+        drop? ? {} : { status: status_code, messages: messages }
+      end
+
+      def display?
+        !SUCCESS_CODES.include?(status_code.to_i) || messages.present?
+      end
+
+      def new_error(status, *messages)
+        self.status = status if status
+        self.messages = self.messages + messages
+      end
+
+      def status_code
+        status ? Rack::Utils.status_code(status) : 200
+      end
+
+      private
+
+      def suppress_response_codes?
+        @suppress_response_codes
+      end
+    end
+  end
+end

data/app/models/axel/payload/metadata.rb

@@ -0,0 +1,57 @@
+module Axel
+  module Payload
+    class Metadata < Base
+      root_node :metadata
+
+      def paged?
+        total_pages > 1
+      end
+
+      def total_pages
+        raw = pagination_settings["total_pages"].to_i
+        raw == 0 ? 1 : raw
+      end
+
+      def merge!(other_object)
+        tap do
+          @attributes.merge! mergeable_from(other_object)
+        end
+      end
+
+      def merge(other_object)
+        #self.class.new(attributes).tap do |c|
+        dup.tap do |c|
+          c.merge!(mergeable_from(other_object))
+        end
+      end
+
+      def dup(*args)
+        super.tap do |d|
+          d.instance_variable_set "@attributes", @attributes.clone
+        end
+      end
+
+      def clone(*args)
+        super.tap do |c|
+          c.instance_variable_set "@attributes", @attributes.clone
+        end
+      end
+
+      def pagination_settings
+        fetch("pagination", {})
+      end
+      private :pagination_settings
+
+      def mergeable_from(object)
+        if object.respond_to?(:attributes) && object.attributes.is_a?(Hash)
+          object.attributes
+        elsif object.is_a? Hash
+          object
+        else
+          {} # unmergeable, should think about erroring
+        end
+      end
+      private :mergeable_from
+    end
+  end
+end

data/app/models/axel/querier.rb

@@ -0,0 +1,166 @@
+module Axel
+  class Querier
+    private
+    attr_writer :klass
+    attr_writer :loaded
+    attr_reader :records
+
+    protected
+    attr_accessor :where_values
+    attr_accessor :manual_uri
+    attr_accessor :extra_paths
+    attr_accessor :request_option_values
+    attr_accessor :paged
+    attr_writer :records
+
+    public
+    attr_reader :klass
+    attr_reader :loaded
+
+    alias loaded? loaded
+    alias paged? paged
+
+    def self.query_methods
+      [
+        :all,
+        :none,
+        :where,
+        :uri,
+        :to_a,
+        :at_path,
+        :request_options,
+        :without_default_path,
+        :paged
+      ]
+    end
+
+    def initialize(klass)
+      self.klass = klass
+      self.records = []
+      self.extra_paths = []
+      self.loaded = false
+      self.where_values = {}.with_indifferent_access
+      self.request_option_values = {}.with_indifferent_access
+    end
+
+    def paged
+      query = clone
+      query.paged = true
+      query
+    end
+
+    def at_path(*paths)
+      return self if paths.blank?
+      query = clone
+      query.extra_paths += paths
+      query
+    end
+
+    # "http://user-service.dev"
+    def uri(base_url)
+      return self if base_url.blank?
+      query = clone
+      query.manual_uri = base_url.to_s
+      query
+    end
+
+    def where(params = {})
+      return self if params.blank? || !params.is_a?(Hash)
+      query = clone
+      query.request_option_values.deep_merge! params: params
+      query
+    end
+
+    def request_options(params = {})
+      return self if params.blank? || !params.is_a?(Hash)
+      query = clone
+      query.request_option_values.deep_merge! params
+      query
+    end
+    alias_method :all, :request_options
+
+    def none
+      query = clone
+      query.loaded!
+      query.records = []
+      query
+    end
+
+    def without_default_path
+      query = clone
+      query.manual_uri = klass.site
+      query
+    end
+
+    def reload
+      reset
+      self
+    end
+
+    def to_a
+      Array(loaded? ? records : self.records = run_requests)
+    end
+
+    def inspect
+      to_a.inspect
+    end
+
+    def loaded!
+      self.loaded = true
+    end
+    protected :loaded!
+
+    def reset
+      self.loaded = false
+      self.records = []
+      self
+    end
+    private :reset
+
+    def request_uri
+      Uri.new((manual_uri || klass.request_uri), *extra_paths).to_s
+    end
+    private :request_uri
+
+    def retrieve_request_options
+      klass.retrieve_default_request_options request_option_values
+    end
+    private :retrieve_request_options
+
+    def run_requests
+      loaded!
+      execute_request_on_klass
+    end
+    private :run_requests
+
+    def execute_request_on_klass
+      initial = klass.request(request_uri, retrieve_request_options)
+      return initial unless paged?
+
+      single = initial.first
+      return initial if single.blank? || !single.paged?
+
+      (2..single.total_pages).reduce(initial) do |memo, page|
+        paged_options = retrieve_request_options
+          .stringify_keys
+          .deep_merge "params" => { "page" => page }
+        memo + klass.request(request_uri, paged_options)
+      end
+    end
+    private :execute_request_on_klass
+
+    def respond_to?(method, include_private = false)
+      super || Array.public_method_defined?(method) || klass.routes.has_key?(method)
+    end
+
+    def method_missing(method, *args, &block)
+      if Array.method_defined?(method)
+        to_a.public_send(method, *args, &block)
+      elsif klass.routes.has_key? method
+        klass.public_send method, *args
+      else
+        super
+      end
+    end
+  end
+end