jeckle 0.0.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2874609cdcb236683601a9e04386dd1af3e6b3a3
-  data.tar.gz: fb456e8f4ff54cd39541841f816ee92721c92f05
+  metadata.gz: be467f303f461477c44a2ff12a334918e42cf833
+  data.tar.gz: 73c1eca8358f96530eabf65c5398898c3f516e18
 SHA512:
-  metadata.gz: ac05f0824c301b8d843d5430084f5edec19d24143bff31cfacb96764f19702b6cc9307e92c6907f522acd47406686f82e399c556e01881033e17a4e82999a498
-  data.tar.gz: 46639dc59b51171ef4a8fe63aa8c91b0d659a8d10f219b4e769ce42e9445118de076eb4229fb1ab1cdc5823497f3200f9e17657bcac0efe748542209a36d0249
+  metadata.gz: 69e64c0210fde8e8b577ad46b00f0bbca449fb234940bb5236f40838d7fbd9912fca85776328a9d126b1d495f736b191d04468b62a9871dd02ba8613de9d1ac2
+  data.tar.gz: 945e10b3420ba0b94f59358eeab47ac976bcf07eae78d1c6c699f5e634ecbfc2856b92f2c74bdef58f8c1b3c26c00280319124be0f95d631b8261f5fb1820392

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -0,0 +1,14 @@
+language: ruby
+script:
+  - bundle exec rspec spec
+rvm:
+  - rbx-2
+  - jruby-head
+  - ruby-head
+  - ruby
+  - jruby
+  - 2.1.0
+  - 2.0.0
+  - 1.9.3
+env:
+  - CODECLIMATE_REPO_TOKEN=71bc27cbd607a9f50ee1d314ad3f74e7d670e42afe3e01d99d7bc1cd6b65524b

data/Gemfile

@@ -2,3 +2,5 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in jeckle.gemspec
 gemspec
+
+gem 'codeclimate-test-reporter', group: :test, require: nil

data/README.md

@@ -1,9 +1,21 @@
 # Jeckle
 
