takeout 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b13e0750c7cac978c5789724348a99f57994021b
+  data.tar.gz: 274d6759e43802ffe0558e505c61cf097cda7e9c
+SHA512:
+  metadata.gz: b5c31da352a23bf7395a87fa103319aa7529d129104a86a3f785b1f9ceada1dba22ed6e9879ad625ca62dd7160b116b4027bfc2a9c1a47dd10ab4e3b48842f2a
+  data.tar.gz: 63e2cc81e661b3c064350e41ce77465c072a958b027baa006a99c4eccd3ebd826f4dd3ca29d0c2457fead6e44e97a6a0530facb4e6191caebd1423a4c3e070d6

data/.gitignore

@@ -0,0 +1,138 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+
+# Created by https://www.gitignore.io
+
+### RubyMine ###
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm
+
+*.iml
+
+## Directory-based project format:
+.idea/
+# if you remove the above rule, at least ignore the following:
+
+# User-specific stuff:
+# .idea/workspace.xml
+# .idea/tasks.xml
+# .idea/dictionaries
+
+# Sensitive or high-churn files:
+# .idea/dataSources.ids
+# .idea/dataSources.xml
+# .idea/sqlDataSources.xml
+# .idea/dynamic.xml
+# .idea/uiDesigner.xml
+
+# Gradle:
+# .idea/gradle.xml
+# .idea/libraries
+
+# Mongo Explorer plugin:
+# .idea/mongoSettings.xml
+
+## File-based project format:
+*.ipr
+*.iws
+
+## Plugin-specific files:
+
+# IntelliJ
+/out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+
+
+### SublimeText ###
+# cache files for sublime text
+*.tmlanguage.cache
+*.tmPreferences.cache
+*.stTheme.cache
+
+# workspace files are user-specific
+*.sublime-workspace
+
+# project files should be checked into the repository, unless a significant
+# proportion of contributors will probably not be using SublimeText
+# *.sublime-project
+
+# sftp configuration file
+sftp-config.json
+
+
+### Vim ###
+[._]*.s[a-w][a-z]
+[._]s[a-w][a-z]
+*.un~
+Session.vim
+.netrwhist
+*~
+
+
+### Ruby ###
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+.idea

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/Gemfile

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

data/Guardfile

