wrappi 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d76d08b4ea48473c331491f345bf3349020d2939038abab2df92c6b2ee39a159
-  data.tar.gz: c17875fe3958e459610c7996f285e493f50b589e053703a5a14aefd54c1061d7
+  metadata.gz: 13686ad4035cddda1cbf1ef0c76cd1d67d221900dd2bcf929e41daff2f81b1dd
+  data.tar.gz: 4d313c68d7d3c401ce78d0dbd5a8c088f6818767d7e6807a8620f3e0f2acf751
 SHA512:
-  metadata.gz: '03181ab50cbfeb1e55b408bf5d8fd11e919b9e6f6528ff0c4670b1296cac684fc67a0a29b376b292772cde316ed9cfe9a0e50475278c2a5da05946728afed817'
-  data.tar.gz: 289a464e32f98a82c0098e5372e96935377a8ec2c9da5c9f8d3f7c3e55bbc7d33542e51f7fe7c4b565b70fae787a1ee7186b1c95084ef6bb94bef31348f7f1e4
+  metadata.gz: 7a1a0fc2bbff8c668f246b15562bff9c33d098b22f2cd4b12a5342425f8242bf6fb5a2aeb2578e1a1c283b05340a83aab942fd5b9fea2b208d3572c24f03da9e
+  data.tar.gz: e4f5f5490059cb6fa8469c44583271186445273d46ca9cc77d139f90b38feefade82cc2617b6eb8a1d7ee17b15b3605ad3c7db472e472cdc759c7b1389f4b2de

data/.coveralls.yml

@@ -0,0 +1,2 @@
+service_name: travis-ci
+repo_token: dTTopKFna7x9zP2JSbTbiWwOtUTywNmdl

data/Gemfile

@@ -2,5 +2,15 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in wrappi.gemspec
 gemspec
-gem 'pry'
-gem 'cache_mock'
+
+group :development, :test do
+  gem 'cache_mock'
+  gem 'pry'
+  # gem 'rubocop', '~> 0.37.2', require: false unless RUBY_VERSION =~ /^1.8/
+  gem 'coveralls', require: false
+
+  platforms :mri, :mingw do
+    gem 'pry', require: false
+    gem 'pry-coolline', require: false
+  end
+end

data/README.md