-TODO: Write a gem description
+[![Build Status](https://travis-ci.org/tomas-stefano/jeckle.svg?branch=master)](https://travis-ci.org/tomas-stefano/jeckle)
+[![Code Climate](https://codeclimate.com/github/tomas-stefano/jeckle.png)](https://codeclimate.com/github/tomas-stefano/jeckle)
+[![Test Coverage](https://codeclimate.com/github/tomas-stefano/jeckle/coverage.png)](https://codeclimate.com/github/tomas-stefano/jeckle)
+
+Wrap APIs with easiness and flexibility.
 
 <img src="http://www.toonopedia.com/hekljekl.jpg" alt="Jeckle" />
 
+> Heckle usually refers to Jeckle familiarly, as "chum" or "pal", while Jeckle
+often calls Heckle "old chap", "old thing", "old boy" or "old featherhead",
+indicating a close friendship between them.
+
+<small>*[Extracted from Wikipedia](http://en.wikipedia.org/wiki/Heckle_and_Jeckle)*</small>
+
+Let third party APIs be Heckle for your app's Jeckle.
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -14,6 +26,47 @@ And then execute:
 
     $ bundle
 
-Or install it yourself as:
+### For Rails applications
+
+We recommend to create a initializer:
+
+```ruby
+# config/initializers/jeckle.rb
+
+Jeckle.configure do |config|
+  config.register :some_service do |api|
+    api.base_uri = 'http://api.someservice.com'
+    api.headers = {
+      'Accept' => 'application/json'
+    }
+    api.namespaces = { prefix: 'api', version: 'v1' }
+    api.logger = Rails.logger
+    api.read_timeout = 5
+  end
+end
+```
+
+And then put your API stuff scoped inside a `services` folder:
+
+```ruby
+# app/services/some_service/models/my_resource.rb
+
+module SomeService
+  module Models
+    class MyResource
+      include Jeckle::Resource
+
+      default_api :some_service
+
+      attribute :id
+    end
+  end
+end
+```
+
+## Roadmap
 
-    $ gem install jeckle
+- Faraday middleware abstraction
+- Per action API
+- Comprehensive restful actions
+- Testability

data/Rakefile

@@ -1 +1 @@
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'

data/examples/dribbble.rb

@@ -0,0 +1,29 @@
+require 'jeckle'
+
+Jeckle.configure do |config|
+  config.register :dribbble do |api|
+    api.base_uri = 'http://api.dribbble.com'
+  end
+end
+
+class Shot
+  include Jeckle::Resource
+
+  default_api :dribbble
+
+  attribute :id, Integer
+  attribute :name, String
+  attribute :url, String
+  attribute :image_url, String
+end
+
+shot = Shot.find 1600459
+
+shot.id
+# => 1600459
+
+shot.name
+# => Daryl Heckle And Jeckle Oates
+
+shot.image_url
+# => https://d13yacurqjgara.cloudfront.net/users/85699/screenshots/1600459/daryl_heckle_and_jeckle_oates-dribble.jpg

data/jeckle.gemspec

@@ -1,29 +1,39 @@
-# coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
 require 'jeckle/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "jeckle"
+  spec.name          = 'jeckle'
   spec.version       = Jeckle::VERSION
-  spec.authors       = ["Tomas D'Stefano"]
-  spec.email         = ["tomas_stefano@successoft.com"]
-  spec.description   = %q{Simple module for build client apis}
-  spec.summary       = %q{Simple module for build client apis}
-  spec.homepage      = "https://github.com/tomas-stefano/jeckle"
-  spec.license       = "MIT"
+  spec.authors       = ['Tomas D\'Stefano', 'Brenno Costa']
+  spec.email         = ['tomas_stefano@successoft.com', 'brennolncosta@gmail.com']
+  spec.description   = %q{Simple module for building client APIs}
+  spec.summary       = %q{Simple module for building client APIs}
+  spec.homepage      = 'https://github.com/tomas-stefano/jeckle'
+  spec.license       = 'MIT'
 
   spec.files         = `git ls-files`.split($/)
   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.require_paths = ['lib']
 
-  spec.add_dependency 'httparty'
-  spec.add_dependency 'virtus'
   spec.add_dependency 'activemodel', '>= 4.0'
-  spec.add_dependency 'activesupport', '>= 4.0'
+  spec.add_dependency 'faraday', '~> 0.9'
+  spec.add_dependency 'faraday_middleware'
+  spec.add_dependency 'virtus', '~> 1.0'
 
-  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'bundler', '~> 1.6'
   spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rspec', '~> 3.1'
+
+  if RUBY_ENGINE == 'rbx'
+    spec.add_development_dependency 'rubinius-compiler'
+    spec.add_development_dependency 'rubinius-debugger'
+  elsif RUBY_ENGINE == 'jruby'
+    spec.add_development_dependency 'pry'
+  else
+    spec.add_development_dependency 'pry-nav' if RUBY_VERSION < '2.0.0'
+    spec.add_development_dependency 'pry-byebug' if RUBY_VERSION >= '2.0.0'
+  end
 end

data/lib/jeckle/api.rb

@@ -0,0 +1,55 @@
+module Jeckle
+  class API
+    attr_accessor :logger
+    attr_writer :base_uri, :namespaces, :params, :headers, :open_timeout, :read_timeout
+    attr_reader :basic_auth, :request_timeout
+
+    def connection
+      @connection ||= Faraday.new(url: base_uri, request: timeout).tap do |conn|
+        conn.headers = headers
+        conn.params = params
+        conn.response :logger, logger
+
+        conn.basic_auth basic_auth[:username], basic_auth[:password] if basic_auth
+        conn.instance_exec &@middlewares_block if @middlewares_block
+      end
+    end
+
+    def basic_auth=(credential_params)
+      [:username, :password].all? do |key|
+        credential_params.has_key? key
+      end or raise Jeckle::NoUsernameOrPasswordError, credential_params
+
+      @basic_auth = credential_params
+    end
+
+    def base_uri
+      [@base_uri, *namespaces.values].join '/'
+    end
+
+    def params
+      @params || {}
+    end
+
+    def headers
+      @headers || {}
+    end
+
+    def namespaces
+      @namespaces || {}
+    end
+
+    def middlewares(&block)
+      raise Jeckle::ArgumentError, 'A block is required when configuring API middlewares' unless block_given?
+
+      @middlewares_block = block
+    end
+
+    def timeout
+      {}.tap do |t|
+        t[:open_timeout] = @open_timeout if @open_timeout
+        t[:timeout] = @read_timeout if @read_timeout
+      end
+    end
+  end
+end

data/lib/jeckle/errors.rb

@@ -0,0 +1,29 @@
+module Jeckle
+  class ArgumentError < ::ArgumentError; end
+
+  class NoSuchAPIError < ArgumentError
+    def initialize(api)
+      message = %{The API name '#{api}' doesn't exist in Jeckle definitions.
+
+        Heckle: - Hey chum, what we can do now?
+        Jeckle: - Old chap, you need to put the right API name!
+        Heckle: - Hey pal, tell me the APIs then!
+        Jeckle: - Deal the trays, old thing: #{Jeckle::Setup.registered_apis.keys}.
+      }
+
+      super message
+    end
+  end
+
+  class NoUsernameOrPasswordError < ArgumentError
+    def initialize(credentials)
+      message = %{No such keys "username" and "password" on `basic_auth` definition"
+
+        Heckle: - Hey chum, what we can do now?
+        Jeckle: - Old chap, you need to define a username and a password for basic auth!
+      }
+
+      super message
+    end
+  end
+end

data/lib/jeckle/model.rb

@@ -0,0 +1,8 @@
+module Jeckle
+  module Model
+    def self.included(base)
+      base.send :include, ActiveModel::Validations
+      base.send :include, Virtus.model
+    end
+  end
+end

data/lib/jeckle/request.rb

@@ -0,0 +1,33 @@
+module Jeckle
+  class Request
+    attr_reader :api, :body, :headers, :method, :params, :response, :endpoint
+
+    def initialize(api, endpoint, options = {})
+      @api = api
+
+      @method = options.delete(:method) || :get
+      @body = options.delete(:body) if %w(post put).include?(method.to_s)
+      @headers = options.delete(:headers)
+
+      @endpoint = endpoint
+      @params = options
+
+      @response = perform_api_request
+    end
+
+    def self.run(*args)
+      new *args
+    end
+
+    private
+
+    def perform_api_request
+      api.connection.public_send method do |api_request|
+        api_request.url endpoint
+        api_request.params = params
+        api_request.body = body
+        api_request.headers = api_request.headers.merge(headers) if headers
+      end
+    end
+  end
+end

data/lib/jeckle/resource.rb

@@ -1,52 +1,49 @@
 module Jeckle
   module Resource
-    extend ActiveSupport::Concern
+    def self.included(base)
+      base.send :include, Jeckle::Model
+      base.send :include, ActiveModel::Naming
 
-    included do
-      include HTTParty
-      include Virtus.model
-      include ActiveModel::Validations
-
-      attribute :response
+      base.send :extend, Jeckle::Resource::ClassMethods
     end
 
     module ClassMethods
-      def resource_name
-        self.class.name.underscore
+      def inherited(base)
+        base.class_eval do
+          @api_mapping = superclass.api_mapping.dup
+        end
       end
 
-      def find(id)
-        get(resource_action)
+      def resource_name
+        model_name.element.pluralize
       end
 
-      def resource_action(id)
-        "#{resource_name}/#{id}"
+      def default_api(registered_api_name)
+        api_mapping[:default_api] = Jeckle::Setup.registered_apis.fetch(registered_api_name)
+      rescue KeyError => e
+        raise Jeckle::NoSuchAPIError, registered_api_name
       end
-    end
-
-    def save
-      request(:post)
-    end
 
-    def update
-      request(:put)
-    end
+      def api_mapping
+        @api_mapping ||= {}
+      end
 
-    def headers
-      {
-        'Content-Type'    => 'application/json; charset="UTF-8"',
-        'Accept-Encoding' => 'application/json'
-      }
-    end
+      def find(id)
+        endpoint = "#{resource_name}/#{id}"
+        attributes = run_request(endpoint).response.body
 
-    private
+        new attributes
+      end
 
-    def request(http_method)
-      return false if invalid?
+      def search(params = {})
+        collection = run_request(resource_name, params).response.body || []
 
-      @response = self.class.send(http_method, resource_name, headers: headers, body: params)
+        collection.collect { |attrs| new attrs }
+      end
 
-      @response.success?
+      def run_request(endpoint, options = {})
+        Jeckle::Request.run api_mapping[:default_api], endpoint, options
+      end
     end
   end
-end
+end

data/lib/jeckle/setup.rb

@@ -0,0 +1,28 @@
+module Jeckle
+  class Setup
+    # Register apis, providing all the configurations to it.
+    #
+    # @example
+    #
+    #    Jeckle.configure do |config|
+    #      config.register :my_api_restful do |api|
+    #        api.basic_auth = { username: 'chucknorris', password: 'nowThatYouKnowYouMustDie' }
+    #        api.namespaces = { version: 'v2' }
+    #        api.base_uri = 'myapi.com'
+    #        api.headers = { 'Content-Type' => 'application/whatever.complex.header.v2+json;charset=UTF-8' }
+    #        api.logger = Rails.logger # or any other logger
+    #      end
+    #    end
+    #
+    def self.register(name)
+      Jeckle::API.new.tap do |user_api|
+        yield user_api
+        registered_apis[name] = user_api
+      end
+    end
+
+    def self.registered_apis
+      @registered_apis ||= {}
+    end
+  end
+end

data/lib/jeckle/version.rb

@@ -1,3 +1,3 @@
 module Jeckle
-  VERSION = '0.0.1'
+  VERSION = '0.2.0'
 end

data/lib/jeckle.rb

@@ -1,11 +1,19 @@
-require 'jeckle/version'
-require 'active_support/dependencies/autoload'
-require 'active_support/concern'
-require 'virtus'
 require 'active_model'
+require 'faraday'
+require 'faraday_middleware'
+require 'virtus'
 
-module Jeckle
-  extend ActiveSupport::Autoload
+require 'jeckle/version'
+
+%w(setup api model request resource errors).each do |file_name|
+  require "jeckle/#{file_name}"
+end
 
-  autoload :Resource
+module Jeckle
+  # Configure APIs to be used on Jeckle::Resources.
+  # See Jeckle::Setup for more information.
+  #
+  def self.configure
+    yield Jeckle::Setup
+  end
 end

data/spec/fixtures/jeckle_config.rb

@@ -0,0 +1,31 @@
+Jeckle::Setup.register(:my_super_api) do |api|
+  api.base_uri = 'http://my-super-api.com.br'
+  api.headers = { 'Content-Type' => 'application/json' }
+  api.logger = Logger.new(STDOUT)
+  api.basic_auth = { username: 'steven_seagal', password: 'youAlwaysLose' }
+  api.namespaces = { prefix: 'api', version: 'v1' }
+  api.params = { hello: 'world' }
+  api.open_timeout = 2
+  api.read_timeout = 5
+
+  api.middlewares do
+    request :json
+    response :json
+    response :raise_error
+  end
+end
+
+Jeckle::Setup.register(:another_api) do |api|
+  api.base_uri = 'http://another-api.com.br'
+  api.headers = { 'Content-Type' => 'application/json' }
+  api.logger = Logger.new(STDOUT)
+  api.basic_auth = { username: 'heisenberg', password: 'metaAfetaAMina' }
+  api.namespaces = { prefix: 'api', version: 'v5' }
+  api.params = { hi: 'there' }
+
+  api.middlewares do
+    request :json
+    response :json
+    response :raise_error
+  end
+end

data/spec/fixtures/models/fake_model.rb

@@ -0,0 +1,3 @@
+class FakeModel
+  include Jeckle::Model
+end

data/spec/fixtures/resources/fake_resource.rb

@@ -0,0 +1,7 @@
+class FakeResource
+  include Jeckle::Resource
+
+  default_api :my_super_api
+
+  attribute :id, Integer
+end

data/spec/jeckle/api_spec.rb

@@ -0,0 +1,180 @@
+require 'spec_helper'
+
+RSpec.describe Jeckle::API do
+  subject(:jeckle_api) { Jeckle::Setup.registered_apis[:my_super_api] }
+
+  describe '#connection' do
+    before { jeckle_api.instance_variable_set(:@connection, nil) }
+
+    let(:fake_faraday_connection) { Faraday::Connection.new }
+
+    it 'returns a Faraday connection' do
+      expect(jeckle_api.connection).to be_kind_of Faraday::Connection
+    end
+
+    it 'caches the connection' do
+      expect(Faraday).to receive(:new).once.and_return(fake_faraday_connection)
+        .with(url: jeckle_api.base_uri, request: jeckle_api.timeout)
+
+      expect(fake_faraday_connection).to receive(:tap).once.and_call_original
+
+      10.times { jeckle_api.connection }
+    end
+
+    it 'assigns api_headers' do
+      expect(jeckle_api.connection.headers).to include 'Content-Type' => 'application/json'
+    end
+
+    it 'assigns basic auth headers' do
+      expect(jeckle_api.connection.headers.keys).to include 'Authorization'
+    end
+
+    it 'assigns params there will be used on all requests' do
+      expect(jeckle_api.connection.params).to eq 'hello' => 'world'
+    end
+
+    it 'assigns timeout options' do
+      expect(jeckle_api.connection.options.open_timeout).to eq 2
+      expect(jeckle_api.connection.options.timeout).to eq 5
+    end
+
+    context 'when middlewares_block is set' do
+      before do
+        jeckle_api.middlewares do
+          request :retry, max: 2, interval: 0.05
+          request :instrumentation
+        end
+      end
+
+      it 'adds middlewares on connection middleware stack' do
+        expect(jeckle_api.connection.builder.handlers.last(2)).to eq [
+          Faraday::Request::Retry,
+          Faraday::Request::Instrumentation
+        ]
+      end
+    end
+  end
+
+  describe '#base_uri' do
+    context 'when namespaces are defined' do
+      it 'appends namespaces' do
+        expect(jeckle_api.base_uri).to eq 'http://my-super-api.com.br/api/v1'
+      end
+    end
+
+    context 'when no namespaces are defined' do
+      subject(:jeckle_api) { described_class.new }
+
+      before { jeckle_api.base_uri = 'http://my-super-api.com.br' }
+
+      it 'keeps base_uri without adding namespaces or futher slashes' do
+        expect(jeckle_api.base_uri).to eq 'http://my-super-api.com.br'
+      end
+    end
+  end
+
+  describe '#basic_auth=' do
+    subject(:jeckle_api) { described_class.new }
+
+    context 'when there is the required credentials' do
+      let(:credentials) { { username: 'sly', password: 'IAmTheLaw'} }
+
+      before { jeckle_api.basic_auth = credentials }
+
+      it 'assigns creditals hash' do
+        expect(jeckle_api.basic_auth).to eq credentials
+      end
+    end
+
+    context 'when required creadentials is missing' do
+      let(:credentials) { {} }
+
+      it 'raises a argument error NoUsernameOrPasswordError' do
+        expect { jeckle_api.basic_auth = credentials }.to raise_error Jeckle::NoUsernameOrPasswordError
+      end
+    end
+  end
+
+  describe '#params' do
+    context 'when there are params' do
+      it 'assigns params hash' do
+        expect(jeckle_api.params).to eq hello: 'world'
+      end
+    end
+
+    context 'when there are no params' do
+      subject(:jeckle_api) { described_class.new }
+
+      it 'assigns an empty hash' do
+        expect(jeckle_api.params).to eq({})
+      end
+    end
+  end
+
+  describe '#headers' do
+    context 'when there are headers' do
+      it 'assigns headers hash' do
+        expect(jeckle_api.headers).to eq 'Content-Type' => 'application/json'
+      end
+    end
+
+    context 'when there are no headers' do
+      subject(:jeckle_api) { described_class.new }
+
+      it 'assigns an empty hash' do
+        expect(jeckle_api.headers).to eq({})
+      end
+    end
+  end
+
+  describe '#middlewares' do
+    context 'when a block is given' do
+      it 'assigns middleware_block' do
+        jeckle_api.middlewares { 123 }
+
+        expect(jeckle_api.instance_variable_get('@middlewares_block')).not_to be_nil
+      end
+    end
+
+    context 'when no block is given' do
+      it 'raises ArgumentError' do
+        expect {
+          jeckle_api.middlewares
+        }.to raise_error Jeckle::ArgumentError, /A block is required when configuring API middlewares/
+      end
+    end
+  end
+
+  describe '#timeout' do
+    let(:timeout) { nil }
+    let(:open_timeout) { nil }
+
+    before do
+      jeckle_api.open_timeout = open_timeout
+      jeckle_api.read_timeout = timeout
+    end
+
+    context 'when no timeout is defined' do
+      it 'returns empty hash' do
+        expect(jeckle_api.timeout).to eq({})
+      end
+    end
+
+    context 'when a read_timeout is defined' do
+      let(:timeout) { 5 }
+
+      it 'returns a hash with assgned option' do
+        expect(jeckle_api.timeout).to eq timeout: timeout
+      end
+    end
+
+    context 'when two timeouts are defined for both open and read' do
+      let(:timeout) { 5 }
+      let(:open_timeout) { 2 }
+
+      it 'returns a hash correctly assigned open and read timeouts' do
+        expect(jeckle_api.timeout).to eq open_timeout: open_timeout, timeout: timeout
+      end
+    end
+  end
+end

data/spec/jeckle/model_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+RSpec.describe Jeckle::Model do
+  it 'includes active_model/validations' do
+    expect(FakeModel.ancestors).to include ActiveModel::Validations
+  end
+
+  it 'includes virtus' do
+    expect(FakeModel.ancestors).to include Virtus::Model::Core
+  end
+end

data/spec/jeckle/request_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+RSpec.describe Jeckle::Request do
+  let(:api) { Jeckle::Setup.registered_apis[:my_super_api] }
+
+  before do
+    # Manipulate Faraday internals to avoid real requests
+    class FakeRackBuilder; def build_response(conn, req); end; end
+    fake_builder = FakeRackBuilder.new
+
+    allow(api.connection).to receive(:builder).and_return(fake_builder)
+  end
+
+  describe '.run' do
+    before { allow(api.connection).to receive(http_method).and_call_original }
+
+    context 'GET' do
+      let(:options) { {} }
+      let(:endpoint) { 'fake_resource/4' }
+      let(:http_method) { :get }
+
+      it_behaves_like Jeckle::Request
+
+      it 'calls GET request on API\'s connection' do
+        expect(api.connection).to receive(http_method).and_call_original
+
+        described_class.run api, endpoint, options
+      end
+    end
+
+    context 'POST' do
+      let(:endpoint) { 'fake_resources' }
+      let(:options) { { body: { value: 1000 }, method: http_method } }
+      let(:http_method) { :post }
+
+      it_behaves_like Jeckle::Request
+
+      it 'calls POST request on API\'s connection' do
+        expect(api.connection).to receive(:post).and_call_original
+
+        described_class.run api, endpoint, options
+      end
+    end
+
+    context 'PUT' do
+      let(:endpoint) { 'fake_resources' }
+      let(:options) { { body: { id: 1001, value: 1000 }, method: http_method } }
+      let(:http_method) { :put }
+
+      it_behaves_like Jeckle::Request
+
+      it 'calls PUT request on API\'s connection' do
+        expect(api.connection).to receive(:put).and_call_original
+
+        described_class.run api, endpoint, options
+      end
+    end
+
+    context 'DELETE' do
+      let(:options) { { method: http_method } }
+      let(:endpoint) { 'fake_resource/4' }
+      let(:http_method) { :delete }
+
+      it_behaves_like Jeckle::Request
+
+      it 'calls DELETE request on API\'s connection' do
+        expect(api.connection).to receive(:delete).and_call_original
+
+        described_class.run api, endpoint, options
+      end
+    end
+  end
+end

data/spec/jeckle/resource_spec.rb

@@ -0,0 +1,126 @@
+require 'spec_helper'
+
+RSpec.describe Jeckle::Resource do
+  subject(:fake_resource) { FakeResource.new }
+
+  let(:api) { FakeResource.api_mapping[:default_api] }
+
+  it 'includes jeckle/model' do
+    expect(FakeResource.ancestors).to include Jeckle::Model
+  end
+
+  it 'includes active_model/naming' do
+    expect(FakeResource.ancestors).to include ActiveModel::Naming
+  end
+
+  describe '.resource_name' do
+    it 'returns resource name based on class name' do
+      expect(FakeResource.resource_name).to eq 'fake_resources'
+    end
+
+    context 'when resource class is namespaced' do
+      before do
+        MySuperApi = Module.new
+        MySuperApi::FakeResource = Class.new(::FakeResource)
+      end
+
+      it 'ignores namespace' do
+        expect(MySuperApi::FakeResource.resource_name).to eq 'fake_resources'
+      end
+    end
+  end
+
+  describe '.api_mapping' do
+    it 'returns a hash containing default api' do
+      expect(FakeResource.api_mapping).to match(
+        default_api: an_instance_of(Jeckle::API)
+      )
+    end
+
+    context 'when resource is inherited' do
+      let(:inherited_class) { Class.new(FakeResource) }
+
+      it "contains the parent's api_mapping" do
+        expect(inherited_class.api_mapping).to eq FakeResource.api_mapping
+      end
+
+      context 'when api_mapping is changed' do
+        it "does not affect the parent" do
+          inherited_class.default_api :another_api
+
+          expect(FakeResource.api_mapping).not_to eq inherited_class.api_mapping
+          expect(FakeResource.api_mapping[:default_api]).to eq Jeckle::Setup.registered_apis[:my_super_api]
+        end
+      end
+    end
+  end
+
+  describe '.default_api' do
+    context 'when defining a registered API via Jeckle::Setup' do
+      it 'returns the assigned API' do
+        expect(FakeResource.default_api :my_super_api).to be_kind_of Jeckle::API
+      end
+
+      it 'assigns API do api_mapping' do
+        expect(FakeResource.api_mapping).to have_key :default_api
+      end
+    end
+
+    context 'when defining an inexistent API' do
+      it 'raises NoSuchAPIError' do
+        expect { FakeResource.default_api :unknown_api }.to raise_error Jeckle::NoSuchAPIError
+      end
+    end
+  end
+
+  describe '.find' do
+    let(:fake_request) { OpenStruct.new response: OpenStruct.new(body: { id: 1001 }) }
+
+    it 'calls default API connection with GET' do
+      expect(Jeckle::Request).to receive(:run)
+        .with(api, 'fake_resources/1001', {}).and_return(fake_request)
+
+      FakeResource.find 1001
+    end
+
+    it 'returns an instance of resource' do
+      allow(Jeckle::Request).to receive(:run).and_return(fake_request)
+
+      expect(FakeResource.find 1001).to be_an_instance_of(FakeResource)
+    end
+  end
+
+  describe '.search' do
+    let(:query) { { name: 'cocada' } }
+
+    context 'when there are results' do
+      let(:fake_request) { OpenStruct.new response: OpenStruct.new(body: [{ id: 1001 }, { id: 1002 }]) }
+
+      it 'calls default API connection with GET and search params' do
+        expect(Jeckle::Request).to receive(:run)
+          .with(api, 'fake_resources', query).and_return(fake_request)
+
+        FakeResource.search query
+      end
+
+      it 'returns an Array of resources' do
+        allow(Jeckle::Request).to receive(:run).and_return(fake_request)
+
+        expect(FakeResource.search query).to match [
+          an_instance_of(FakeResource),
+          an_instance_of(FakeResource)
+        ]
+      end
+    end
+
+    context 'when there are no results' do
+      let(:fake_request) { OpenStruct.new response: OpenStruct.new(body: nil) }
+
+      it 'returns an empty Array' do
+        allow(Jeckle::Request).to receive(:run).and_return(fake_request)
+
+        expect(FakeResource.search query).to match []
+      end
+    end
+  end
+end

data/spec/jeckle/setup_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+RSpec.describe Jeckle::Setup do
+  describe '.register' do
+    context 'when block is given' do
+      let(:registered_apis) { Jeckle::Setup.registered_apis }
+
+      it 'returns a new registered API' do
+        expect(registered_apis).to have_key(:my_super_api)
+      end
+
+      describe 'base uri' do
+        it 'assigns to the api instance' do
+          expect(registered_apis[:my_super_api].base_uri).to eq 'http://my-super-api.com.br/api/v1'
+        end
+      end
+
+      describe 'headers' do
+        it 'assigns to the api instance' do
+          expect(registered_apis[:my_super_api].headers).to eq 'Content-Type' => 'application/json'
+        end
+      end
+
+      describe 'logger' do
+        it 'assigns to the api instance' do
+          expect(registered_apis[:my_super_api].logger).to be_kind_of Logger
+        end
+      end
+
+      describe 'basic auth' do
+        it 'assigns to the api instance' do
+          expect(registered_apis[:my_super_api].basic_auth).to eq username: 'steven_seagal', password: 'youAlwaysLose'
+        end
+      end
+
+      describe 'query string' do
+        it 'assigns to the api instance' do
+          expect(registered_apis[:my_super_api].params).to eq(hello: 'world')
+        end
+      end
+
+      describe 'namespaces' do
+        it 'assigns to the api instance' do
+          expect(registered_apis[:my_super_api].namespaces).to eq prefix: 'api', version: 'v1'
+        end
+      end
+    end
+
+    context 'when block is not given' do
+      it 'raises no block given exception' do
+        expect {
+          Jeckle::Setup.register(:my_api)
+        }.to raise_exception(LocalJumpError)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,3 +1,17 @@
+if ENV['CODECLIMATE_REPO_TOKEN']
+  require 'codeclimate-test-reporter'
+  CodeClimate::TestReporter.start
+end
+
 require 'bundler/setup'
-Bundler.require
-require 'jeckle'
+require 'jeckle'
+
+Dir['spec/support/**/*.rb'].each { |file| require File.expand_path(file) }
+
+require 'fixtures/jeckle_config'
+
+Dir['spec/fixtures/**/*.rb'].each { |file| require File.expand_path(file) }
+
+RSpec.configure do |config|
+  config.disable_monkey_patching!
+end

data/spec/support/shared_examples.rb

@@ -0,0 +1,47 @@
+RSpec.shared_examples_for Jeckle::Request do
+  let(:api_params) { api.params.stringify_keys }
+
+  before do
+    allow_any_instance_of(Faraday::Request).to receive(:params=).with(any_args).and_call_original
+    allow_any_instance_of(Faraday::Request).to receive(:headers=).with(any_args).and_call_original
+  end
+
+  it 'sets request URL' do
+    expect_any_instance_of(Faraday::Request).to receive(:url).with endpoint
+
+    described_class.run api, endpoint, options
+  end
+
+  it 'sets global api params defined via register block' do
+    expect_any_instance_of(Faraday::Request).to receive(:params=).with(api_params).
+      at_least(:once).and_call_original
+
+    described_class.run api, endpoint, options
+  end
+
+  it 'sets request params' do
+    expect_any_instance_of(Faraday::Request).to receive(:params=).with(options).
+      at_least(:once).and_call_original
+
+    described_class.run api, endpoint, options
+  end
+
+  it 'sets global api headers defined via register block' do
+    expect_any_instance_of(Faraday::Request).to receive(:headers=).with(api.connection.headers).
+      at_least(:once).and_call_original
+
+    described_class.run api, endpoint, options
+  end
+
+  context 'when has headers option' do
+    let(:options) { { headers: { 'Accept' => 'application/json' } } }
+    let(:expected_headers) { api.connection.headers.merge options[:headers] }
+
+    it 'merges request headers with global api headers' do
+      expect_any_instance_of(Faraday::Request).to receive(:headers=).with(expected_headers).
+        at_least(:once).and_call_original
+
+      described_class.run api, endpoint, options
+    end
+  end
+end

metadata

@@ -1,85 +1,86 @@
 --- !ruby/object:Gem::Specification
 name: jeckle
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Tomas D'Stefano
+- Brenno Costa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-18 00:00:00.000000000 Z
+date: 2014-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: httparty
+  name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '4.0'
 - !ruby/object:Gem::Dependency
-  name: virtus
+  name: faraday
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.9'
 - !ruby/object:Gem::Dependency
-  name: activemodel
+  name: faraday_middleware
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: virtus
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '1.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '1.6'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -96,6 +97,20 @@ dependencies:
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
@@ -108,23 +123,41 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: Simple module for build client apis
+description: Simple module for building client APIs
 email:
 - tomas_stefano@successoft.com
+- brennolncosta@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .rspec
+- .travis.yml
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- examples/dribbble.rb
 - jeckle.gemspec
 - lib/jeckle.rb
+- lib/jeckle/api.rb
+- lib/jeckle/errors.rb
+- lib/jeckle/model.rb
+- lib/jeckle/request.rb
 - lib/jeckle/resource.rb
+- lib/jeckle/setup.rb
 - lib/jeckle/version.rb
+- spec/fixtures/jeckle_config.rb
+- spec/fixtures/models/fake_model.rb
+- spec/fixtures/resources/fake_resource.rb
+- spec/jeckle/api_spec.rb
+- spec/jeckle/model_spec.rb
+- spec/jeckle/request_spec.rb
+- spec/jeckle/resource_spec.rb
+- spec/jeckle/setup_spec.rb
 - spec/spec_helper.rb
+- spec/support/shared_examples.rb
 homepage: https://github.com/tomas-stefano/jeckle
 licenses:
 - MIT
@@ -148,6 +181,15 @@ rubyforge_project:
 rubygems_version: 2.0.5
 signing_key: 
 specification_version: 4
-summary: Simple module for build client apis
+summary: Simple module for building client APIs
 test_files:
+- spec/fixtures/jeckle_config.rb
+- spec/fixtures/models/fake_model.rb
+- spec/fixtures/resources/fake_resource.rb
+- spec/jeckle/api_spec.rb
+- spec/jeckle/model_spec.rb
+- spec/jeckle/request_spec.rb
+- spec/jeckle/resource_spec.rb
+- spec/jeckle/setup_spec.rb
 - spec/spec_helper.rb
+- spec/support/shared_examples.rb