axel 0.0.1

data/lib/axel/configurators/services.rb

@@ -0,0 +1,29 @@
+require 'axel/configurations/service'
+module Axel
+  module Configurators
+    class Services
+      attr_reader :services
+      def initialize
+        @services = {}.with_indifferent_access
+      end
+
+      def resources
+        services.values.collect(&:resources).inject({}.with_indifferent_access) { |hash, pair| hash.merge pair }
+      end
+
+      def add_service(service_name, url)
+        if services[service_name]
+          services[service_name].url = url if url
+          services[service_name]
+        else
+          services[service_name] = Configurations::Service.new(service_name, url)
+        end
+      end
+
+      def add_resource(service_name, resource_name, options = {})
+        service = add_service service_name, (options.delete(:service) || {})[:url]
+        service.add_resource resource_name, options
+      end
+    end
+  end
+end

data/lib/axel/controller_base.rb

@@ -0,0 +1,27 @@
+module Axel
+  class ControllerBase
+    def configured
+      should_use_api? ? api_base : proper_base
+    end
+
+    def should_use_api?
+      config.uses_rails_api? && !!api_base
+    rescue NameError
+      false
+    end
+
+    private
+
+    def api_base
+      ::ActionController::API
+    end
+
+    def proper_base
+      ::ActionController::Base
+    end
+
+    def config
+      Axel._config
+    end
+  end
+end

data/lib/axel/controller_helpers.rb

