resource_kit 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6271c0e0f56abd845d9067c8bc2e55597a532fcd
+  data.tar.gz: 4898d65f961b2be6121c782efd92fbfd2f153660
+SHA512:
+  metadata.gz: 1bb8f7fea234fabc6d235eb4a9d3f1829d685b72dad2fe737986fee2dd2a432f9b59d91563fbcde239dbcfe802ec2df4614543b22fd9838ab241163d49b102ea
+  data.tar.gz: e78e93b61f9301dea5c86db6c3aa219794ff33fab4ad97da122a393d3ee3ecde093ddc34f751c80c8fd3f79405b860a7254b8026dff4571473ee6307889b0d0f

data/.gitignore

@@ -0,0 +1,22 @@
+*.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

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Robert Ross
+
+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,91 @@
+# Resource Kit
+
+Resource Kit provides tools to aid in making API Clients. Such as URL resolving, Request / Response layer, and more.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'resource_kit'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install resource_kit
+
+## Usage
+
+This library recommends using [Kartograph](http://github.com/digitaloceancloud/kartograph) for representing and deserializing response bodies.
+You'll see it in the examples provided below.
+
+### Resource classes
+
+Resource Kit provides a comprehensive but intuitive DSL where you describe the remote resources capabilities.
+For example, where can I get a list of users? Where do I get a single user? How do I create a user?
+
+When you're able to answer these questions, you can describe them in your resource class like this:
+
+```ruby
+class DropletResource < ResourceKit::Resource
+  resources do
+    default_handler(422) {|response| ErrorMapping.extract_single(response.body, :read) }
+    default_handler(:ok, :created) {|response| DropletMapping.extract_single(response.body, :read) }
+
+    # Defining actions will create instance methods on the resource class to call them.
+    action :find do
+      verb :get # get is assumed if this is omitted
+      path '/droplets/:id'
+      handler(200) {|response| DropletMapping.extract_single(response.body, :read) }
+    end
+
+    action :all do
+      path '/droplets'
+      handler(200) {|body| DropletMapping.extract_collection(body, :read) }
+    end
+
+    action :create do
+      path '/droplets'
+      verb :post
+      body {|object| DropletMapping.representation_for(:create, object) } # Generate a response body from a passed object
+      handler(202) {|response| DropletMapping.extract_single(response.body, :read) }
+    end
+  end
+end
+```
+
+Now that we've described our resources. We can instantiate our class with a connection object. ResourceKit relies on the interface that Faraday provides. For example:
+
+```ruby
+connection = Faraday.new(url: 'http://api.digitalocean.com') do |req|
+  req.adapter :net_http
+end
+
+resource = DropletResource.new(connection)
+```
+
+Now that we've instantiated a resource with our class, we can call the actions we've defined on it.
+
+```
+all_droplets = resource.all
+single_droplet = resource.find(id: 123)
+create = resource.create(Droplet.new)
+```
+
+### Nice to have's
+
+Things we've thought about but just haven't implemented are:
+
+* `action :find, 'PUT droplets/:id/restart'`
+* Pagination capabilities
+
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/resource_kit/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/examples/digitalocean_droplets.rb

@@ -0,0 +1,53 @@
+require 'kartograph'
+
+class Droplet
+  attr_accessor :id, :name, :region, :size, :image
+end
+
+class DropletMapping
+  include Kartograph::DSL
+
+  kartograph do
+    mapping Droplet
+    root_key plural: 'droplets', singular: 'droplet', scopes: [:read]
+
+    property :id, scopes: [:read]
+    property :name, scopes: [:read, :create]
+    property :size, scopes: [:read, :create]
+    property :image, scopes: [:read, :create]
+    property :region, scopes: [:read, :create]
+  end
+end
+
+class DropletResource < ResourceKit::Resource
+  resources do
+    action :all do
+      verb :get
+      path '/v2/droplets'
+      handler(200) { |response| DropletMapping.extract_collection(response.body, :read) }
+    end
+
+    action :find do
+      verb :get
+      path '/v2/droplets/:id'
+      handler(200) { |response| DropletMapping.extract_single(response.body, :read) }
+    end
+
+    action :create do
+      verb :post
+      path '/v2/droplets'
+      body {|object| DropletMapping.representation_for(:create, object) }
+      handler(202) { |response| DropletMapping.extract_single(response.body, :read) }
+    end
+  end
+end
+
+token = 'YOUR_ACCESS_TOKEN'
+connection = Faraday.new(url: 'https://api.digitalocean.com', headers: { content_type: 'application/json', authorization: "Bearer #{token}" }) do |req|
+  req.adapter :net_http
+end
+
+resource = DropletResource.new(connection)
+
+# Retrieve all droplets
+puts resource.all

data/lib/resource_kit/action.rb

@@ -0,0 +1,37 @@
+module ResourceKit
+  class Action
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+    end
+
+    def verb(v = nil)
+      @verb = v if v
+      @verb
+    end
+
+    def path(path = nil)
+      @path = path if path
+      @path
+    end
+
+    def handlers
+      @handlers ||= {}
+    end
+
+    def handler(*response_codes, &block)
+      response_codes.each do |code|
+        unless code.is_a?(Fixnum)
+          code = StatusCodeMapper.code_for(code)
+        end
+        handlers[code] = block
+      end
+    end
+
+    def body(&block)
+      @body_handler = block if block_given?
+      @body_handler
+    end
+  end
+end

data/lib/resource_kit/action_invoker.rb

@@ -0,0 +1,38 @@
+module ResourceKit
+  class ActionInvoker
+    ALLOWED_VERBS = [:get, :post, :put, :delete, :head, :patch, :options]
+
+    def self.call(action, connection, *args)
+      raise ArgumentError, "Verb '#{action.verb}' is not allowed" unless action.verb.in?(ALLOWED_VERBS)
+      options = args.extract_options!
+      resolver = EndpointResolver.new(path: action.path)
+
+      if args.size > 0 and action.verb.in?([:post, :put, :patch])
+        # This request is going to have a response body. Handle it.
+        response = connection.send(action.verb, resolver.resolve(options)) do |request|
+          request.body = construct_body(args.first, action)
+        end
+      else
+        response = connection.send(action.verb, resolver.resolve(options))
+      end
+
+      handle_response(response, action)
+    end
+
+    def self.handle_response(response, action)
+      if handler = action.handlers[response.status]
+        handler.call(response)
+      else
+        response.body
+      end
+    end
+
+    def self.construct_body(object, action)
+      if action.body
+        action.body.call(object)
+      else
+        object.to_s
+      end
+    end
+  end
+end

data/lib/resource_kit/endpoint_resolver.rb

@@ -0,0 +1,42 @@
+require 'addressable/uri'
+
+module ResourceKit
+  class EndpointResolver
+    attr_reader :path, :query_param_keys
+
+    def initialize(options = {})
+      @path = options[:path]
+      @query_param_keys = options[:query_param_keys] || {}
+    end
+
+    def resolve(values = {})
+      uri = Addressable::URI.new
+      new_path = generated_path(values)
+      uri.path = normalized_path_components(new_path)
+      uri.query = append_query_values(uri, values) unless query_param_keys.empty?
+
+      uri.to_s
+    end
+
+    private
+
+    def generated_path(values)
+      values.inject(path) do |np, (key, value)|
+        np.gsub(":#{key}", value.to_s)
+      end
+    end
+
+    def normalized_path_components(*components)
+      components.reject(&:blank?).map do |piece|
+        # Remove leading and trailing forward slashes
+        piece.gsub(/(^\/)|(\/$)/, '')
+      end.join('/').insert(0, '/')
+    end
+
+    def append_query_values(uri, values)
+      query_param_keys.each_with_object({}) do |key, query_values|
+        query_values[key] = values[key] if values.has_key?(key)
+      end.to_query
+    end
+  end
+end

data/lib/resource_kit/method_factory.rb

@@ -0,0 +1,20 @@
+module ResourceKit
+  class MethodFactory
+    def self.construct(object, resource_collection, invoker = ActionInvoker)
+      resource_collection.each do |action|
+        if object.method_defined?(action.name)
+          raise ArgumentError, "Action '#{action.name}' is already defined on `#{object}`"
+        end
+        method_block = method_for_action(action, invoker)
+
+        object.send(:define_method, action.name, &method_block)
+      end
+    end
+
+    def self.method_for_action(action, invoker)
+      Proc.new do |*args|
+        invoker.call(action, connection, *args)
+      end
+    end
+  end
+end

data/lib/resource_kit/resource.rb

@@ -0,0 +1,19 @@
+module ResourceKit
+  class Resource
+    class_attribute :namespace
+
+    attr_reader :connection
+
+    def initialize(connection)
+      @connection = connection
+    end
+
+    def self.resources(&block)
+      @resources ||= ResourceCollection.new
+      @resources.instance_eval(&block) if block_given?
+
+      MethodFactory.construct(self, @resources)
+      @resources
+    end
+  end
+end

data/lib/resource_kit/resource_collection.rb

@@ -0,0 +1,22 @@
+module ResourceKit
+  class ResourceCollection
+    extend Forwardable
+    def_delegators :@collection, :find, :<<, :each, :include?
+
+    def initialize
+      @collection = []
+    end
+
+    def action(name, &block)
+      action = Action.new(name)
+      action.instance_eval(&block) if block_given?
+      action.tap {|a| self << a }
+    end
+
+    def find_action(name)
+      find do |action|
+        action.name == name
+      end
+    end
+  end
+end

data/lib/resource_kit/status_code_mapper.rb

@@ -0,0 +1,59 @@
+module ResourceKit
+  class StatusCodeMapper
+    MAP = {
+      continue: 100,
+      switching_protocols: 101,
+      processing: 102,
+      ok: 200,
+      created: 201,
+      accepted: 202,
+      non_authoritative_information: 203,
+      no_content: 204,
+      reset_content: 205,
+      partial_content: 206,
+      multi_status: 207,
+      im_used: 226,
+      multiple_choices: 300,
+      moved_permanently: 301,
+      found: 302,
+      see_other: 303,
+      not_modified: 304,
+      use_proxy: 305,
+      temporary_redirect: 307,
+      bad_request: 400,
+      unauthorized: 401,
+      payment_required: 402,
+      forbidden: 403,
+      not_found: 404,
+      method_not_allowed: 405,
+      not_acceptable: 406,
+      proxy_authentication_required: 407,
+      request_timeout: 408,
+      conflict: 409,
+      gone: 410,
+      length_required: 411,
+      precondition_failed: 412,
+      request_entity_too_large: 413,
+      request_uri_too_long: 414,
+      unsupported_media_type: 415,
+      requested_range_not_satisfiable: 416,
+      expectation_failed: 417,
+      unprocessable_entity: 422,
+      locked: 423,
+      failed_dependency: 424,
+      upgrade_required: 426,
+      internal_server_error: 500,
+      not_implemented: 501,
+      bad_gateway: 502,
+      service_unavailable: 503,
+      gateway_timeout: 504,
+      http_version_not_supported: 505,
+      insufficient_storage: 507,
+      not_extended: 510
+    }
+
+    def self.code_for(symbol)
+      MAP[symbol]
+    end
+  end
+end

data/lib/resource_kit/version.rb

@@ -0,0 +1,3 @@
+module ResourceKit
+  VERSION = "0.0.1"
+end

data/lib/resource_kit.rb

@@ -0,0 +1,16 @@
+require "resource_kit/version"
+require 'active_support/core_ext'
+require 'faraday'
+
+module ResourceKit
+  autoload :Resource, 'resource_kit/resource'
+  autoload :ResourceCollection, 'resource_kit/resource_collection'
+
+  autoload :Action, 'resource_kit/action'
+  autoload :ActionInvoker, 'resource_kit/action_invoker'
+  autoload :MethodFactory, 'resource_kit/method_factory'
+
+  autoload :StatusCodeMapper, 'resource_kit/status_code_mapper'
+  autoload :EndpointResolver, 'resource_kit/endpoint_resolver'
+
+end

data/resource_kit.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'resource_kit/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "resource_kit"
+  spec.version       = ResourceKit::VERSION
+  spec.authors       = ["Robert Ross"]
+  spec.email         = ["rross@digitalocean.com"]
+  spec.summary       = %q{Resource Kit provides tools to aid in making API Clients. Such as URL resolving, Request / Response layer, and more.}
+  spec.description   = ''
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  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_dependency 'faraday'
+  spec.add_dependency 'activesupport', '>= 3.0'
+  spec.add_dependency 'addressable', '~> 2.3.6'
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "webmock", "~> 1.18.0"
+  spec.add_development_dependency "kartograph", "~> 0"
+end

data/spec/lib/resource_kit/action_invoker_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+RSpec.describe ResourceKit::ActionInvoker do
+  let(:connection) { Faraday.new {|b| b.adapter :test, stubs } }
+  let(:stubs) do
+    Faraday::Adapter::Test::Stubs.new do |stub|
+      stub.get('/users') { |env| [200, {}, 'all users'] }
+      stub.get('/users/bad_page') { |env| [404, {}, 'not found'] }
+      stub.get('/users/12') { |env| [200, {}, 'user 12'] }
+      stub.post('/users') { |env| [200, {}, env[:body]] }
+    end
+  end
+  let(:action) { ResourceKit::Action.new(:find) }
+
+  describe '.call' do
+    it 'performs a request to the specfied URL' do
+      action.verb :get
+      action.path '/users'
+
+      result = ResourceKit::ActionInvoker.call(action, connection)
+
+      expect(result).to eq('all users')
+    end
+
+    it 'substitues params on call' do
+      action.verb :get
+      action.path '/users/:id'
+
+      result = ResourceKit::ActionInvoker.call(action, connection, id: 12)
+      expect(result).to eq('user 12')
+    end
+
+    context 'when an action has a handler' do
+      it 'returns the handler block' do
+        action.verb :get
+        action.path '/users'
+        action.handler(200) {|response| 'changed' }
+
+        result = ResourceKit::ActionInvoker.call(action, connection)
+
+        expect(result).to eq('changed')
+      end
+
+      it 'uses the correct handler on status codes' do
+        action.verb :get
+        action.path '/users/bad_page'
+        action.handler(404) {|response| '404ed' }
+
+        result = ResourceKit::ActionInvoker.call(action, connection)
+        expect(result).to eq('404ed')
+      end
+    end
+
+    context 'for requests with bodies' do
+      it 'includes the contents of the body in the request' do
+        action.verb :post
+        action.path '/users'
+
+        result = ResourceKit::ActionInvoker.call(action, connection, 'echo me')
+        expect(result).to eq('echo me')
+      end
+
+      it 'uses the body handler when present' do
+        action.verb :post
+        action.path '/users'
+        action.body {|object| 'i am a banana' }
+
+        result = ResourceKit::ActionInvoker.call(action, connection, 'echo me')
+        expect(result).to eq('i am a banana')
+      end
+    end
+  end
+end

data/spec/lib/resource_kit/action_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+RSpec.describe ResourceKit::Action do
+  subject(:action) { ResourceKit::Action.new(:bunk) }
+
+  describe '#initialize' do
+    it 'initializes with a name' do
+      instance = ResourceKit::Action.new(:all)
+      expect(instance.name).to eq(:all)
+    end
+  end
+
+  describe '#verb' do
+    it 'sets the verb' do
+      action = described_class.new(:find)
+      action.verb :get
+      expect(action.verb).to be(:get)
+    end
+  end
+
+  describe '#path' do
+    it 'sets the path' do
+      action = described_class.new(:find)
+      action.path '/something/sammy'
+      expect(action.path).to eq('/something/sammy')
+    end
+  end
+
+  describe '#handler' do
+    it 'adds a handler to the handlers' do
+      expect { action.handler(202) { } }.to change(action.handlers, :size).from(0).to(1)
+    end
+
+    it 'adds the correct status code when using a symbol' do
+      action.handler(:ok) {}
+      expect(action.handlers).to have_key(200)
+    end
+  end
+
+  describe '#handlers' do
+    it 'returns a handler collection object' do
+      collection = action.handlers
+      expect(collection).to be_kind_of(Hash)
+    end
+  end
+
+  describe '#body' do
+    it 'stores a proc for handling requests with bodies' do
+      handler = Proc.new {|object| 'whut whut' }
+      action.body(&handler)
+
+      expect(action.body).to be(handler)
+    end
+  end
+end

data/spec/lib/resource_kit/endpoint_resolver_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+RSpec.describe ResourceKit::EndpointResolver do
+  describe '#initialize' do
+    it 'initializes with pieces of a URL' do
+      options = { path: '/users', namespace: '/v2', query_param_keys: ['per_page', 'page'] }
+      instance = ResourceKit::EndpointResolver.new(options)
+
+      expect(instance.path).to eq(options[:path])
+      expect(instance.query_param_keys).to eq(options[:query_param_keys])
+    end
+  end
+
+  describe '#resolve' do
+    let(:options) { { path: '/users' } }
+    subject(:resolver) { ResourceKit::EndpointResolver.new(options) }
+
+    context 'simple resolve' do
+      it 'creates a populated URL from passed values' do
+        endpoint = resolver.resolve()
+        expect(endpoint).to eq('/users')
+      end
+    end
+
+    context 'substituted paths' do
+      let(:options) { super().merge(path: '/users/:id') }
+
+      it 'creates a populated URL from passed values' do
+        endpoint = resolver.resolve(id: 1066)
+        expect(endpoint).to eq('/users/1066')
+      end
+    end
+
+    context 'with query parameters' do
+      let(:options) { super().merge(path: '/users', query_param_keys: [:per_page, :page]) }
+
+      it 'generates a URL with query parameters set correctly' do
+        endpoint = resolver.resolve(per_page: 2, page: 3)
+
+        uri = Addressable::URI.parse(endpoint)
+        expect(uri.query_values).to eq("per_page" => '2', "page" => '3')
+      end
+    end
+  end
+end

data/spec/lib/resource_kit/method_factory_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+RSpec.describe ResourceKit::MethodFactory do
+  let(:collection) { ResourceKit::ResourceCollection.new }
+  let(:klass) { Class.new { attr_accessor :connection } }
+
+  describe '.construct' do
+    before do
+      collection.action :find
+      collection.action :all
+    end
+
+    it 'adds the methods from the resource collection to the passed object' do
+      ResourceKit::MethodFactory.construct(klass, collection)
+      instance = klass.new
+      expect(instance).to respond_to(:find, :all)
+    end
+
+    it 'bails when the method is already defined' do
+      collection.action :all
+
+      expect {
+        ResourceKit::MethodFactory.construct(klass, collection)
+      }.to raise_exception(ArgumentError).with_message("Action 'all' is already defined on `#{klass}`")
+    end
+
+    it 'adds the correct interface for the action' do
+      ResourceKit::MethodFactory.construct(klass, collection)
+      method_sig = klass.instance_method(:all).parameters
+
+      expect(method_sig).to eq([[:rest, :args]])
+    end
+
+  end
+
+  describe 'Calling the method' do
+    it 'calls the invoker passed with the arguments and action' do
+      action = ResourceKit::Action.new(:bunk)
+      collection << action
+      invoker = double('invoker', call: true)
+
+      ResourceKit::MethodFactory.construct(klass, collection, invoker)
+
+      instance = klass.new
+      instance.connection = double('connection')
+      instance.bunk('something', 'something else')
+      expect(invoker).to have_received(:call).with(action, instance.connection, 'something', 'something else')
+    end
+  end
+end

data/spec/lib/resource_kit/resource_collection_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+RSpec.describe ResourceKit::ResourceCollection do
+  subject(:collection) { ResourceKit::ResourceCollection.new }
+
+  describe '#action' do
+    it 'yields an action to the block' do
+      expect {|b| collection.action(:all, &b) }.to yield_with_args(instance_of(ResourceKit::Action))
+    end
+
+    it 'adds the action to the collection' do
+      action = collection.action :all
+      expect(collection).to include(action)
+    end
+  end
+
+  describe '#find_action' do
+    it 'returns the action with the name passed' do
+      collection.action(:all)
+
+      retrieved_action = collection.find_action(:all)
+
+      expect(retrieved_action).to be_kind_of(ResourceKit::Action)
+      expect(retrieved_action.name).to eq(:all)
+    end
+  end
+end

data/spec/lib/resource_kit/resource_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+RSpec.describe ResourceKit::Resource do
+  describe '.resources' do
+    subject(:resource) { Class.new(described_class) }
+
+    it 'returns a resource collection' do
+      expect(resource.resources).to be_kind_of(ResourceKit::ResourceCollection)
+    end
+
+    it 'yields a resource collection' do
+      expect { |b| resource.resources(&b) }.to yield_with_args(instance_of(ResourceKit::ResourceCollection))
+    end
+
+    context 'action methods' do
+      class DropletResource < described_class
+        resources do
+          action :find
+          action :all
+        end
+      end
+
+      subject(:droplet_resource) { DropletResource.new(double) }
+
+      it "defines the action method" do
+        expect(droplet_resource).to respond_to(:find)
+      end
+    end
+  end
+
+  describe '#initialize' do
+    it 'initializes with a connection' do
+      faraday = Faraday.new(url: 'http://lol.com')
+      instance = ResourceKit::Resource.new(faraday)
+
+      expect(instance.connection).to be(faraday)
+    end
+  end
+end

data/spec/lib/resource_kit/status_code_mapper_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+RSpec.describe ResourceKit::StatusCodeMapper do
+  describe '.code_for' do
+    it 'returns the status code for a symbol' do
+      expect(described_class.code_for(:ok)).to eq(200)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'resource_kit'
+
+RSpec.configure do |config|
+  config.order = :random
+end

metadata

@@ -0,0 +1,190 @@
+--- !ruby/object:Gem::Specification
+name: resource_kit
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Robert Ross
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  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: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: addressable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.6
+- !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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.18.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.18.0
+- !ruby/object:Gem::Dependency
+  name: kartograph
+  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:
+- rross@digitalocean.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/digitalocean_droplets.rb
+- lib/resource_kit.rb
+- lib/resource_kit/action.rb
+- lib/resource_kit/action_invoker.rb
+- lib/resource_kit/endpoint_resolver.rb
+- lib/resource_kit/method_factory.rb
+- lib/resource_kit/resource.rb
+- lib/resource_kit/resource_collection.rb
+- lib/resource_kit/status_code_mapper.rb
+- lib/resource_kit/version.rb
+- resource_kit.gemspec
+- spec/lib/resource_kit/action_invoker_spec.rb
+- spec/lib/resource_kit/action_spec.rb
+- spec/lib/resource_kit/endpoint_resolver_spec.rb
+- spec/lib/resource_kit/method_factory_spec.rb
+- spec/lib/resource_kit/resource_collection_spec.rb
+- spec/lib/resource_kit/resource_spec.rb
+- spec/lib/resource_kit/status_code_mapper_spec.rb
+- spec/spec_helper.rb
+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: '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: Resource Kit provides tools to aid in making API Clients. Such as URL resolving,
+  Request / Response layer, and more.
+test_files:
+- spec/lib/resource_kit/action_invoker_spec.rb
+- spec/lib/resource_kit/action_spec.rb
+- spec/lib/resource_kit/endpoint_resolver_spec.rb
+- spec/lib/resource_kit/method_factory_spec.rb
+- spec/lib/resource_kit/resource_collection_spec.rb
+- spec/lib/resource_kit/resource_spec.rb
+- spec/lib/resource_kit/status_code_mapper_spec.rb
+- spec/spec_helper.rb