@@ -1,6 +1,6 @@
 [![Build Status](https://travis-ci.org/arturictus/wrappi.svg?branch=master)](https://travis-ci.org/arturictus/wrappi)
 [![Maintainability](https://api.codeclimate.com/v1/badges/8751a0b6523a52b5e23e/maintainability)](https://codeclimate.com/github/arturictus/wrappi/maintainability)
-[![Test Coverage](https://api.codeclimate.com/v1/badges/8751a0b6523a52b5e23e/test_coverage)](https://codeclimate.com/github/arturictus/wrappi/test_coverage)
+[![Coverage Status](https://coveralls.io/repos/github/arturictus/wrappi/badge.svg?branch=master)](https://coveralls.io/github/arturictus/wrappi?branch=master)
 
 # Wrappi
 Making APIs fun again!
@@ -251,6 +251,7 @@ end
 | timeout         | Hash                     | { write: 9, connect: 9, read: 9 }                                        |          |
 | use_ssl_context | Boolean                  | false                                                                    |          |
 | ssl_context     | OpenSSL::SSL::SSLContext |                                                                          |          |
+| basic_auth      | Hash (keys: user, pass)  |                                                                          |          |
 
 #### Endpoint
 
@@ -261,7 +262,7 @@ end
 | verb             | Symbol                                     | :get                    | *        |
 | default_params   | Hash `or` block -> Hash                    | {}                      |          |
 | headers          | Hash `or` block -> Hash                    | proc { client.headers } |          |
-| basic_auth       | Hash (keys: user, pass) `or` block -> Hash |                         |          |
+| basic_auth       | Hash (keys: user, pass) `or` block -> Hash | proc { client.basic_auth } |          |
 | follow_redirects | Boolean `or` block -> Boolean              | true                    |          |
 | body_type        | Symbol, one of: :json,:form,:body          | :json                   |          |
 | cache            | Boolean `or` block -> Boolean              | proc { options[:cache] }|          |
@@ -527,6 +528,68 @@ It holds the common configuration for all the endpoints (`Wrappi::Endpoint`).
     end
   ```
 
+## Code Organization
+### Build a gem
+
+Wrappi is designed to be able to build HTTP client gems with it.
+
+```ruby
+module GithubCLI
+  class Client < Wrappi::Client
+    setup do |config|
+      config.domain = 'https://api.github.com'
+      config.headers = {
+        'Content-Type' => 'application/json',
+        'Accept' => 'application/vnd.github.v3+json',
+      }
+    end
+
+    class << self
+      attr_accessor :my_custom_config
+    end
+  end
+
+  def self.setup
+    yield(Client)
+  end
+
+  class Endpoint < Wrappi::Endpoint
+    client Client
+  end
+
+  class User < Endpoint
+    verb :get
+    path "users/:username"
+  end
+
+  def self.user(params, opts = {})
+    User.new(params, opts)
+  end
+end
+
+user = GithubCLI.user(username: 'arturictus')
+user.success?
+```
+
+### In your project
+
+## The HTTP clients war
+
+In ruby there are many ruby clients an everyone has an opinion of which one is the
+best.
+Every new API client that you install in your project will install a different HTTP client
+adding redundant and unnecessary dependencies in your project.
+That's why __Wrappi is designed to be HTTP client agnostic__.
+Right now is implemented with [HTTP gem](https://github.com/http/http) (my favorite) but all the logic is decoupled from
+the HTTP client.
+
+All the configuration, metadata and logic to build the request is hold by an instance of Endpoint. Allowing to create adapters that translates this processed metadata to the target HTTP client.
+
+__Tests are HTTP client agnostic__. To help the development of these adapters and probe the reliability of the gem most of the test are run against a Rails application. __All the tests that probe an HTTP call are running this HTTP call against a local server__ making all test End To End and again, HTTP client agnostic.
+
+Right now is not designed the system to change HTTP clients via configuration but if you are interested to implement one let me know
+and we will figure out the way.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies.

data/article.md

@@ -0,0 +1,163 @@
+# Wrappi an HTTP framework
+
+I would like to introduce you the gem I recently created to build HTTP clients.
+
+My motivations:
+
+- I've been using a lot of API clients in my projects an every time I have to use
+one I have to memorize the behavior. Or some of them where not easy to use or with
+estrange interface.
+
+- When building myself API clients I find myself repeating the same process of finding how to
+implement the best practices and flexibility enough for use cases, same abstractions to handle request errors, codes, etc.
+Basically redoing something that I think could be abstracted in a framework.
+
+That's why I builded Wrappi.
+
+Let me convince you that your life will be much easier if you use Wrappi.
+
+Let's do a Github Client together:
+
+__The client:__
+
+Client is where the shared configurations for you calls are stored. Domain, api keys, headers.
+
+Here it is an example:
+
+```ruby
+module GithubCLI
+  class Client < Wrappi::Client
+    setup do |config|
+      config.domain = 'https://api.github.com'
+      config.headers = {
+        'Content-Type' => 'application/json',
+        'Accept' => 'application/vnd.github.v3+json',
+      }
+    end
+  end
+end
+```
+How you see we created a namespace `GithubCLI`.
+I like my clients to be appended with `CLI` or `API` because when you use the gem in you project you will need
+to create a wrapper around it and if the gem is called like the service I makes you have to be creative about the name and
+your application code is less descriptive.
+
+see by yourself:
+
+```ruby
+module Github
+  def self.update_repos(user)
+    g = GithubCLI.users(username: user.github_username)
+    if g.success?
+      g.body['repos'].each do |r|
+        # what ever
+      end
+    else
+      false
+    end
+  end
+end
+
+Github.update_repos(user)
+```
+In this case the service is integrated to our application. We just call `Github` in
+our application.
+
+Next we created a Client holding all the global settings to make a call to any API. That means the domain, headers and params that will be shared
+between all the endpoints in which we use this client.
+
+Now let's create our first endpoint:
+
+```ruby
+module GithubCLI
+  class client < Wrappi:Client
+    # ...
+  end
+
+
+  class User < Wrappi::Endpoint
+    client Client
+    verb :get
+    path "users/:username"
+  end
+end
+```
+
+Here we just defined a class iheriting from `Wrappi::Endpoint`. In this class we just set few configs:
+client, verb and path. This is all we need to make our first request.
+
+```ruby
+req = GithubCLI::User.new(username: 'arturictus')
+user.error? # => false
+user.status_code # => 200
+user.body # => {"login"=>"arturictus", "id"=>1930175, ...}
+```
+
+Yep!, done.
+
+Right now is when you say: "I can do the same in a single line of code" and you are right. But now is when things get interesting.
+
+Imagine that you have have an API key. It's not a hard thing to fix right?, maybe we create a class that all our endpoints inherit from?..
+
+In wrappi you can just do it with a line of code:
+
+```ruby
+module GithubCLI
+  class Client < Wrappi::Client
+    setup do |config|
+      config.domain = 'https://api.github.com'
+      config.headers = {
+        'Content-Type' => 'application/json',
+        'Accept' => 'application/vnd.github.v3+json',
+      }
+      config.params = { api_token: 'very_secret' } # Look here
+    end
+  end
+end
+```
+
+Now all the endpoints using this client will send with the request the `api_token` param.
+
+```ruby
+req = GithubCLI::User.new(username: 'arturictus')
+req.conssumated_params # => { api_token: ...}
+```
+
+Ok, not impressive but we are starting to safe lines of code.
+
+
+```ruby
+module GithubCLI
+  class Client < Wrappi::Client
+    setup do |config|
+      config.domain = 'https://api.github.com'
+      config.headers = {
+        'Content-Type' => 'application/json',
+        'Accept' => 'application/vnd.github.v3+json',
+      }
+    end
+
+    class << self
+      attr_accessor :my_custom_config
+    end
+  end
+
+  def self.setup
+    yield(Client)
+  end
+
+  class Endpoint < Wrappi::Endpoint
+    client Client
+  end
+
+  class User < Endpoint
+    verb :get
+    path "users/:username"
+  end
+
+  def self.user(params, opts = {})
+    User.new(params, opts)
+  end
+end
+
+```

data/bin/console

@@ -5,7 +5,7 @@ require "wrappi"
 
 # Github example:
 
-module Github
+module GithubCLI
   class Client < Wrappi::Client
     setup do |config|
       config.domain = 'https://api.github.com'
@@ -14,12 +14,28 @@ module Github
         'Accept' => 'application/vnd.github.v3+json',
       }
     end
+
+    class << self
+      attr_accessor :my_custom_config
+    end
   end
-  class User < Wrappi::Endpoint
+
+  def self.setup
+    yield(Client)
+  end
+
+  class Endpoint < Wrappi::Endpoint
     client Client
+  end
+
+  class User < Endpoint
     verb :get
     path "users/:username"
   end
+
+  def self.user(params, opts = {})
+    User.new(params, opts)
+  end
 end
 
 

data/lib/wrappi/client.rb

@@ -18,6 +18,7 @@ module Wrappi
     config_accessor(:params) { {} }
     config_accessor(:cache)
     config_accessor(:async_handler) { AsyncHandler }
+    config_accessor(:basic_auth)
 
     def self.setup
       yield(self)

data/lib/wrappi/endpoint.rb

@@ -15,7 +15,8 @@ module Wrappi
       body_type: :json,
       cache: proc { options[:cache] },
       cache_options: {},
-      async_callback: proc {}
+      async_callback: proc {},
+      basic_auth: proc { client.basic_auth }
     }
   )
     attr_reader :input_params, :options
@@ -111,8 +112,29 @@ module Wrappi
       "?#{d}"
     end
 
+    # URI behaviour
+    # example:
+    #
+    #     URI.join('https://hello.com/foo/bar', '/bin').to_s
+    #     => "https://hello.com/bin"
+    #
+    #     URI.join('https://hello.com/foo/bar', 'bin').to_s
+    #     => "https://hello.com/foo/bin"
+    #
+    #
+    #     URI.join('https://hello.com/foo/bar/', '/bin').to_s
+    #     => "https://hello.com/bin"
+    #
+    #     We want this behaviour:
+    #     URI.join('https://hello.com/foo/bar/', 'bin').to_s
+    #     => "https://hello.com/foo/bar/bin"
     def _url
-      URI.join("#{client.domain}/", path_gen.path) # TODO: remove heading "/" of path
+      URI.join(domain, path_gen.for_uri)
+    end
+
+    def domain
+      return client.domain if client.domain =~ /\/$/
+      "#{client.domain}/"
     end
 
     def params

data/lib/wrappi/path_gen.rb

@@ -15,6 +15,28 @@ module Wrappi
     end
     alias_method :path, :compiled_path
 
+    # removes first character if path starts with `/`
+    # this is because URI will remove all the paths in between
+    # example:
+    #
+    #     URI.join('https://hello.com/foo/bar', '/bin').to_s
+    #     => "https://hello.com/bin"
+    #
+    #     URI.join('https://hello.com/foo/bar', 'bin').to_s
+    #     => "https://hello.com/foo/bin"
+    #
+    #
+    #     URI.join('https://hello.com/foo/bar/', '/bin').to_s
+    #     => "https://hello.com/bin"
+    #
+    #     We want this behaviour:
+    #     URI.join('https://hello.com/foo/bar/', 'bin').to_s
+    #     => "https://hello.com/foo/bar/bin"
+    def for_uri
+      return compiled_path unless compiled_path =~ /^\//
+      compiled_path.dup.tap { |s| s[0] = '' }
+    end
+
     def processed_params
       return input_params unless interpolable?
       @processed_params ||= input_params.reject{ |k, v| keys_in_params.include?(k.to_sym) }

data/lib/wrappi/testing.rb

@@ -0,0 +1,45 @@
+module Wrappi
+  class Endpoint
+
+    def fixture_name
+      "#{self.class}#{fixture_params_key}.json"
+    end
+
+    def fixture_params_key
+      return if processed_params.empty?
+      d = Digest::MD5.hexdigest processed_params.to_json
+      "-#{d}"
+    end
+
+    def fixture_content
+      return {} unless success?
+      {
+        request: {
+          method: verb.to_s,
+          url: url,
+          domain: domain,
+          headers: headers,
+          params: consummated_params,
+          path: path_gen.path
+        },
+        response: {
+          status: status,
+          body: body
+        }
+      }
+    end
+  end
+
+  module Testing
+    def store_response(path, &block)
+      endpoint = block.call
+      raise "Not succesful call to #{endpoint.class}" unless endpoint.success?
+      file_fullname = File.join(path, endpoint.fixture_name)
+      return endpoint if File.exists?(file_fullname)
+      File.open(file_fullname, "w") do |f|
+        f.write(JSON.pretty_generate(endpoint.fixture_content))
+      end
+      endpoint
+    end
+  end
+end

data/lib/wrappi/version.rb

@@ -1,3 +1,3 @@
 module Wrappi
-  VERSION = "0.2.2"
+  VERSION = "0.2.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wrappi
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - Artur Pañach
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-02-03 00:00:00.000000000 Z
+date: 2019-04-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -135,6 +135,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".coveralls.yml"
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
@@ -143,6 +144,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- article.md
 - bin/console
 - bin/dev_server
 - bin/setup
@@ -161,6 +163,7 @@ files:
 - lib/wrappi/request/template.rb
 - lib/wrappi/request/with_body.rb
 - lib/wrappi/response.rb
+- lib/wrappi/testing.rb
 - lib/wrappi/uncalled_request.rb
 - lib/wrappi/version.rb
 - wrappi.gemspec