@@ -0,0 +1,209 @@
+module Axel
+  RecordNotFound = Class.new StandardError
+  module ControllerHelpers
+    extend ActiveSupport::Concern
+    included do
+      if respond_to?(:helper_method)
+        helper_method :errors,
+          :metadata,
+          :header_status,
+          :drop_meta?,
+          :format,
+          :render_nil_format,
+          :safe_json_load,
+          :xml_clean
+      end
+
+      delegate :header_status,
+        to: :errors
+
+      if respond_to?(:layout) && !ControllerBase.new.should_use_api?
+        layout "axel"
+      end
+
+      if respond_to?(:rescue_from)
+        rescue_from ForceSSL do |e|
+          drop_meta!
+          rescue_error status: :forbidden, message: "SSL is required"
+        end
+
+        rescue_from NotAuthorized do |e|
+          rescue_error status: 401, message: "User not authorized"
+        end
+
+        rescue_from Axel::RecordNotFound do |e|
+          rescue_error status: 404, message: "Record not found"
+        end
+
+        if defined?(ActiveRecord::RecordNotFound)
+          rescue_from ActiveRecord::RecordNotFound do |e|
+            rescue_error status: 404, message: "Record not found"
+          end
+        end
+
+        if defined?(ActiveModel::MassAssignmentSecurity::Error)
+          rescue_from ActiveModel::MassAssignmentSecurity::Error do |e|
+            rescue_error status: 422, message: "Unacceptable parameter being used"
+          end
+        end
+
+        if defined?(ActionController::UnknownFormat)
+          rescue_from ActionController::UnknownFormat do |e|
+            render nothing: true, status: 406, message: "Unknown Format"
+          end
+        end
+      end
+    end
+
+    module ClassMethods
+      def respond_to_json_xml
+        respond_to :json, :xml
+      end
+    end
+
+    # Public: Quick access to a set of errors we're tracking
+    # while dealing with a request
+    #
+    # Example:
+    #
+    #   errors
+    #   # => <# Errors ...>
+    #
+    # Return an object for recording errors over a request
+    def errors
+      @errors ||= Payload::Errors.new
+    end
+
+    def metadata
+      @metadata ||= Payload::Metadata.new
+    end
+
+    # Default API response when an error occurs
+    def rescue_error(options = {})
+      messages = ([options[:messages]] + [options[:message]]).flatten.compact
+      errors.new_error options[:status], *messages
+      respond_to_empty
+    end
+
+    # Public: Use for weird actions like #update where we don't want
+    # to create a whole rabl template for it. This will allow the format
+    # to fixed correctly and render a different action for you.
+    #
+    # action    - used to pick the template we're now rendering
+    #
+    # Example:
+    #
+    #   respond_with_action :show
+    #
+    def respond_with_action(action)
+      respond_with do |f|
+        f.json { render action: action }
+        f.xml { render action: action }
+      end
+    end
+    alias render_action respond_with_action
+
+    # Public: Use to respond with an empty template. Especially useful for
+    # manipulative controller actions where you don't want to have a new view,
+    # but you DO want to return our "envelope"
+    def respond_to_empty
+      respond_to do |f|
+        f.json { render nothing: true, layout: "axel", status: header_status }
+        f.xml { render nothing: true, layout: "axel", status: header_status }
+      end
+    end
+    alias render_empty respond_to_empty
+
+    # Public: Use as a before filter. Will find a resource with some automation.
+    # Find based on params.
+    #
+    # options   - Hash of options for tweaking
+    #           :finder   - Column being used for the select (:id, :user_name)
+    #           :value    - The value the column should be (an ID or Name value)
+    #
+    # Example:
+    #
+    #   PersonasController#find_resource # (with params[:id] => 1)
+    #   # => @persona # => <# Persona id: 1 #>
+    #
+    #   PersonasController#find_resource(finder: :user_id) # (with params[:user_id] => 1)
+    #   # => @persona # => <# Persona user_id: 1 #>
+    #
+    #   PersonasController#find_resource(finder: :user_id, value: 2) # (with params[:user_id] => 1)
+    #   # => @persona # => <# Persona user_id: 2 #>
+    #
+    # Return the value of the instance variable we just set
+    def find_resource(options = {})
+      resource_name = controller_name.singularize
+      resource = controller_name.classify.constantize
+      finder_column = options[:finder] || :id
+      finder_value = options[:value] || params[:id]
+      resources = resource.where(finder_column => finder_value)
+      if resources.length == 0
+        raise RecordNotFound
+      else
+        instance_variable_set "@#{resource_name}", resources.first
+      end
+    end
+
+    def query_params
+      try_strong_params request.GET
+    end
+
+    def post_params
+      try_strong_params request.POST
+    end
+
+    def object_params
+      try_strong_params post_params.fetch(object_name, post_params)
+    end
+
+    def try_strong_params(regular_params)
+      ControllerParameters.new(regular_params).params_object
+    end
+
+    def object_name
+      controller_name.singularize
+    end
+
+    def force_ssl!
+      return true unless Rails::Application.productionish?
+      if !request.ssl?
+        raise ForceSSL
+      end
+    end
+
+    def drop_meta!
+      metadata.drop!
+    end
+
+    def drop_meta?
+      metadata.drop?
+    end
+
+    def format
+      params[:format] || :json
+    end
+
+    def render_nil_format
+      {
+        json: nil,
+        xml: ""
+      }.with_indifferent_access[format]
+    end
+
+    def rabl_render(object, view)
+      Rabl.render(object, view, view_path: 'app/views', scope: self)
+    end
+
+    def safe_json_load(json)
+      json.present? ? MultiJson.load(json, mode: :null) : nil
+    end
+
+    def xml_clean(payload)
+      payload.gsub(/\<(\/)*hash\>\s{1}/, '').
+        gsub(/<\?\W*([xX][mM][lL])\W*version.*encoding.*\?>/, "").
+        strip
+    end
+  end
+end

data/lib/axel/controller_parameters.rb

@@ -0,0 +1,32 @@
+module Axel
+  class ControllerParameters
+    private
+    attr_accessor :controller_params
+
+    public
+
+    def initialize(controller_params)
+      self.controller_params = controller_params
+    end
+
+    def params_object
+      strong_params? ? params_class.new(controller_params) : controller_params
+    end
+
+    def params_class # testability
+      ActionController::Parameters
+    end
+    private :params_class
+
+    def strong_module
+      ActionController::StrongParameters
+    end
+
+    def strong_params?
+      !!(params_class && strong_module)
+    rescue
+      false
+    end
+    private :strong_params?
+  end
+end

data/lib/axel/engine.rb

@@ -0,0 +1,14 @@
+module Axel
+  class Engine < ::Rails::Engine
+    if Rails::VERSION::MAJOR == 3 && Rails::VERSION::MINOR > 0
+      isolate_namespace Axel
+    end
+    config.railties_order = [self, :main_app, :all]
+
+    initializer 'axel.application_helper' do |app|
+      ActiveSupport.on_load :action_controller do
+        helper Axel::ApplicationHelper
+      end
+    end
+  end
+end

data/lib/axel/inspector.rb

@@ -0,0 +1,91 @@
+module Axel
+  class Inspector
+    private
+    attr_writer :object
+    attr_writer :parens_params
+    attr_writer :attributes
+
+    public
+    attr_reader :object
+    attr_reader :parens_params
+    attr_reader :attributes
+
+    def initialize(object, parens_params = [], attributes = [])
+      self.object = object
+      self.parens_params = hasherize parens_params
+      self.attributes = hasherize attributes
+    end
+
+    def inspect
+      class_name.tap do |string|
+        string << "(#{display_parens})" unless parens_params.empty?
+        string << " #{display_attributes}" unless attributes.empty?
+        unless class?
+          string.prepend "#<"
+          string << ">"
+        end
+      end
+    end
+
+    def class_name
+      class? ? object.name : object.class.name
+    end
+    private :class_name
+
+    def class?
+      object.is_a?(Class)
+    end
+
+    def display_parens
+      display parens_params
+    end
+    private :display_parens
+
+    def display_attributes
+      display attributes, :show_keys
+    end
+    private :display_attributes
+
+    def display(array, show_keys = false)
+      array.collect { |key,value|
+        show_keys ? "#{key}: #{attribute_for_inspect(value)}" : attribute_for_inspect(value)
+      }.join(", ")
+    end
+    private :display
+
+    def attribute_for_inspect(value)
+      if value.is_a?(String) && value.length > 50
+        "#{value[0..50]}...".inspect
+      elsif value.is_a?(Date) || value.is_a?(Time)
+        %("#{value}")
+      else
+        value.inspect
+      end
+    end
+    private :attribute_for_inspect
+
+    def safe_send(key)
+      object.public_send(key)
+    rescue
+      nil
+    end
+    private :safe_send
+
+    def hasherize(params)
+      if params.is_a? Hash
+        params
+      elsif params.is_a? Array
+        Hash[params.map { |key|
+          begin
+            [key, safe_send(key)] if object.respond_to? key
+          rescue
+            [key, "<Error Collecting>"]
+          end
+        }.compact]
+      else
+        {}
+      end
+    end
+    private :hasherize
+  end
+end

data/lib/axel/payload/remote_error.rb

@@ -0,0 +1,14 @@
+module Axel
+  module Payload
+    class RemoteError < StandardError
+      attr_reader :remote_errors
+      def initialize(remote_errors)
+        @remote_errors = remote_errors
+      end
+
+      def to_s
+        "Failed. HTTP Status: #{remote_errors.status_code}, Messages: #{@remote_errors.messages.join('. ')}"
+      end
+    end
+  end
+end

data/lib/axel/request_options.rb

@@ -0,0 +1,26 @@
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/hash/deep_merge'
+module Axel
+  class RequestOptions
+    attr_accessor :given_options
+    attr_accessor :default_options
+
+    def initialize(default_options = {}, given_options)
+      self.default_options = (default_options || {})
+      self.given_options = (given_options || {}).with_indifferent_access
+    end
+
+    def compiled
+      default_request_options.
+        dup.
+        deep_merge!(default_options).
+        deep_merge!(given_options).
+        with_indifferent_access
+    end
+
+    def default_request_options
+      { headers: { 'Content-Type' => 'application/json' } }.with_indifferent_access
+    end
+    private :default_request_options
+  end
+end