rest-in-peace 1.0.0

data/.gitignore

@@ -0,0 +1,2 @@
+Gemfile.lock
+coverage

data/.rspec

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

data/.ruby-gemset

@@ -0,0 +1 @@
+rest-in-peace

data/.ruby-version

@@ -0,0 +1 @@
+1.9.3-p547

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.2
+script:
+  - bundle exec rake spec

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Guardfile

@@ -0,0 +1,10 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :rspec do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+end
+

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Nine Internet Solutions AG (nine.ch)
+
+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,163 @@
+# REST in Peace [![Build Status](https://travis-ci.org/ninech/REST-in-Peace.svg)](https://travis-ci.org/ninech/REST-in-Peace) [![Code Climate](https://codeclimate.com/github/ninech/REST-in-Peace.png)](https://codeclimate.com/github/ninech/REST-in-Peace)
+
+A ruby REST client that lets you feel like in heaven when consuming APIs.
+
+![logo](https://raw.githubusercontent.com/ninech/REST-in-Peace/master/images/rest_in_peace.gif)
+
+## Getting Started
+
+1. Add `REST-in-Peace` to your dependencies
+
+        gem 'rest-in-peace'
+
+2. Choose which http adapter you want to use
+
+        gem 'faraday'
+
+## Usage
+
+### HTTP Client Library
+
+There is no dependency on a specific HTTP client library but the client has been tested with [Faraday](https://github.com/lostisland/faraday) only. You can use any other client library as long as it has the same API as Faraday.
+
+### Configuration
+
+You need to define all the API endpoints you want to consume with `RESTinPeace`. Currently the four HTTP Verbs `GET`, `POST`, `PATCH` and `DELETE` are supported.
+
+There are two sections where you can specify endpoints: `resource` and `collection`:
+
+```ruby
+rest_in_peace do
+  resource do
+    get :reload, '/rip/:id'
+  end
+  collection do
+    get :find, '/rip/:id'
+  end
+end
+```
+
+#### HTTP Client Configuration
+
+You need to specify the HTTP client library to use. You can either specify a block (for lazy loading) or a client instance directly.
+
+```ruby
+class Resource
+  rest_in_peace do
+    use_api ->() { Faraday.new(url: 'http://rip.dev') }
+  end
+end
+
+class ResourceTwo
+  rest_in_peace do
+    use_api Faraday.new(url: 'http://rip.dev')
+  end
+end
+```
+
+#### Resource
+
+If you define anything inside the `resource` block, it will define a method on the instances of the class:
+```ruby
+class Resource
+  rest_in_peace do
+    resource do
+      get :reload, '/rip/:id'
+      post :create, '/rip'
+    end
+  end
+end
+
+resource = Resource.new(id: 1)
+resource.create # calls "POST /rip"
+resource.reload # calls "GET /rip/1"
+```
+
+#### Collection
+
+If you define anything inside the `collection` block, it will define a method on the class:
+
+```ruby
+class Resource
+  rest_in_peace do
+    collection do
+      get :find, '/rip/:id'
+      get :find_on_other, '/other/:other_id/rip/:id'
+    end
+  end
+end
+
+resource = Resource.find(1) # calls "GET /rip/1"
+resource = Resource.find_on_other(42, 1337) # calls "GET /other/42/rip/1337"
+```
+
+#### Pagination
+
+You can define your own pagination module which will be mixed in when calling the API:
+
+```ruby
+class Resource
+  rest_in_peace do
+    collection do
+      get :all, '/rips', paginate_with: MyClient::Paginator
+    end
+  end
+end
+```
+
+An example pagination mixin with HTTP headers can be found in the [examples directory](https://github.com/ninech/REST-in-Peace/blob/master/examples) of this repo.
+
+#### Complete Configuration
+
+```ruby
+require 'my_client/paginator'
+require 'rest_in_peace'
+
+module MyClient
+  class Fabric < Struct.new(:id, :name, :ip)
+    include RESTinPeace
+
+    rest_in_peace do
+      use_api ->() { MyClient.api }
+    
+      resource do
+        patch :save, '/fabrics/:id'
+        post :create, '/fabrics'
+        delete :destroy, '/fabrics/:id'
+        get :reload, '/fabrics/:id'
+      end
+
+      collection do
+        get :all, '/fabrics', paginate_with: MyClient::Paginator
+        get :find, '/fabrics/:id'
+      end
+    end
+  end
+end
+```
+
+## Helpers
+
+### SSL Configuration for Faraday
+
+There is a helper class which can be used to create a Faraday compatible SSL configuration hash (with support for client certificates).
+
+```ruby
+ssl_config = {
+  "api_url"         => "https://api-backend.dev:3443",
+  "use_cert"        => true,
+  "ssl_cert_client" => "/etc/ssl/private/client.crt",
+  "ssl_key_client"  => "/etc/ssl/private/client.key",
+  "ssl_ca"          => "/etc/ssl/certs/ca-chain.crt"
+}
+
+ssl_config_creator = RESTinPeace::SSLConfigCreator.new(ssl_config, :peer)
+ssl_config_creator.faraday_options.inspect
+# =>
+{
+  :client_cert => #<OpenSSL::X509::Certificate>,
+  :client_key  => Long key is long,
+  :ca_file     => "/etc/ssl/certs/ca-chain.crt",
+  :verify_mode => 1
+}
+```

data/Rakefile

@@ -0,0 +1,9 @@
+#!/usr/bin/env rake
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |task|
+  task.rspec_opts = '--format doc --profile'
+end
+
+task default: :spec

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/examples/pagination_with_headers.rb

@@ -0,0 +1,26 @@
+module MyClient
+  module Paginator
+    def get
+      Enumerator.new do |yielder|
+        @params.merge!(page: 1)
+        result = api.get(url, @params)
+        current_page = result.env.response_headers['X-Page'].to_i
+        total_pages = result.env.response_headers['X-Total-Pages'].to_i
+
+        loop do
+          # Yield the results we got in the body.
+          result.body.each do |item|
+            yielder << @klass.new(item)
+          end
+
+          # Only make a request to get the next page if we have not
+          # reached the last page yet.
+          raise StopIteration if current_page == total_pages
+          @params.merge!(page: current_page + 1)
+          result = api.get(url, @params)
+          current_page = result.env.response_headers['X-Page'].to_i
+        end
+      end
+    end
+  end
+end

data/lib/rest-in-peace.rb

@@ -0,0 +1 @@
+require 'rest_in_peace'

data/lib/rest_in_peace/api_call.rb

@@ -0,0 +1,53 @@
+require 'rest_in_peace/template_sanitizer'
+require 'rest_in_peace/response_converter'
+
+module RESTinPeace
+  class ApiCall
+    def initialize(api, url_template, klass, params)
+      @api = api
+      @url_template = url_template
+      @klass = klass
+      @params = params
+    end
+
+    def get
+      response = api.get(url, params)
+      convert_response(response)
+    end
+
+    def post
+      response = api.post(url, params)
+      convert_response(response)
+    end
+
+    def patch
+      response = api.patch(url, params)
+      convert_response(response)
+    end
+
+    def delete
+      response = api.delete(url, params)
+      convert_response(response)
+    end
+
+    def url
+      sanitizer.url
+    end
+
+    def params
+      sanitizer.leftover_params
+    end
+
+    def sanitizer
+      @sanitizer ||= RESTinPeace::TemplateSanitizer.new(@url_template, @params)
+    end
+
+    def convert_response(response)
+      RESTinPeace::ResponseConverter.new(response, @klass).result
+    end
+
+    def api
+      @api.respond_to?(:call) ? @api.call : @api
+    end
+  end
+end

data/lib/rest_in_peace/definition_proxy/collection_method_definitions.rb

@@ -0,0 +1,31 @@
+require 'rest_in_peace/template_sanitizer'
+require 'rest_in_peace/api_call'
+
+module RESTinPeace
+  class DefinitionProxy
+    class CollectionMethodDefinitions
+      def initialize(target)
+        @target = target
+      end
+
+      def get(method_name, url_template, default_params = {})
+        @target.send(:define_singleton_method, method_name) do |*args|
+          if args.last.is_a?(Hash)
+            params = default_params.merge(args.pop)
+          else
+            params = default_params.dup
+            tokens = RESTinPeace::TemplateSanitizer.new(url_template, {}).tokens
+            tokens.each do |token|
+              params.merge!(token.to_sym => args.shift)
+            end
+          end
+
+          call = RESTinPeace::ApiCall.new(api, url_template, self, params)
+          call.extend(params.delete(:paginate_with)) if params[:paginate_with]
+          call.get
+        end
+      end
+    end
+  end
+end
+

data/lib/rest_in_peace/definition_proxy/resource_method_definitions.rb

@@ -0,0 +1,39 @@
+module RESTinPeace
+  class DefinitionProxy
+    class ResourceMethodDefinitions
+      def initialize(target)
+        @target = target
+      end
+
+      def get(method_name, url_template, default_params = {})
+        @target.send(:define_method, method_name) do
+          call = RESTinPeace::ApiCall.new(api, url_template, self, to_h)
+          call.get
+        end
+      end
+
+      def patch(method_name, url_template)
+        @target.send(:define_method, method_name) do
+          call = RESTinPeace::ApiCall.new(api, url_template, self, to_h)
+          call.patch
+        end
+      end
+
+      def post(method_name, url_template)
+        @target.send(:define_method, method_name) do
+          call = RESTinPeace::ApiCall.new(api, url_template, self, to_h)
+          call.post
+        end
+      end
+
+      def delete(method_name, url_template, default_params = {})
+        @target.send(:define_method, method_name) do |params = {}|
+          merged_params = default_params.merge(to_h).merge(params)
+          call = RESTinPeace::ApiCall.new(api, url_template, self, merged_params)
+          call.delete
+        end
+      end
+    end
+  end
+end
+

data/lib/rest_in_peace/definition_proxy.rb

@@ -0,0 +1,24 @@
+require 'rest_in_peace/definition_proxy/resource_method_definitions'
+require 'rest_in_peace/definition_proxy/collection_method_definitions'
+
+module RESTinPeace
+  class DefinitionProxy
+    def initialize(target)
+      @target = target
+    end
+
+    def resource(&block)
+      method_definitions = RESTinPeace::DefinitionProxy::ResourceMethodDefinitions.new(@target)
+      method_definitions.instance_eval(&block)
+    end
+
+    def collection(&block)
+      method_definitions = RESTinPeace::DefinitionProxy::CollectionMethodDefinitions.new(@target)
+      method_definitions.instance_eval(&block)
+    end
+
+    def use_api(api)
+      @target.api = api
+    end
+  end
+end

data/lib/rest_in_peace/errors.rb

@@ -0,0 +1,3 @@
+module RESTinPeace
+  class DefaultError < Exception; end
+end

data/lib/rest_in_peace/response_converter.rb

@@ -0,0 +1,33 @@
+module RESTinPeace
+  class ResponseConverter
+    def initialize(response, klass)
+      @response = response
+      @klass = klass
+    end
+
+    def result
+      case @response.body.class.to_s
+      when 'Array'
+        convert_from_array
+      when 'Hash'
+        convert_from_hash
+      else
+        raise "Don't know how to convert #{@response.body.class}"
+      end
+    end
+
+    def convert_from_array
+      @response.body.map do |entity|
+        convert_from_hash(entity)
+      end
+    end
+
+    def convert_from_hash(entity = @response.body)
+      klass.new entity
+    end
+
+    def klass
+      @klass.respond_to?(:new) ? @klass : @klass.class
+    end
+  end
+end

data/lib/rest_in_peace/ssl_config_creator.rb

@@ -0,0 +1,53 @@
+require 'openssl'
+
+module RESTinPeace
+  class SSLConfigCreator
+    def initialize(config, verify = :peer)
+      @config = config
+      @verify = verify
+    end
+
+    def faraday_options
+      {client_cert: client_cert, client_key: client_key, ca_file: ca_cert_path, verify_mode: verify_mode}
+    end
+
+    def client_cert
+      OpenSSL::X509::Certificate.new(open_file(client_cert_path))
+    end
+
+    def client_cert_path
+      path(@config[:ssl_cert_client])
+    end
+
+    def client_key
+      OpenSSL::PKey::RSA.new(open_file(client_key_path))
+    end
+
+    def client_key_path
+      path(@config[:ssl_key_client])
+    end
+
+    def ca_cert_path
+      path(@config[:ssl_ca])
+    end
+
+    def verify_mode
+      case @verify
+      when :peer
+        OpenSSL::SSL::VERIFY_PEER
+      else
+        raise "Unknown verify variant '#{@verify}'"
+      end
+    end
+
+    private
+
+    def open_file(file)
+      File.open(file)
+    end
+
+    def path(file)
+      File.join(file)
+    end
+  end
+end

data/lib/rest_in_peace/template_sanitizer.rb

@@ -0,0 +1,32 @@
+require 'rest_in_peace/errors'
+
+module RESTinPeace
+  class TemplateSanitizer
+
+    class IncompleteParams < RESTinPeace::DefaultError; end
+
+    def initialize(url_template, params)
+      @url_template = url_template
+      @params = params.dup
+    end
+
+    def url
+      return @url if @url
+      @url = @url_template.dup
+      tokens.each do |token|
+        param = @params.delete(token.to_sym)
+        raise IncompleteParams, "Unknown parameter for token :#{token} found" unless param
+        @url.gsub!(%r{:#{token}}, param.to_s)
+      end
+      @url
+    end
+
+    def tokens
+      @url_template.scan(%r{:([a-z_]+)}).flatten
+    end
+
+    def leftover_params
+      @params.delete_if { |param| tokens.include?(param.to_s) }
+    end
+  end
+end

data/lib/rest_in_peace.rb

@@ -0,0 +1,38 @@
+require 'rest_in_peace/definition_proxy'
+
+module RESTinPeace
+
+  def self.included(base)
+    base.send :extend, ClassMethods
+  end
+
+  def api
+    self.class.api
+  end
+
+  def initialize(attributes = {})
+    update_from_hash(attributes)
+  end
+
+  def to_h
+    Hash[each_pair.to_a]
+  end
+
+  protected
+
+  def update_from_hash(hash)
+    hash.each do |key, value|
+      next unless self.class.members.map(&:to_s).include?(key.to_s)
+      send("#{key}=", value)
+    end
+  end
+
+  module ClassMethods
+    attr_accessor :api
+
+    def rest_in_peace(&block)
+      definition_proxy = RESTinPeace::DefinitionProxy.new(self)
+      definition_proxy.instance_eval(&block)
+    end
+  end
+end

data/rest-in-peace.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+#
+$:.push File.expand_path('../lib', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = 'rest-in-peace'
+  s.version     = File.read(File.expand_path('../VERSION', __FILE__)).strip
+  s.authors     = ['Raffael Schmid']
+  s.email       = ['raffael.schmid@nine.ch']
+  s.homepage    = 'http://github.com/ninech/'
+  s.license     = 'MIT'
+  s.summary     = 'REST in peace'
+  s.description = 'Let your api REST in peace.'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  s.add_development_dependency 'rake', '~> 10.0'
+  s.add_development_dependency 'rspec', '~> 3.0'
+  s.add_development_dependency 'guard', '~> 2.6.1'
+  s.add_development_dependency 'guard-rspec', '~> 4.2.0'
+  s.add_development_dependency 'simplecov', '~> 0.8.2'
+end

data/spec/rest_in_peace/api_call_spec.rb

@@ -0,0 +1,54 @@
+require 'rest_in_peace/api_call'
+require 'ostruct'
+
+describe RESTinPeace::ApiCall do
+  let(:api) { double }
+  let(:url_template) { '/rip/:id' }
+  let(:klass) { OpenStruct }
+  let(:params) { {id: 1} }
+
+  let(:api_call) { RESTinPeace::ApiCall.new(api, url_template, klass, params) }
+
+  let(:response) { OpenStruct.new(body: []) }
+
+  describe '#get' do
+    context 'with enough parameters for the template' do
+      it 'calls the api with the parameters' do
+        expect(api).to receive(:get).with('/rip/1', {}).and_return(response)
+        api_call.get
+      end
+    end
+
+    context 'with more parameters than needed' do
+      let(:params) { { id: 1, name: 'test' } }
+      it 'uses also the additional parameters' do
+        expect(api).to receive(:get).with('/rip/1', { name: 'test' }).and_return(response)
+        api_call.get
+      end
+    end
+  end
+
+  describe '#post' do
+    let(:url_template) { '/rip' }
+    let(:params) { { name: 'test' } }
+    it 'calls the api with the parameters' do
+      expect(api).to receive(:post).with('/rip', { name: 'test' }).and_return(response)
+      api_call.post
+    end
+  end
+
+  describe '#patch' do
+    let(:params) { { id: 1, name: 'test' } }
+    it 'calls the api with the parameters' do
+      expect(api).to receive(:patch).with('/rip/1', { name: 'test' }).and_return(response)
+      api_call.patch
+    end
+  end
+
+  describe '#delete' do
+    it 'calls the api with the parameters' do
+      expect(api).to receive(:delete).with('/rip/1', {}).and_return(response)
+      api_call.delete
+    end
+  end
+end

data/spec/rest_in_peace/definition_proxy/collection_method_definitions_spec.rb

@@ -0,0 +1,80 @@
+require 'rest_in_peace'
+require 'rest_in_peace/definition_proxy/collection_method_definitions'
+
+describe RESTinPeace::DefinitionProxy::CollectionMethodDefinitions do
+  let(:method_name) { :find }
+  let(:url_template) { '/a/:id' }
+  let(:default_params) { {} }
+  let(:struct) { Struct.new(:id, :name) }
+  let(:target) do
+    Class.new(struct) do
+      include RESTinPeace
+    end
+  end
+  let(:definitions) { described_class.new(target) }
+  let(:api_call_double) { object_double(RESTinPeace::ApiCall.new(target.api, url_template, definitions, default_params)) }
+
+  subject { definitions }
+
+  before do
+    allow(RESTinPeace::ApiCall).to receive(:new).and_return(api_call_double)
+  end
+
+  context '#get' do
+    it 'defines a singleton method on the target' do
+      expect { subject.get(:find, '/a/:id', default_params) }.
+        to change { target.respond_to?(:find) }.from(false).to(true)
+    end
+
+    describe 'the created method' do
+      before do
+        allow(api_call_double).to receive(:get)
+      end
+
+      context 'without a paginator' do
+        it 'does not extend api call' do
+          expect(api_call_double).to_not receive(:extend)
+
+          subject.get(:find, '/a/:id', default_params)
+          target.find(1)
+        end
+      end
+
+      context 'with a paginator' do
+        it 'extends api call' do
+          expect(api_call_double).to receive(:extend)
+
+          subject.get(:find, '/a/:id', default_params.merge(paginate_with: Module))
+          target.find(1)
+        end
+      end
+
+      describe 'parameter and arguments handling' do
+        it 'converts the parameters' do
+          expect(RESTinPeace::ApiCall).to receive(:new).
+            with(target.api, '/a/:id', target, {id: 1}).
+            and_return(api_call_double)
+
+          subject.get(:find, '/a/:id', default_params)
+          target.find(1)
+        end
+
+        it 'appends the given attributes' do
+          expect(RESTinPeace::ApiCall).to receive(:new).
+            with(target.api, '/a', target, {name: 'daniele', last_name: 'in der o'}).
+            and_return(api_call_double)
+
+          subject.get(:all, '/a', {last_name: 'in der o'})
+          target.all(name: 'daniele')
+        end
+
+        it 'does not modify the default params' do
+          default_params = { per_page: 250 }
+          subject.get(:find, '/a/:id', default_params)
+          target.find(1)
+          expect(default_params).to eq({ per_page: 250 })
+        end
+      end
+    end
+  end
+end

data/spec/rest_in_peace/definition_proxy/resource_method_definitions_spec.rb

@@ -0,0 +1,77 @@
+require 'rest_in_peace'
+require 'rest_in_peace/definition_proxy/resource_method_definitions'
+
+describe RESTinPeace::DefinitionProxy::ResourceMethodDefinitions do
+  let(:struct) { Struct.new(:id, :name) }
+  let(:target) do
+    Class.new(struct) do
+      include RESTinPeace
+    end
+  end
+  let(:instance) { target.new }
+  let(:definitions) { described_class.new(target) }
+  let(:api_call_double) { object_double(RESTinPeace::ApiCall.new(target.api, '/a/:id', definitions, {})) }
+
+  subject { definitions }
+
+  before do
+    allow(RESTinPeace::ApiCall).to receive(:new).and_return(api_call_double)
+  end
+
+  shared_examples_for 'an instance method' do
+    it 'defines a singleton method on the target' do
+      expect { subject.send(http_verb, method_name, url_template) }.
+        to change { instance.respond_to?(method_name) }.from(false).to(true)
+    end
+
+    describe 'the created method' do
+      before do
+        allow(api_call_double).to receive(http_verb)
+      end
+
+      describe 'parameter and arguments handling' do
+        it 'uses the attributes of the class' do
+          expect(RESTinPeace::ApiCall).to receive(:new).
+            with(target.api, url_template, instance, instance.to_h).
+            and_return(api_call_double)
+
+          subject.send(http_verb, method_name, url_template)
+          instance.send(method_name)
+        end
+      end
+    end
+  end
+
+  context '#get' do
+    it_behaves_like 'an instance method' do
+      let(:http_verb) { :get }
+      let(:method_name) { :reload }
+      let(:url_template) { '/a/:id' }
+    end
+  end
+
+  context '#patch' do
+    it_behaves_like 'an instance method' do
+      let(:http_verb) { :patch }
+      let(:method_name) { :save }
+      let(:url_template) { '/a/:id' }
+    end
+  end
+
+  context '#post' do
+    it_behaves_like 'an instance method' do
+      let(:http_verb) { :post }
+      let(:method_name) { :create }
+      let(:url_template) { '/a/:id' }
+    end
+  end
+
+  context '#delete' do
+    it_behaves_like 'an instance method' do
+      let(:http_verb) { :delete }
+      let(:method_name) { :destroy }
+      let(:url_template) { '/a/:id' }
+    end
+  end
+
+end

data/spec/rest_in_peace/definition_proxy_spec.rb

@@ -0,0 +1,36 @@
+require 'rest_in_peace/definition_proxy'
+
+describe RESTinPeace::DefinitionProxy do
+  let(:resource_definitions) { object_double(RESTinPeace::DefinitionProxy::ResourceMethodDefinitions) }
+  let(:collection_definitions) { object_double(RESTinPeace::DefinitionProxy::CollectionMethodDefinitions) }
+  let(:target) { }
+  let(:proxy) { RESTinPeace::DefinitionProxy.new(target) }
+  let(:test_proc) { ->() {} }
+
+  subject { proxy }
+
+  before do
+    allow(RESTinPeace::DefinitionProxy::ResourceMethodDefinitions).
+      to receive(:new).with(target).and_return(resource_definitions)
+    allow(RESTinPeace::DefinitionProxy::CollectionMethodDefinitions).
+      to receive(:new).with(target).and_return(collection_definitions)
+  end
+
+  describe '#resource' do
+    it 'forwards the given block to a resource method definition' do
+      expect(resource_definitions).to receive(:instance_eval) do |&block|
+        expect(block).to be_instance_of(Proc)
+      end
+      subject.resource(&test_proc)
+    end
+  end
+
+  describe '#collection' do
+    it 'forwards the given block to a collection method definition' do
+      expect(collection_definitions).to receive(:instance_eval) do |&block|
+        expect(block).to be_instance_of(Proc)
+      end
+      subject.collection(&test_proc)
+    end
+  end
+end

data/spec/rest_in_peace/response_converter_spec.rb

@@ -0,0 +1,47 @@
+require 'rest_in_peace/response_converter'
+require 'ostruct'
+
+describe RESTinPeace::ResponseConverter do
+  let(:element1) { { name: 'test1' } }
+  let(:element2) { { name: 'test2' } }
+  let(:response) { OpenStruct.new(body: response_body) }
+  let(:converter) { RESTinPeace::ResponseConverter.new(response, klass) }
+
+  describe '#result' do
+    subject { converter.result }
+
+    shared_examples_for 'an array input' do
+      let(:response_body) { [element1, element2] }
+      specify { expect(subject).to be_instance_of(Array) }
+      specify { expect(subject).to eq([OpenStruct.new(name: 'test1'), OpenStruct.new(name: 'test2')]) }
+    end
+
+    shared_examples_for 'a hash input' do
+      let(:response_body) { element1 }
+      specify { expect(subject).to be_instance_of(OpenStruct) }
+      specify { expect(subject).to eq(OpenStruct.new(name: 'test1')) }
+    end
+
+    context 'given type is a class' do
+      let(:klass) { OpenStruct }
+      context 'input is an array' do
+        it_behaves_like 'an array input'
+      end
+
+      context 'input is a hash' do
+        it_behaves_like 'a hash input'
+      end
+    end
+
+    context 'given type is an instance' do
+      let(:klass) { OpenStruct.new }
+      context 'input is an array' do
+        it_behaves_like 'an array input'
+      end
+
+      context 'input is a hash' do
+        it_behaves_like 'a hash input'
+      end
+    end
+  end
+end

data/spec/rest_in_peace/template_sanitizer_spec.rb

@@ -0,0 +1,64 @@
+require 'rest_in_peace/template_sanitizer'
+
+describe RESTinPeace::TemplateSanitizer do
+
+  let(:template_sanitizer) { RESTinPeace::TemplateSanitizer.new(url_template, params) }
+
+  describe '#url' do
+    subject { template_sanitizer.url }
+
+    context 'single token' do
+      let(:params) { { id: 1 } }
+      let(:url_template) { '/a/:id' }
+      specify { expect(subject).to eq('/a/1') }
+    end
+
+    context 'multiple token' do
+      let(:params) { { id: 2, a_id: 1 } }
+      let(:url_template) { '/a/:a_id/b/:id' }
+      specify { expect(subject).to eq('/a/1/b/2') }
+    end
+
+    context 'incomplete params' do
+      let(:params) { {} }
+      let(:url_template) { '/a/:id' }
+      specify { expect { subject }.to raise_error(RESTinPeace::TemplateSanitizer::IncompleteParams) }
+    end
+
+    context 'immutability of the url template' do
+      let(:params) { { id: 1 } }
+      let(:url_template) { '/a/:id' }
+      specify { expect { subject }.to_not change { url_template } }
+    end
+
+    context 'immutability of the params' do
+      let(:params) { { id: 1 } }
+      let(:url_template) { '/a/:id' }
+      specify { expect { subject }.to_not change { params } }
+    end
+  end
+
+  describe '#tokens' do
+    let(:params) { {} }
+
+    context 'single token' do
+      let(:url_template) { '/a/:id' }
+      subject { template_sanitizer.tokens }
+      specify { expect(subject).to eq(%w(id)) }
+    end
+
+    context 'multiple tokens' do
+      let(:url_template) { '/a/:a_id/b/:id' }
+      subject { template_sanitizer.tokens }
+      specify { expect(subject).to eq(%w(a_id id)) }
+    end
+  end
+
+  describe '#leftover_params' do
+    let(:params) { { id: 1, name: 'test' } }
+    let(:url_template) { '/a/:id' }
+    subject { template_sanitizer.leftover_params }
+
+    specify { expect(subject).to eq({name: 'test'}) }
+  end
+end

data/spec/rest_in_peace_spec.rb

@@ -0,0 +1,55 @@
+require 'rest_in_peace'
+
+describe RESTinPeace do
+
+  let(:struct) { Struct.new(:name) }
+  let(:extended_class) do
+    Class.new(struct) do
+      include RESTinPeace
+    end
+  end
+  let(:attributes) { { name: 'test' } }
+  let(:instance) { extended_class.new(attributes) }
+
+  describe '::api' do
+    subject { extended_class }
+    specify { expect(subject).to respond_to(:api).with(0).arguments }
+  end
+
+  describe '::rest_in_peace' do
+    subject { extended_class }
+    specify { expect(subject).to respond_to(:rest_in_peace).with(0).arguments }
+    let(:definition_proxy) { object_double(RESTinPeace::DefinitionProxy) }
+
+
+    it 'evaluates the given block inside the definition proxy' do
+      allow(RESTinPeace::DefinitionProxy).to receive(:new).with(subject).and_return(definition_proxy)
+      expect(definition_proxy).to receive(:instance_eval) do |&block|
+        expect(block).to be_instance_of(Proc)
+      end
+      subject.rest_in_peace { }
+    end
+  end
+
+  describe '#api' do
+    subject { instance }
+    specify { expect(subject).to respond_to(:api).with(0).arguments }
+  end
+
+  describe '#to_h' do
+    subject { instance }
+    specify { expect(subject).to respond_to(:to_h).with(0).arguments }
+  end
+
+  describe '#initialize' do
+    subject { instance }
+    specify { expect(subject.name).to eq('test') }
+
+    context 'unknown params' do
+      let(:attributes) { { name: 'test42', email: 'yolo@example.org' } }
+      specify { expect(subject.name).to eq('test42') }
+      specify { expect { subject.email }.to raise_error(NoMethodError) }
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,61 @@
+require 'simplecov'
+SimpleCov.start
+
+RSpec.configure do |config|
+  # 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
+
+  # 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
+
+  # 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|
+    # Enable only the newer, non-monkey-patching expect syntax.
+    # For more details, see:
+    #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+    expectations.syntax = :expect
+  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|
+    # Enable only the newer, non-monkey-patching expect syntax.
+    # For more details, see:
+    #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+    mocks.syntax = :expect
+
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended.
+    mocks.verify_partial_doubles = true
+  end
+end

metadata

@@ -0,0 +1,166 @@
+--- !ruby/object:Gem::Specification
+name: rest-in-peace
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Raffael Schmid
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.6.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.6.1
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.2
+description: Let your api REST in peace.
+email:
+- raffael.schmid@nine.ch
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .ruby-gemset
+- .ruby-version
+- .travis.yml
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- examples/pagination_with_headers.rb
+- images/rest_in_peace.gif
+- lib/rest-in-peace.rb
+- lib/rest_in_peace.rb
+- lib/rest_in_peace/api_call.rb
+- lib/rest_in_peace/definition_proxy.rb
+- lib/rest_in_peace/definition_proxy/collection_method_definitions.rb
+- lib/rest_in_peace/definition_proxy/resource_method_definitions.rb
+- lib/rest_in_peace/errors.rb
+- lib/rest_in_peace/response_converter.rb
+- lib/rest_in_peace/ssl_config_creator.rb
+- lib/rest_in_peace/template_sanitizer.rb
+- rest-in-peace.gemspec
+- spec/rest_in_peace/api_call_spec.rb
+- spec/rest_in_peace/definition_proxy/collection_method_definitions_spec.rb
+- spec/rest_in_peace/definition_proxy/resource_method_definitions_spec.rb
+- spec/rest_in_peace/definition_proxy_spec.rb
+- spec/rest_in_peace/response_converter_spec.rb
+- spec/rest_in_peace/template_sanitizer_spec.rb
+- spec/rest_in_peace_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/ninech/
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23.2
+signing_key: 
+specification_version: 3
+summary: REST in peace
+test_files:
+- spec/rest_in_peace/api_call_spec.rb
+- spec/rest_in_peace/definition_proxy/collection_method_definitions_spec.rb
+- spec/rest_in_peace/definition_proxy/resource_method_definitions_spec.rb
+- spec/rest_in_peace/definition_proxy_spec.rb
+- spec/rest_in_peace/response_converter_spec.rb
+- spec/rest_in_peace/template_sanitizer_spec.rb
+- spec/rest_in_peace_spec.rb
+- spec/spec_helper.rb