@@ -0,0 +1,54 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :bundler do
+  require 'guard/bundler'
+  require 'guard/bundler/verify'
+  helper = Guard::Bundler::Verify.new
+
+  files = ['Gemfile']
+  files += Dir['*.gemspec'] if files.any? { |f| helper.uses_gemspec?(f) }
+
+  # Assume files are symlinked from somewhere
+  files.each { |file| watch(helper.real_path(file)) }
+end
+
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separately)
+#  * 'just' rspec: 'rspec'
+
+guard :rspec, cmd: "bundle exec rspec" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # Feel free to open issues for suggestions and improvements
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  watch(%r{^lib/takeout/(.+)\.rb$}) { |m| puts m; "spec/#{m.last}_spec.rb" }
+  watch(%r{^lib/(.+)\.rb$}) { |m| "spec/lib/#{m.last}_spec.rb" }
+end
+
+guard 'rake', task: 'build', run_on_all: true, run_on_start: true do
+  watch(%r{^lib/takeout/client.rb})
+end
+
+guard 'rake', task: 'install', run_on_all: true, run_on_start: true do
+  watch(%r{^lib/takeout/client.rb})
+end
+
+guard 'yard' do
+  watch(%r{app/.+\.rb})
+  watch(%r{lib/.+\.rb})
+  watch(%r{ext/.+\.c})
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Kyle Lucas
+
+MIT License
+
+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,140 @@
+# Takeout
+[![Code Climate](https://codeclimate.com/github/kylegrantlucas/takeout/badges/gpa.svg)](https://codeclimate.com/github/kylegrantlucas/takeout) [![Test Coverage](https://codeclimate.com/github/kylegrantlucas/takeout/badges/coverage.svg)](https://codeclimate.com/github/kylegrantlucas/takeout/coverage) [![Circle CI](https://circleci.com/gh/kylegrantlucas/takeout/tree/master.svg?style=shield)](https://circleci.com/gh/kylegrantlucas/takeout/tree/master) [![Inline docs](http://inch-ci.org/github/kylegrantlucas/takeout.svg?branch=master&style=shields)](http://inch-ci.org/github/kylegrantlucas/takeout)
+
+A powerful little tool for generating on-the-fly API clients.
+
+## Requirements
+
+All version of MRI 1.8 and up are supported, it probably work sunder other variations of ruby it just hasn't been tested on the,
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'takeout'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install takeout
+
+## Usage
+
+### Quick Use
+
+The first step is to instantiate a client with the URI and given endpoints you would like the gem to create methods for:
+
+    client = Takeout::Client.new(uri: 'testing.com', endpoints: {get: [:test, :test2], post: :test2})
+
+This can also be done using block format:
+   
+    client = Takeout::Client.new do |client|
+      client.uri = 'testing.com'
+      client.endpoints = {get: [:test, :test2], post: :test2}
+    end
+    
+From here you can begin calling your api methods! They take on the form ```(request_type)_(endpoint_name)```
+So given the example instantiation our method list would look like:
+
+    client.get_test
+    client.get_test2
+    client.post_test2
+    
+You can at anytime see a list of the methods available to you by running this:
+
+    (client.methods - Object.methods - Takeout::Client.instance_methods(false))
+    
+Results are returned as parsed ruby objects:
+
+    client.get_test
+      #=> {test: 1}
+      
+### Options
+#### Extensions
+
+You have the ability to specify an extension that gets tacked on, if you need it.
+You may do this in either the call or in teh client instantiation, however the call will always override the clients extension if there is a confilct.
+
+    client = Takeout::Client.new do |client|
+      client.uri = 'testing.com'
+      client.endpoints = {get: [:test, :test2], post: :test2}
+      client.extension = 'json'
+    end
+    
+    client.get_test(extension: 'json')
+    
+#### Templating
+
+Takeout includes support for specifying customs endpoint schemas using the [Liquid Templating Engine](http://liquidmarkup.org):
+    
+To define a schema do so in the instantiation of the client:
+
+    client = Takeout::Client.new do |client|
+      client.uri = 'testing.com'
+      client.endpoints = {get: [:test, :test2], post: :test2}
+      client.schemas = {get: {test: '/{{endpoint}}{% if param %}/required-param-{{param}}{% endif %}'}
+    end
+    
+From there when you call the endpoint you may pass in your params as part of the options and it will fill in accordingly:
+
+    client.get_test(param: 'Testing')
+      URL => "http://testing.com/test/required-param-Testing
+        
+    client.get_test
+      URL => "http://testing.com/test"
+        
+As you can see in the above example I use ```{{endpoint}}``` as one of the template values, it is only one of two reserved keywords for the templates, the other is ```{{object_id}}```.
+
+#### SSL Support
+
+SSL is also supported, and it very easy to flip on.
+
+You can either specify ssl when instantiating the object:
+
+    client = Takeout::Client.new(uri: 'testing.com', endpoints: {get: :test}, ssl: true)
+
+Or you can flip it on once already created:
+
+    client.enable_ssl
+
+You can disable it using the same method:
+
+    client.disable_ssl
+
+#### Headers
+
+Takeout also feature full support for headers:
+
+    client = Takeout::Client.new do |client|
+      client.uri = 'testing.com'
+      client.endpoints = {get: [:test, :test2], post: :test2}
+      client.headers = {auth_token: 'asdjhdskjfh23423423'}
+    end
+
+Much like extensions this can be done in the endpoint call too, and it will merge with the clients global headers:
+
+    client.get_test(headers: {auth_token: 'asdjhdskjfh23423423'})
+
+#### Basic Authentication
+
+Takeout also has support for basic auth by specifying both the ```username``` and ```password``` options during a call or instantiation
+Unlike most other features these are simply passed as options to the call:
+
+    client = Takeout::Client.new do |client|
+      client.uri = 'testing.com'
+      client.endpoints = {get: [:test, :test2], post: :test2}
+      client.options = {username: 'user', password: 'pass'}
+    end
+    
+    client.get_test(username: 'user', password: 'pass')
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/takeout/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

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

data/circle.yml

@@ -0,0 +1,3 @@
+machine:
+  ruby:
+    version: 2.1.0-p0

data/lib/takeout/client.rb

@@ -0,0 +1,201 @@
+module Takeout
+  class Client
+    require 'curb'
+    require 'oj'
+    require 'uri'
+    require 'erb'
+    require 'liquid'
+
+    # @return [Boolean] a boolean specifying whether or not to run curl with teh verbose setting
+    attr_accessor :debug
+
+    # @return [Hash] a hash specifying the global options to apply to each request
+    attr_accessor :options
+
+    # @return [Hash] a hash specifying the headers to apply to each request
+    attr_accessor :headers
+
+    # @return [String] a string with the extension to be appended on each request
+    attr_accessor :extension
+
+    # @return [Boolean] a boolean to specify whether or not SSL is turned on
+    attr_accessor :ssl
+
+    # @return [Hash] a hash specifying the custom per-endpoint schema templates
+    attr_accessor :schemas
+
+    # @return [String] the uri to send requests to
+    attr_accessor :uri
+
+    # @return [Hash] the hash containing the endpoints by request type to generate methods for
+    attr_reader :endpoints
+
+    # A constant specifying the kind of event callbacks to raise errors for
+    FAILURES = [:failure, :missing, :redirect]
+
+    # The main client initialization method.
+    # ==== Attributes
+    #
+    # * +options+ - The main atrtibute and extra global options to set for the client
+    # ==== Options
+    #
+    # * +:uri+ - A string defining the URI for the API to call.
+    # * +:endpoints+ - A hash containing the endpoints by request type to generate methods for
+    # * +:headers+ - A hash specifying the headers to apply to each request
+    # * +:ssl+ - A boolean to specify whether or not SSL is turned on
+    # * +:schemas+ - A hash specifying the custom per-endpoint schema templates
+    # * +:extension+ - A string with the extension to be appended on each request
+    def initialize(options={})
+      if block_given?
+        yield self
+      else
+        # Set instance variables
+        @uri = options[:uri] ? options[:uri] : ''
+        self.endpoints = options[:endpoints] ? options[:endpoints] : {}
+        @headers = options[:headers] ? options[:headers] : {}
+        @debug = options[:debug] ? options[:debug] : false
+        @ssl = options[:ssl] ? options[:ssl] : false
+        @schemas = options[:schemas] ? options[:schemas] : {}
+        @extension =  options[:extension] ? options[:extension] : nil
+
+        # Clean instance variables out of options hash and set that as options instance variable
+        [:uri, :endpoints, :headers, :debug, :ssl, :schemas, :extension].each { |v| options.delete(v) }
+        @options = options
+      end
+    end
+
+    # Check if SSL is enabled.
+    # @return [Boolean] Returns true if SSL is enabled, false if disabled
+    def ssl?
+      return @ssl
+    end
+
+    # Sets the instance variable and then generates the dynamic methods by calling #generate_enpoint_methods
+    # @param [Hash] value A hash specifying the custom per-endpoint schema templates
+    def endpoints=(value)
+      generate_endpoint_methods(value)
+      @endpoints = value
+    end
+
+    # Flips the @ssl instance variable to true
+    def enable_ssl
+      @ssl=true
+    end
+
+    # Flips the @ssl instance variable to false
+    def disable_ssl
+      @ssl=false
+    end
+
+    private
+
+    # Generates the dynamic (request_type)_(endpoint_name) methods that allow you to access your API.
+    # @param [Hash] endpoints A hash with the form {request_type: :endpoint_name} or {request_type: [:endpoint_name1, :endpoint_name_2]}
+    def generate_endpoint_methods(endpoints)
+      endpoints.each do |request_type, endpoint_names|
+        # Force any give values into an array and then iterate over that
+        [endpoint_names].flatten(1).each do |request_name|
+          define_singleton_method("#{request_type}_#{request_name}".to_sym) do |options={}|
+            # Extract values that we store separately from the options hash and then clean it up
+            headers.merge!(options[:headers]) if options[:headers]
+
+            # Merge in global options
+            options.merge!(@options) if @options
+
+            # Build the request_url and update the options to remove templated values (if there are any)
+            request_url, options = generate_request_url(request_name, request_type, options)
+
+            # Clean up options hash before performing request
+            [:headers, :extension, :object_id].each { |value| options.delete(value)}
+
+            return perform_curl_request(request_type, request_url, options, headers)
+          end
+        end
+      end if endpoints.is_a? Hash
+    end
+
+    # Render out the template values and return the updated options hash
+    # @param [String] endpoint
+    # @param [String] request_type
+    # @param [Hash] options
+    # @return [String] rendered_template
+    # @return [Hash] options
+    def substitute_template_values(endpoint, request_type, options={})
+      # Gets the proper template for the give CUSTOM_SCHEMA string for this endpoint and substitutes value for it based on give options
+      endpoint_templates = @schemas.fetch(request_type, nil)
+      template = endpoint_templates.fetch(endpoint, nil) if endpoint_templates
+
+      if template
+        extracted_options, options = extract_template_options(options.merge({endpoint: endpoint}), template)
+        # Render out the template
+        rendered_template = Liquid::Template.parse(template).render(extracted_options)
+      end
+
+      return rendered_template, options
+    end
+
+    def extract_template_options(options, template)
+      extracted_options = {}
+
+      # Build new options hash for templating
+      extracted_options.merge!({endpoint: options[:endpoint]}) if options[:object_id]
+      extracted_options.merge!({object_id: options[:object_id]}) if options[:object_id]
+      template.scan(/\{\{(\w+)\}\}/).flatten(1).each { |template_key| extracted_options.merge!(options.select {|key| key == template_key.to_sym }) }
+
+      # Convert keys to strings
+      extracted_options = extracted_options.inject({}){|memo,(k,v)| memo[k.to_s] = v; memo}
+
+      # Encode the template values and remove template values from original options hash
+      extracted_options.each do |key, value|
+        extracted_options[key] = ERB::Util.url_encode(value.to_s)
+        options.delete(key.to_sym)
+      end
+
+      return extracted_options, options
+    end
+
+    def perform_curl_request(request_type, request_url, options=nil, headers=nil)
+      curl = Curl.send(request_type.to_sym, request_url.to_s, options) do |curl|
+        curl.verbose = true if @debug
+
+        if options[:basic_auth]
+          curl.http_auth_types = :basic
+          curl.username = options[:basic_auth][:username]
+          curl.password = options[:basic_auth][:password]
+        end
+
+        headers.each { |key, value| curl.headers[key.to_s] = value } if headers
+
+        curl.on_success {|response| @parsed_body, @failure = Oj.load(response.body_str), false }
+
+        FAILURES.each { |failure_type| curl.send("on_#{failure_type}") {@failure=true} }
+      end
+
+      raise Takeout::EndpointFailureError.new(curl, request_type) if @failure
+
+      return @parsed_body if @parsed_body
+    end
+
+
+    def generate_request_url(endpoint_name, request_type=nil, options=nil)
+      # Generate custom templated path string and update options hash
+      custom_schema, options = substitute_template_values(endpoint_name, request_type, options) unless schemas.empty?
+
+      # Generate URL based on if the custom schema exists, and if there is a given object_id
+      request_url = if custom_schema.nil? || (custom_schema && custom_schema.empty?)
+                      (options[:object_id] ? url("/#{endpoint_name.to_s}/#{options[:object_id]}") : url("/#{endpoint_name.to_s}"))
+                    else
+                      url(custom_schema)
+                    end
+
+      # Append extension if one is given
+      request_url = "#{request_url}.#{options[:extension] ? options[:extension] : self.extension}" if options[:extension] || self.extension
+
+      return request_url, options
+    end
+
+    def url(endpoint=nil)
+      ssl? ? URI::HTTPS.build(host: @uri, path: endpoint) : URI::HTTP.build(host: @uri, path: endpoint)
+    end
+  end
+end

data/lib/takeout/endpoint_failure_error.rb

@@ -0,0 +1,13 @@
+module Takeout
+  class EndpointFailureError < StandardError
+    attr_reader :object, :request_type, :request_url, :response_code
+
+    def initialize(object, request_type)
+      @object, @request_type = object, request_type
+    end
+
+    def message
+      "Error in calling #{@request_type.to_s.upcase} on the endpoint: #{@object.url}, response_code: #{@object.response_code}"
+    end
+  end
+end

data/lib/takeout/version.rb

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

data/lib/takeout.rb

@@ -0,0 +1,6 @@
+require 'takeout/version'
+require 'takeout/endpoint_failure_error'
+require 'takeout/client.rb'
+
+module Takeout
+end

data/spec/client_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+ENDPOINTS = [:posts, :fake_failure, :fake_missing, :fake_redirect]
+describe Takeout::Client do
+  let (:client) {Takeout::Client.new(uri: 'test.com', endpoints: {get: ENDPOINTS, post: ENDPOINTS, put: ENDPOINTS, delete: ENDPOINTS})}
+
+  context 'initialization' do
+    it 'creates methods for all provided endpoints' do
+      expect((client.methods - Object.methods - Takeout::Client.instance_methods(false))).to eq([:get_posts, :get_fake_failure, :get_fake_missing, :get_fake_redirect,
+                                                                                                 :post_posts, :post_fake_failure, :post_fake_missing, :post_fake_redirect,
+                                                                                                 :put_posts, :put_fake_failure, :put_fake_missing, :put_fake_redirect,
+                                                                                                 :delete_posts, :delete_fake_failure, :delete_fake_missing, :delete_fake_redirect])
+    end
+  end
+
+  context 'ssl' do
+    it 'uses https protocol when enabled' do
+      client.enable_ssl
+      expect(client.send(:url).scheme).to eql 'https'
+    end
+
+    it 'uses http protocol when disabled' do
+      client.disable_ssl
+      expect(client.send(:url).scheme).to eql 'http'
+    end
+  end
+
+  context 'templating' do
+    it 'properly substitutes template keys' do
+      temp_client = Takeout::Client.new(uri: 'test.com', endpoints: {get: ENDPOINTS}, schemas: {get: {posts: '/{{endpoint}}/{{test}}'}})
+      expect(temp_client.send(:generate_request_url, :posts, :get, {test: 'STRING'}).first.to_s).to eq 'http://test.com/posts/STRING'
+    end
+
+    it 'properly returns updated options hash' do
+      temp_client = Takeout::Client.new(uri: 'test.com', endpoints: {get: ENDPOINTS}, schemas: {get: {posts: '/{{endpoint}}/{{test}}'}})
+      expect(temp_client.send(:generate_request_url, :posts, :get, {test: 'STRING', auth_key: '111'}).last).to eq auth_key: '111'
+    end
+
+    it 'properly handles an object_id' do
+      expect(client.send(:generate_request_url, :posts, :get, {object_id: 1}).first.to_s).to eq 'http://test.com/posts/1'
+    end
+  end
+
+
+  context 'headers' do
+    pending 'submits headers'
+    pending 'merges instance headers with call headers'
+  end
+
+  context 'options' do
+    pending 'merges instance options with call options'
+  end
+
+  context 'get' do
+    it 'returns array on success' do
+      expect(client.get_posts).to be_an(Array)
+    end
+
+    it 'raises EndpointFailureError on missing' do
+      expect{client.get_fake_missing}.to raise_error(Takeout::EndpointFailureError, generate_error_message(:get, 'fake_missing'))
+    end
+
+    it 'raises EndpointFailureError on failure' do
+      expect{client.get_fake_failure}.to raise_error(Takeout::EndpointFailureError, generate_error_message(:get, 'fake_failure'))
+    end
+    pending 'raises EndPointFailureError on redirect'
+  end
+
+  context 'post' do
+    it 'returns hash on success' do
+      expect(client.post_posts).to be_an(Hash)
+    end
+
+    it 'raises EndpointFailureError when called without object_id' do
+      expect{client.post_posts(object_id: 1)}.to raise_error(Takeout::EndpointFailureError, generate_error_message(:post, 'posts/1'))
+    end
+
+    it 'raises EndpointFailureError on missing' do
+      expect{client.post_fake_missing}.to raise_error(Takeout::EndpointFailureError, generate_error_message(:post, 'fake_missing'))
+    end
+    it 'raises EndpointFailureError on failure' do
+      expect{client.post_fake_failure}.to raise_error(Takeout::EndpointFailureError, generate_error_message(:post, 'fake_failure'))
+    end
+
+    pending 'raises EndpointFailureError on redirect'
+  end
+
+  context 'delete' do
+    it 'returns hash on success with object_id' do
+      expect(client.delete_posts(object_id: 1)).to be_a(Hash)
+    end
+
+    it 'raises EndpointFailureError when called without object_id' do
+      expect{client.delete_posts}.to raise_error(Takeout::EndpointFailureError, generate_error_message(:delete, 'posts'))
+    end
+
+    it 'raises EndpointFailureError on missing' do
+      expect{client.delete_fake_missing}.to raise_error(Takeout::EndpointFailureError, generate_error_message(:delete, 'fake_missing'))
+    end
+
+    it 'raises EndpointFailureError on failure' do
+      expect{client.delete_fake_failure}.to raise_error(Takeout::EndpointFailureError, generate_error_message(:delete, 'fake_failure'))
+    end
+
+    pending 'raises EndPointFailureError on redirect'
+  end
+
+  context 'put' do
+    it 'returns hash on success with object_id' do
+      expect(client.put_posts(object_id: 1)).to be_a(Hash)
+    end
+
+    it 'raises EndpointFailureError when called without object_id' do
+      expect{client.put_posts}.to raise_error(Takeout::EndpointFailureError, generate_error_message(:put, 'posts'))
+    end
+
+    it 'raises EndpointFailureError on missing' do
+      expect{client.put_fake_missing}.to raise_error(Takeout::EndpointFailureError, generate_error_message(:put, 'fake_missing'))
+    end
+    it 'raises EndpointFailureError on failure' do
+      expect{client.put_fake_failure}.to raise_error(Takeout::EndpointFailureError, generate_error_message(:put, 'fake_failure'))
+    end
+    pending 'raises EndPointFailureError on redirect'
+  end
+end
+
+def generate_error_message(request_type, endpoint)
+  codes = {fake_failure: 500, fake_missing: 404, fake_redirect: 301, :'posts/1' => 404, posts: 404}
+  return "Error in calling #{request_type.to_s.upcase} on the endpoint: http://test.com/#{endpoint}, response_code: #{codes[endpoint.to_sym]}"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,104 @@
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
+require 'bundler/setup'
+Bundler.setup
+require 'takeout'
+require 'webmock/rspec'
+WebMock.disable_net_connect!(:allow => "codeclimate.com")
+
+Dir["./spec/support/**/*.rb"].sort.each { |f| require f}
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+
+  config.before(:each) do
+    stub_request(:any, /test.com/).to_rack(FakeTestApi)
+  end
+end

data/spec/support/fake_test_api.rb

@@ -0,0 +1,43 @@
+require 'sinatra/base'
+
+class FakeTestApi < Sinatra::Base
+  REQUEST_TYPES = [:get, :put, :post, :delete]
+  #
+  # /posts endpoints
+  #
+  get('/posts') {json_response 200, 'posts.json'}
+  post('/posts') {json_response 200, 'post.json'}
+  delete('/posts') {json_response 404, nil}
+  put('/posts') {json_response 404, nil}
+
+  #
+  # /posts/1 endpoints
+  #
+  get('/posts/1') {json_response 200, 'post.json'}
+  delete('/posts/1') {json_response 200, 'post.json'}
+  put('/posts/1') {json_response 200, 'post.json'}
+  post('/posts/1') {json_response 404, nil}
+
+  #
+  # /fake_failure
+  #
+  REQUEST_TYPES.each {|rt| self.superclass.send(rt, '/fake_failure') {json_response 500, nil}}
+
+  #
+  # /fake_missing
+  #
+  REQUEST_TYPES.each {|rt| self.superclass.send(rt, '/fake_missing') {json_response 404, nil}}
+
+  #
+  # /fake_redirect
+  #
+  REQUEST_TYPES.each {|rt| self.superclass.send(rt, '/fake_redirect') {json_response 301, nil}}
+
+  private
+
+  def json_response(response_code, file_name)
+    content_type :json
+    status response_code
+    File.open(File.dirname(__FILE__) + '/fixtures/' + file_name, 'rb').read if file_name
+  end
+end

data/spec/support/fixtures/post.json

@@ -0,0 +1,3 @@
+{
+  "id": 1
+}

data/spec/support/fixtures/posts.json

@@ -0,0 +1,8 @@
+[
+  {
+    "id": 1
+  },
+  {
+    "id": 2
+  }
+]

data/takeout.gemspec

@@ -0,0 +1,37 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'takeout/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "takeout"
+  spec.version       = Takeout::VERSION
+  spec.authors       = ["Kyle Lucas"]
+  spec.email         = ["kglucas93@gmail.com"]
+  spec.summary       = %q{A simple ruby library to autogenerate api clients.}
+  spec.description   = %q{}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+  spec.required_ruby_version = '>= 1.8.0'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_runtime_dependency "oj"
+  spec.add_runtime_dependency "curb"
+  spec.add_runtime_dependency "liquid"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "sinatra"
+  spec.add_development_dependency "webmock"
+  spec.add_development_dependency "guard", "2.12.5"
+  spec.add_development_dependency "guard-rspec", '4.5.0'
+  spec.add_development_dependency "guard-bundler"
+  spec.add_development_dependency "guard-rake"
+  spec.add_development_dependency "terminal-notifier-guard"
+  spec.add_development_dependency "codeclimate-test-reporter"
+  spec.add_development_dependency 'guard-yard'
+end

metadata

@@ -0,0 +1,283 @@
+--- !ruby/object:Gem::Specification
+name: takeout
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kyle Lucas
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: curb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: liquid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.12.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.12.5
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.5.0
+- !ruby/object:Gem::Dependency
+  name: guard-bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: terminal-notifier-guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ''
+email:
+- kglucas93@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- circle.yml
+- lib/.DS_Store
+- lib/takeout.rb
+- lib/takeout/client.rb
+- lib/takeout/endpoint_failure_error.rb
+- lib/takeout/version.rb
+- spec/.DS_Store
+- spec/client_spec.rb
+- spec/spec_helper.rb
+- spec/support/.DS_Store
+- spec/support/fake_test_api.rb
+- spec/support/fixtures/post.json
+- spec/support/fixtures/posts.json
+- takeout.gemspec
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.8.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A simple ruby library to autogenerate api clients.
+test_files:
+- spec/.DS_Store
+- spec/client_spec.rb
+- spec/spec_helper.rb
+- spec/support/.DS_Store
+- spec/support/fake_test_api.rb
+- spec/support/fixtures/post.json
+- spec/support/fixtures/posts.json
+has_rdoc: