apidiesel 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 44ad9f9bd05bf14034e7aeffbe7b261121e6bd36
+  data.tar.gz: 63cc65536628b44a8595f9d124bda911db8c8d9e
+SHA512:
+  metadata.gz: 2e91ff208c1b6782c7cc1fadb1a2b6dc1ded0dc8e86d701fc333538bea818ce2f0affdf641a8dffa6dc0211028967c8c49b9efc528e58a56f1698b5bd04ab6ca
+  data.tar.gz: af65805859d9cbe02578c7f1dcbd0cd31724a58bee865b06414f95d6fb21043c9028caece1033e2809c1a0c9ce87eebe0fbace5c577543ab2ab3c3527866c78c

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+apidiesel.sublime-project
+apidiesel.sublime-workspace

data/.ruby-gemset

@@ -0,0 +1 @@
+apidiesel

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.2.3

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in apidiesel.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Jan-Christian Föh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,36 @@
+# Apidiesel
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/apidiesel`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'apidiesel'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install apidiesel
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/apidiesel.
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/apidiesel.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'apidiesel/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "apidiesel"
+  spec.version       = Apidiesel::VERSION
+  spec.authors       = ["Jan-Christian Foeh"]
+  spec.email         = ["jan@programmanstalt.de"]
+
+  spec.summary       = %q{Build API clients through an expressive DSL}
+  spec.homepage      = "https://github.com/janfoeh/apidiesel"
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency 'activesupport', '>= 4.2.0'
+  spec.add_runtime_dependency 'httpi', '>= 2.4.1'
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "apidiesel"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/apidiesel/action.rb

@@ -0,0 +1,185 @@
+module Apidiesel
+
+  # An abstract base class for API endpoints.
+  class Action
+    extend Dsl
+
+    # accessors for class instance variables
+    # (class-level variables, not shared with subclasses)
+    class << self
+
+      # Hash for storing validation closures. These closures are called with the request
+      # parameters before the request is made and have the opportunity to check and modify them.
+      def parameter_validations
+        @parameter_validations ||= []
+      end
+
+      # Hash for storing filter closures. These closures are called with the received data
+      # after a request is made and have the opportunity to modify or check it before the
+      # data is returned
+      def response_filters
+        @response_filters ||= []
+      end
+
+      def response_formatters
+        @response_formatters ||= []
+      end
+
+      def format_parameters(&block)
+        @parameter_formatter = block
+      end
+
+      def parameter_formatter
+        @parameter_formatter
+      end
+
+      # Combined getter/setter for this actions' endpoint
+      #
+      # @param [String] value
+      def endpoint(value = nil)
+        if value
+          @endpoint = value
+        else
+          @endpoint
+        end
+      end
+
+      # Combined getter/setter for this actions URL
+      #
+      # Falls back to the Api setting if blank.
+      #
+      # @param [String] value
+      def url(value = nil)
+        if value
+          @url = value
+        else
+          @url
+        end
+      end
+
+      # Combined getter/setter for the HTTP method used
+      #
+      # Falls back to the Api setting if blank.
+      #
+      # @param [String] value
+      def http_method(value = nil)
+        if value
+          @http_method = value
+        else
+          @http_method
+        end
+      end
+    end
+
+    attr_accessor :api
+
+    # Hook method that is called by {Apidiesel::Api} to register this Action on itself.
+    #
+    # Example: when {Apidiesel::Api} calls this method inherited on {Apidiesel::Actions::Foo},
+    # it itself gains a `Apidiesel::Api#foo` instance method to instantiate and call the Foo action.
+    #
+    # Executed in {Apidiesel::Api} through
+    #
+    #   Apidiesel::Actions.constants.each do |action|
+    #     Apidiesel::Actions.const_get(action).register(self)
+    #   end
+    def self.register(caller)
+      caller.class_eval <<-EOT
+        def #{name_as_method}(*args)
+          execute_request(#{name}, *args)
+        end
+      EOT
+    end
+
+      private
+
+    # Returns current class name formatted for use as a method name
+    #
+    # Example: {Apidiesel::Actions::Foo} will return `foo`
+    #
+    # @return [String] the demodulized, underscored name of the current Class
+    def self.name_as_method
+      ::ActiveSupport::Inflector.underscore( ::ActiveSupport::Inflector.demodulize(self.name) )
+    end
+
+      public
+
+    # @param [Apidiesel::Api] api A reference to the parent Api object
+    def initialize(api)
+      @api = api
+    end
+
+    # Getter/setter for the parameters to be used for creating the API request. Prefilled
+    # with the `op` action key.
+    #
+    # @return [Hash]
+    def parameters
+      @parameters ||= {}
+    end
+
+    def endpoint
+      self.class.endpoint
+    end
+
+    def url
+      self.class.url || @api.class.url
+    end
+
+    def http_method
+      self.class.http_method || @api.class.http_method
+    end
+
+    # Performs the action-specific input validations on `*args` according to the actions
+    # `expects` block, executes the API request and prepares the data according to the
+    # actions `responds_with` block.
+    #
+    # @param [Hash] *args see specific, non-abstract `Apidiesel::Action`
+    # @return [Apidiesel::Request]
+    def build_request(*args)
+      args = args && args.first.is_a?(Hash) ? args.first : {}
+
+      params = {}
+
+      self.class.parameter_validations.each do |validation|
+        validation.call(args, params)
+      end
+
+      if self.class.parameter_formatter
+        params = self.class.parameter_formatter.call(params)
+      end
+
+      Apidiesel::Request.new action: self, parameters: params
+    end
+
+    def process_response(response_hash)
+      processed_result = {}
+
+      response_hash.symbolize_keys!
+
+      if self.class.response_filters.none? && self.class.response_formatters.none?
+        return response_hash
+      end
+
+      self.class.response_filters.each do |filter|
+        response_hash = filter.call(response_hash)
+      end
+
+      self.class.response_formatters.each do |filter|
+        processed_result = filter.call(response_hash, processed_result)
+      end
+
+      processed_result
+    end
+
+      protected
+
+    # @return [Hash] Apidiesel configuration options
+    def config
+      Apidiesel::CONFIG[environment]
+    end
+
+    def logger
+      @api.logger
+    end
+  end
+end

data/lib/apidiesel/api.rb

@@ -0,0 +1,156 @@
+module Apidiesel
+
+  # This is the abstract main interface class for the Apidiesel gem. It is meant to be
+  # inherited from:
+  #
+  #   module MyApi
+  #     class Api < Apidiesel::Api
+  #     end
+  #   end
+  #
+  # Apidiesel expects there to be an `Actions` namespace alongside the same scope,
+  # in which it can find the individual endpoint definitions for this API:
+  #
+  #   module MyApi
+  #     class Api < Apidiesel::Api
+  #     end
+  #
+  #     module Actions
+  #       class Action1; end
+  #       class Action2; end
+  #     end
+  #   end
+  #
+  #   # Registers endpoints Action1 and Action2
+  #   MyApi::Api.register_actions
+  #
+  class Api
+    class << self
+      def request_handlers
+        @request_handlers ||= []
+      end
+
+      def response_handlers
+        @response_handlers ||= []
+      end
+
+      def exception_handlers
+        @exception_handlers ||= []
+      end
+
+      def config(key = nil, value = nil)
+        @config ||= {}
+
+        if key && value
+          @config[key] = value
+        else
+          @config
+        end
+      end
+
+      # Combined getter/setter for this actions URL
+      #
+      # Falls back to the Api setting if blank.
+      #
+      # @param [String] value
+      def url(base_url = nil)
+        if base_url
+          config[:url] = base_url
+        else
+          config[:url]
+        end
+      end
+
+      # Combined getter/setter for the HTTP method used
+      #
+      # Falls back to the Api setting if blank.
+      #
+      # @param [String] value
+      def http_method(value = nil)
+        if value
+          config[:http_method] = value
+        else
+          config[:http_method]
+        end
+      end
+
+      # Registers a handler for requests and/or responses
+      #
+      # @param [Class] klass
+
+      def use(klass, *args, &block)
+        request_handler   = "#{klass.name}::RequestHandler".safe_constantize
+        response_handler  = "#{klass.name}::ResponseHandler".safe_constantize
+        exception_handler = "#{klass.name}::ExceptionHandler".safe_constantize
+
+        request_handlers   << request_handler.new(*args, &block) if request_handler
+        response_handlers  << response_handler.new(*args, &block) if response_handler
+        exception_handlers << exception_handler.new(*args, &block) if exception_handler
+      end
+
+      # Registers the individual API endpoint definitions
+      def register_actions
+        namespace = "#{self.name.deconstantize}::Actions".safe_constantize
+
+        namespace.constants.each do |action|
+          namespace.const_get(action).register(self)
+        end
+      end
+
+      def logger(logger = nil)
+        if logger
+          @logger = logger
+        else
+          @logger
+        end
+      end
+    end
+
+    # @param [Hash] *args
+    def initialize(*args)
+      @config = args.extract_options!.reverse_merge(self.class.config)
+    end
+
+    def logger
+      self.class.logger
+    end
+
+      protected
+
+    def execute_request(action_klass, *args)
+      request = action_klass.new(self).build_request(*args)
+
+      self.class.request_handlers.each do |handler|
+        request = handler.run(request, @config)
+        break if request.response_body.present?
+      end
+
+      unless request.response_body.present?
+        raise "All request handlers failed to deliver a response"
+      end
+
+      self.class.response_handlers.each do |handler|
+        request = handler.run(request, @config)
+      end
+
+      response_handler_klasses =
+        self.class.response_handlers.collect { |handler| handler.class.name.to_s.demodulize }
+
+      # Execute the actions' `responds_with` block automatically, unless
+      # the handler has been included manually in order to control the
+      # order in which the handlers are run
+      unless response_handler_klasses.include?('ActionResponseProcessor')
+        request.process_response
+      end
+
+      request
+    rescue => e
+      self.class.exception_handlers.each do |handler|
+        request = handler.run(e, request, @config)
+      end
+
+      raise e
+    end
+
+  end
+end

data/lib/apidiesel/dsl.rb

@@ -0,0 +1,286 @@
+module Apidiesel
+  module Dsl
+    # Defines the input parameters expected for this API action.
+    #
+    # @example
+    #   expects do
+    #     string :query
+    #     integer :per_page, :optional => true, :default => 10
+    #   end
+    #
+    # See the {Apidiesel::Dsl::ExpectationBuilder ExpectationBuilder} instance methods
+    # for more information on what to use within `expect`.
+    #
+    # @macro [attach] expects
+    #   @yield [Apidiesel::Dsl::ExpectationBuilder]
+    def expects(&block)
+      builder = ExpectationBuilder.new
+      builder.instance_eval(&block)
+      parameter_validations.concat builder.parameter_validations
+    end
+
+    # Defines the expected content and format of the response for this API action.
+    #
+    # @example
+    #   responds_with do
+    #     string :user_id
+    #   end
+    #
+    # See the {Apidiesel::Dsl::FilterBuilder FilterBuilder} instance methods
+    # for more information on what to use within `responds_with`.
+    #
+    # @macro [attach] responds_with
+    #   @yield [Apidiesel::Dsl::FilterBuilder]
+    def responds_with(&block)
+      builder = FilterBuilder.new
+      builder.instance_eval(&block)
+      response_filters.concat builder.response_filters
+      response_formatters.concat builder.response_formatters
+    end
+
+    # ExpectationBuilder defines the methods available within an `expects` block
+    # when defining an API action.
+    class ExpectationBuilder
+      attr_accessor :parameter_validations
+
+      def initialize
+        @parameter_validations  = []
+      end
+
+      # Defines a string parameter.
+      #
+      # @example
+      #   expects do
+      #     string :email, :submitted_as => :username
+      #     string :value1, :optional_if_present => :value2
+      #     string :value2, :optional_if_present => :value1
+      #   end
+      #
+      #   # This action expects to be given an 'email', which is sent to the API as 'username',
+      #   # and requires either a 'value1', a 'value2' or both to be present.
+      #
+      # @param [Symbol] param_name name of the parameter
+      # @param [Hash] *args
+      # @option *args [Boolean] :optional (false) defines whether this parameter may be omitted
+      # @option *args [Symbol] :optional_if_present param_name is optional, if the parameter given here is present instead
+      # @option *args [Symbol] :submitted_as submit param_name to the API under the name given here
+      # @option *args [Object] :default a default parameter to be set when no value is specified
+      # @option *args [Enumerable] :allowed_values only accept the values in this Enumerable.
+      #                             If Enumerable is a Hash, use the hash values to define what is actually
+      #                             sent to the server. Example: `:allowed_values => {:foo => "f"}` allows
+      #                             the value ':foo', but sends it as 'f'
+      def string(param_name, *args)
+        validation_builder(:to_s, param_name, *args)
+      end
+
+      # Defines an integer parameter.
+      #
+      # @example
+      #   expects do
+      #     integer :per_page, :optional => true
+      #   end
+      #
+      # @param (see #string)
+      # @option (see #string)
+      def integer(param_name, *args)
+        validation_builder(:to_i, param_name, *args)
+      end
+
+      # Defines a boolean parameter.
+      #
+      # FIXME: sensible duck typing check
+      #
+      # @example
+      #   expects do
+      #     boolean :per_page, :optional => true
+      #   end
+      #
+      # @param (see #string)
+      # @option (see #string)
+      def boolean(param_name, *args)
+        validation_builder(:to_s, param_name, *args)
+      end
+
+        protected
+
+      def validation_builder(duck_typing_check, param_name, *args)
+        options = args.extract_options!
+
+        parameter_validations << lambda do |given_params, processed_params|
+          if options[:default]
+            given_params[param_name] ||= options[:default]
+          end
+
+          if options.has_key?(:optional_if_present)
+            options[:optional] = true unless given_params[ options[:optional_if_present] ].blank?
+          end
+
+          unless options.has_key?(:optional) && options[:optional] == true
+            raise Apidiesel::InputError, "missing arg: #{param_name} - options: #{options.inspect}" unless given_params.has_key?(param_name) && !given_params[param_name].blank?
+            raise Apidiesel::InputError, "invalid arg #{param_name}: must respond to #{duck_typing_check}" unless given_params[param_name].respond_to?(duck_typing_check)
+          end
+
+          if options.has_key?(:allowed_values) && !given_params[param_name].blank?
+            unless options[:allowed_values].include?(given_params[param_name])
+              raise Apidiesel::InputError, "value '#{given_params[param_name]}' is not a valid value for #{param_name}"
+            end
+
+            if options[:allowed_values].is_a? Hash
+              given_params[param_name] = options[:allowed_values][ given_params[param_name] ]
+            end
+          end
+
+          if options[:submitted_as]
+            processed_params[ options[:submitted_as] ] = given_params[param_name]
+          else
+            processed_params[param_name] = given_params[param_name]
+          end
+        end
+      end
+    end
+
+    # FilterBuilder defines the methods available within an `responds_with` block
+    # when defining an API action.
+    class FilterBuilder
+      attr_accessor :response_filters, :response_formatters
+
+      def initialize
+        @response_filters    = []
+        @response_formatters = []
+      end
+
+      # Returns `key` from the API response as a string.
+      #
+      # @param [Symbol] key the key name to be returned as a string
+      # @param [Hash] *args
+      # @option *args [Symbol] :within look up the key in a namespace (nested hash)
+      def string(key, *args)
+        copy_value_directly(key, *args)
+      end
+
+      # Returns `key` from the API response as an integer.
+      #
+      # @param (see #string)
+      # @option (see #string)
+      def integer(key, *args)
+        copy_value_directly(key, *args)
+      end
+
+      # Returns `key` from the API response as a hash.
+      #
+      # @param (see #string)
+      # @option (see #string)
+      def hash(key, *args)
+        copy_value_directly(key, *args)
+      end
+
+      # Returns `key` from the API response as an array.
+      #
+      # @param (see #string)
+      # @option (see #string)
+      def array(key, *args)
+        copy_value_directly(key, *args)
+      end
+
+      # Returns the API response processed or wrapped in wrapper objects.
+      #
+      # @example
+      #   responds_with do
+      #     object :issues, :processed_with => lambda { |data| data.delete_if { |k,v| k == 'www_id' } }
+      #   end
+      #
+      # @example
+      #
+      #   responds_with do
+      #     object :issues, :wrapped_in => Apidiesel::ResponseObjects::Topic
+      #   end
+      #
+      # @param [Symbol] key the key name to be wrapped or processed
+      # @option *args [Symbol] :within look up the key in a namespace (nested hash)
+      # @option *args [Proc] :processed_with yield the data to this Proc for processing
+      # @option *args [Class] :wrapped_in wrapper object, will be called as `Object.create(data)`
+      # @option *args [Symbol] :as key name to save the result as
+      def objects(key, *args)
+        options = args.extract_options!
+
+        response_formatters << lambda do |data, processed_data|
+          d = get_value(key, data, options[:within])
+
+          if options[:processed_with]
+            d = options[:processed_with].call(d)
+          end
+          if options[:wrapped_in]
+            d = options[:wrapped_in].send(:create, d)
+          end
+
+          result_key = options[:as] || key
+
+          processed_data[result_key] = d
+
+          processed_data
+        end
+      end
+
+      # Descends into the hash key hierarchy
+      #
+      # Useful for cutting out useless top-level keys
+      #
+      # @param [Symbol, Array] key
+      def set_scope(key)
+        response_filters << lambda do |data|
+          fetch_path(data, *key)
+        end
+      end
+
+      # Raises an Apidiesel::ResponseError if the callable returns true
+      #
+      # @example
+      #   responds_with do
+      #     response_error_if ->(data) { data[:code] != 0 },
+      #                       message: ->(data) { data[:message] }
+      #
+      # @param [Lambda, Proc] callable
+      # @param [String, Lambda, Proc] message
+      # @raises [Apidiesel::ResponseError]
+      def response_error_if(callable, message:)
+        response_formatters << lambda do |data, processed_data|
+          return processed_data unless callable.call(data)
+
+          message = message.is_a?(String) ? message : message.call(data)
+
+          raise ResponseError.new(message)
+        end
+      end
+
+        protected
+
+      def get_value(key, hash, namespace = nil)
+        if namespace.is_a?(Array)
+          fetch_path(hash, *namespace)
+        elsif namespace.nil?
+          hash[key]
+        else
+          hash[namespace][key]
+        end
+      end
+
+      def fetch_path(hash, *parts)
+        parts.reduce(hash) do |memo, key|
+          memo[key] if memo
+        end
+      end
+
+      def copy_value_directly(key, *args)
+        options = args.extract_options!
+
+        response_formatters << lambda do |data, processed_data|
+          processed_data[key] = get_value(key, data, options[:within])
+
+          processed_data
+        end
+      end
+
+    end
+
+  end
+end

data/lib/apidiesel/errors.rb

@@ -0,0 +1,15 @@
+module Apidiesel
+  class Error < StandardError; end
+  class InputError < Error; end
+
+  class RequestError < Error
+    attr_reader :request
+
+    def initialize(msg = nil, request = nil)
+      @request = request
+      super(msg)
+    end
+  end
+
+  class ResponseError < RequestError; end
+end

data/lib/apidiesel/handlers/action_response_processor.rb

@@ -0,0 +1,13 @@
+module Apidiesel
+  module Handlers
+    module ActionResponseProcessor
+      class ResponseHandler
+        def run(request, _)
+          request.process_response
+
+          request
+        end
+      end
+    end
+  end
+end

data/lib/apidiesel/handlers/http_request_helper.rb

@@ -0,0 +1,38 @@
+module Apidiesel
+  module Handlers
+    module HttpRequestHelper
+      protected
+
+      # Executes a HTTP request
+      #
+      # @param [Apidiesel::Request] request
+      # @param [Hash] payload the request body
+      # @param [Hash] api_config the configuration data of the Apidiesel::Api
+      #               instance, as given to the handlers #run method
+      #
+      def execute_request(request:, payload:, api_config:)
+        http_request      = HTTPI::Request.new(request.action.url)
+        http_request.body = payload
+
+        http_request.auth.ssl.verify_mode = api_config[:ssl_verify_mode] || :peer
+        http_request.open_timeout         = api_config[:timeout] || 30
+        http_request.read_timeout         = api_config[:timeout] || 30
+
+        request.http_request = http_request
+
+        begin
+          response = HTTPI.request(request.action.http_method, http_request)
+          request.http_response = response
+        rescue => e
+          raise RequestError.new(e, request)
+        end
+
+        if response.error?
+          raise RequestError.new("#{request.action.http_method} #{request.action.url} returned #{response.code}", request)
+        end
+
+        request
+      end
+    end
+  end
+end

data/lib/apidiesel/handlers/mock_response.rb

@@ -0,0 +1,55 @@
+module Apidiesel
+  module Handlers
+    module MockResponse
+      class RequestHandler
+        def run(request, api_config)
+          action = request.action
+
+          return request unless action.respond_to?(:mock_response) && action.mock_response
+
+          file_name = action.mock_response[:file]
+          parser    = action.mock_response[:parser]
+          file      = File.read(file_name)
+
+          request.response_body = if parser
+            parser.call(file)
+
+          elsif file_name.ends_with?('.json')
+            JSON.parse(file)
+
+          elsif file_name.ends_with?('.xml')
+            Hash.from_xml(file)
+
+          else
+            file
+          end
+
+          request
+        end
+      end
+
+      module ActionExtension
+        extend ActiveSupport::Concern
+
+        class_methods do
+          def mock_response!(file:, &block)
+            @mock_response = {
+              file: file,
+              parser: block
+            }
+          end
+
+          def mock_response
+            @mock_response
+          end
+        end
+
+        def mock_response
+          self.class.mock_response
+        end
+      end
+    end
+  end
+end
+
+Apidiesel::Action.send(:include, Apidiesel::Handlers::MockResponse::ActionExtension)

data/lib/apidiesel/request.rb

@@ -0,0 +1,40 @@
+module Apidiesel
+
+  # Wrapper for API requests
+  class Request
+    attr_accessor :action, :parameters, :response_body, :http_request, :http_response, :metadata, :result
+
+    # @param [Apidiesel::Action] action
+    # @param [Hash] parameters
+    # @param [Hash] metadata
+    def initialize(action:, parameters:, metadata: {})
+      @action     = action
+      @parameters = parameters
+      @metadata   = metadata
+    end
+
+    def response_body
+      @response_body || http_response.try(:body)
+    end
+
+    def process_response
+      # Reraise ResponseErrors to include ourselves. Not
+      # pretty, but I can't think of anything nicer right now
+      begin
+        @result = action.process_response(response_body)
+      rescue ResponseError => e
+        raise ResponseError.new(e.message, self)
+      end
+    end
+
+    def to_s
+      [
+        "Apidiesel::Request",
+        action.http_method.to_s.upcase,
+        action.url,
+        action.endpoint,
+        parameters.collect { |key, value| "#{key}: #{value}"}.join(',')
+      ].join(' ')
+    end
+  end
+end

data/lib/apidiesel/version.rb

@@ -0,0 +1,3 @@
+module Apidiesel
+  VERSION = "0.1.0"
+end

data/lib/apidiesel.rb

@@ -0,0 +1,11 @@
+require 'httpi'
+
+require 'apidiesel/version'
+
+require 'apidiesel/errors'
+require 'apidiesel/api'
+require 'apidiesel/dsl'
+require 'apidiesel/request'
+require 'apidiesel/action'
+require 'apidiesel/handlers/action_response_processor'
+require 'apidiesel/handlers/http_request_helper'

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: apidiesel
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jan-Christian Foeh
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-11-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+- !ruby/object:Gem::Dependency
+  name: httpi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.4.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.4.1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: 
+email:
+- jan@programmanstalt.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-gemset"
+- ".ruby-version"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- apidiesel.gemspec
+- bin/console
+- bin/setup
+- lib/apidiesel.rb
+- lib/apidiesel/action.rb
+- lib/apidiesel/api.rb
+- lib/apidiesel/dsl.rb
+- lib/apidiesel/errors.rb
+- lib/apidiesel/handlers/action_response_processor.rb
+- lib/apidiesel/handlers/http_request_helper.rb
+- lib/apidiesel/handlers/mock_response.rb
+- lib/apidiesel/request.rb
+- lib/apidiesel/version.rb
+homepage: https://github.com/janfoeh/apidiesel
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Build API clients through an expressive DSL
+test_files: []