wrappi 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49b4ecb9e1cd6395c2e514f607da4460deda743f7e9eab24a786df41f674cef7
-  data.tar.gz: 5e4b65bc43c871285b10268389ccba2df572a7083a21afe8bb6d5b93d4aeae7f
+  metadata.gz: 244907ad87d770e992be773f840eedaa08e370cc1b08f66981e13f45b12c4e30
+  data.tar.gz: 5024e8339f63640f24008f221288f3ee79805b8e80ac9d54980967390188ad66
 SHA512:
-  metadata.gz: 57abcc813f5e80d1ec60fd665f05a4f18b9ef2048a75fbccae24870ab61177fad170b85c8492dfcaa3887ff07fd325ebc003839b780a15362288e0bd53a0bd39
-  data.tar.gz: fda078035d91096d8bc6443157da9969ea597e2a608caed83a46f89551430dfa7962353d3ca9c8d4b8608076067aba501bd89e0d8e9591a4d308b14f2310ca94
+  metadata.gz: 2a655cb94421b1e9901ed275ca23a243ecce04e6afb97f24c34ff726f081bad2e8170657064c8a309f0271da46982a451759cc1be61212a52b62e2d284718651
+  data.tar.gz: 1cc627f259122b2c75ed6f239bb31676e8cb9a4e42c34fd23a5968f6a5373b4128da6cddc3fec52c5cec08c9e9f5e2bb0532aba540010004ee4b95e2265214f6

data/.travis.yml

@@ -1,5 +1,26 @@
-sudo: false
 language: ruby
+cache: bundler
+services:
+  - docker
 rvm:
-  - 2.1.6
-before_install: gem install bundler -v 1.12.4
+  - 2.3.7
+  - 2.4.4
+  - 2.5.1
+  - ruby-head
+before_install:
+  - docker build -t dummy -f spec/dummy/Dockerfile .
+  - docker run -d -p 127.0.0.1:9873:9873 dummy
+  - docker ps -a
+  - gem install bundler -v 1.17.3
+script:
+  - bundle exec rspec
+# Code climate test reporter
+env:
+  global:
+    - CC_TEST_REPORTER_ID=6cebf6c67b6e2d8a53a608ea98ebd897f4cba357bf1e3431bfdb77ff4207399e
+before_script:
+  - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
+  - chmod +x ./cc-test-reporter
+  - ./cc-test-reporter before-build
+after_script:
+  - ./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT

data/Gemfile

@@ -1,6 +1,6 @@
 source 'https://rubygems.org'
 
-gem 'fusu', path: '../fusu'
 # Specify your gem's dependencies in wrappi.gemspec
 gemspec
 gem 'pry'
+gem 'cache_mock'

data/README.md

@@ -1,3 +1,7 @@
+[![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)
+
 # Wrappi
 
 Framework to create API clients.
@@ -46,43 +50,77 @@ end
 
 ```ruby
 user = Github::User.new(username: 'arturictus')
-user.success?
-# => true
-user.code
-# => 200
-user.body
-# => {"login"=>"arturictus", "id"=>1930175, ...}
+user.success? # => true
+user.error? # => false
+user.status_code # => 200
+user.body # => {"login"=>"arturictus", "id"=>1930175, ...}
 ```
 
+### Configurations
+
+#### Client
+
+| Name            | Type                     | Default                                                                  | Required |
+|-----------------|--------------------------|--------------------------------------------------------------------------|----------|
+| domain          | String                   |                                                                          | *        |
+| params          | Hash                     |                                                                          |          |
+| logger          | Logger                   | Logger.new(STDOUT)                                                       |          |
+| headers         | Hash                     | { 'Content-Type' => 'application/json', 'Accept' => 'application/json' } |          |
+| ssl_context     | OpenSSL::SSL::SSLContext |                                                                          |          |
+| use_ssl_context | Boolean                  | false                                                                    |          |
+
+#### Endpoint
+
+| Name             | Type                              | Default                 | Required |
+|------------------|-----------------------------------|-------------------------|----------|
+| client           | Wrappi::Client                    |                         | *        |
+| path             | String                            |                         | *        |
+| verb             | Symbol                            | :get                    | *        |
+| default_params   | Hash                              | {}                      |          |
+| headers          | block                             | proc { client.headers } |          |
+| basic_auth       | Hash, keys: user, pass            |                         |          |
+| follow_redirects | Boolean                           | true                    |          |
+| body_type        | Symbol, one of: :json,:form,:body | :json                   |          |
+| cache            | Boolean                           | false                   |          |
+| retry_if         | block                             |                         |          |
+| retry_options    | block                             |                         |          |
+| around_request   | block                             |                         |          |
+
 ### Client
 
 Is the main configuration for your service.
 
 It holds the common configuration for all the endpoints (`Wrappi::Endpoint`).
 
-Required:
+#### Required:
 
-  - `domain`: Yep, you know.
+  - __domain:__ Yep, you know.
     ```ruby
     config.domain = 'https://api.github.com'
     ```
 
-Optionals:
+#### Optionals:
 
-  - `params`: Set global params for all the `Endpoints`.
+  - __params:__ Set global params for all the `Endpoints`.
     This is a great place to put the `api_key`.
     ```ruby
     config.params = { "api_key" => "asdfasdfoerkwlejrwer" }
     ```
     default: `{}`
 
-  - `logger`: Set your logger.
+  - __logger:__ Set your logger.
+
+    default: `Logger.new(STDOUT)`
     ```ruby
     config.logger = Rails.logger
     ```
-    default: `Logger.new(STDOUT)`
 
-  - `headers`: Headers for all the endpoints. Format, Authentication.
+  - __headers:__ Headers for all the endpoints. Format, Authentication.
+
+    default:
+    ```ruby
+    { 'Content-Type' => 'application/json', 'Accept' => 'application/json' }
+    ```
     ```ruby
     config.headers = {
       "Content-Type" => "application/json",
@@ -90,57 +128,167 @@ Optionals:
       "Auth-Token" => "verysecret"
     }
     ```
-    default:
-    ```ruby
-    { 'Content-Type' => 'application/json', 'Accept' => 'application/json' }
-    ```
 
-  - `ssl_context`: If you need to set an ssl_context.
+  - __ssl_context:__ If you need to set an ssl_context.
+
+     default: `nil`
      ```ruby
      config.ssl_context = OpenSSL::SSL::SSLContext.new.tap do |ctx|
                             ctx.verify_mode = OpenSSL::SSL::VERIFY_NONE
                           end
      ```
-     default: `nil`
 
-  - `use_ssl_context`: It has to be set to `true` for using the `ssl_context`
+  - __use_ssl_context:__ It has to be set to `true` for using the `ssl_context`
 
      default: `false`
 
 ### Endpoint
 
-Required:
-  - `client`: `Wrappi::Client` `class`
-  - `path`: The path.
+#### Required:
+  - __client:__ `Wrappi::Client` `class`
+    ```ruby
+      client MyClient
+    ```
+
+  - __path:__ The path to the resource.
+    You can use doted notation and they will be interpolated with the params
+
+    ```ruby
+      class MyEndpoint < Wrappi::Endpoint
+        client MyClient
+        verb :get
+        path "/users/:id"
+      end
+      endpoint = MyEndpoint.new(id: "the_id", other: "foo")
+      endpoint.url_with_params #=> "http://domain.com/users/the_id?other=foo"
+      endpoint.url #=> "http://domain.com/users/the_id"
+      endpoint.consummated_params #=> {"other"=>"foo"}
+    ```
+    Notice how interpolated params are removed from the query or the body
+
+  - __verb:__
 
-    TODO
-  - `verb`:
+    default: `:get`
     - `:get`
     - `:post`
     - `:delete`
     - `:put`
 
-    default: `:get`
 
-Optional:
+#### Optional:
 
-  - `default_params`:
+  - __default_params:__ Default params for the request. This params will be added
+    to all the instances unless you override them.
 
     default: `{}`
-  - `headers`:
+
+    ```ruby
+    class MyEndpoint < Wrappi::Endpoint
+      client MyClient
+      verb :get
+      path "/users/:id"
+      default_params do
+        { other: "bar", foo: "foo" }
+      end
+    end
+    endpoint = MyEndpoint.new(id: "the_id", other: "foo")
+    endpoint.consummated_params #=> {"other"=>"foo","foo" => "foo" }
+    ```
+
+  - __headers:__ You can modify the client headers here. Notice that if you want
+    to use the client headers as well you will have to merge them.
 
     default: `proc { client.headers }`
+    ```ruby
+    class MyEndpoint < Wrappi::Endpoint
+      client MyClient
+      verb :get
+      path "/users"
+      headers do
+        client.headers #=> { 'Content-Type' => 'application/json', 'Accept' => 'application/json' }
+        client.headers.merge('Agent' => 'wrappi')
+      end
+    end
+    endpoint = MyEndpoint.new()
+    endpoint.headers #=> { 'Agent' => 'wrappi', 'Content-Type' => 'application/json', 'Accept' => 'application/json'}
+    ```
 
-  - `basic_auth`:
+  - __basic_auth:__ If your endpoint requires basic_auth here is the place. keys
+    have to be: `user` and `pass`.
 
     default: `nil`
-  - `follow_redirects`:
+    ```ruby
+      basic_auth do
+        { user: 'wrappi', pass: 'secret'}
+      end
+    ```
+
+  - __follow_redirects:__ If first request responds a redirect it will follow them.
 
     default: `true`
-  - `body_type`:
+
+  - __body_type:__ Body type.
 
     default: `:json`
 
+    - :json
+    - :form
+    - :body (Binary data)
+
+#### Flow Control:
+
+  This configs allows you fine tune your request adding middleware, retries and cache.
+  The are executed in this nested stack:
+  ```
+    cache
+      |- retry
+        |- around_request
+  ```
+  Check [specs](/blob/master/spec/wrappi/executer_spec.rb) for more examples.
+
+  - __cache:__ Cache the request if successful.
+
+    default: `false`
+  - __retry_if:__ Block to evaluate if request has to be retried. In the block are
+    yielded `Response` and `Endpoint` instances. If the block returns `true` the request will be retried.
+    ```ruby
+      retry_if do |response, endpoint|
+        endpoint.class #=> MyEndpoint
+        response.error? # => true or false
+      end
+    ```
+
+    Use case:
+
+    We have a service that returns an aggregation of hotels available to book for a city. The service will start the aggregation in the background and will return `200` if the aggregation is completed if the aggregation is not completed will return `201` making us know that we should call again to retrieve all the data. This behavior only occurs if we pass the param: `onlyIfComplete`.
+
+    ```ruby
+      retry_if do |response, endpoint|
+        endpoint.consummated_params["onlyIfComplete"] &&
+          response.status_code == 201
+      end
+    ```
+    Notice that this block will never be executed if an error occur (like timeouts). For retrying on errors use the `retry_options`
+
+  - __retry_options:__ We are using the great gem [retryable](https://github.com/nfedyashev/retryable) to accomplish this behavior.
+  Check the documentation for fine tuning. I just paste some examples for convenience.
+
+  ```ruby
+    retry_options do
+      { tries: 5, on: [ArgumentError, Wrappi::TimeoutError] } # or
+      { tries: :infinite, sleep: 0 }
+    end
+  ```
+  - __around_request:__ This block is executed surrounding the request. The request
+  will only get executed if you call `request.call`.
+  ```ruby
+    around_request do |request, endpoint|
+      endpoint.logger.info("making a request to #{endpoint.url} with params: #{endpoint.consummated_params}")
+      request.call # IMPORTANT
+      endpoint.logger.info("response status is: #{request.status_code}")
+    end
+  ```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies.
@@ -157,7 +305,17 @@ bundle exec rspec
 
 You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
+#### Docker
 
+Run dummy server with docker:
+```
+docker build -t wrappi/dummy -f spec/dummy/Dockerfile .
+docker run -d -p 127.0.0.1:9873:9873 wrappy/dummy /bin/sh -c "bin/rails server -b 0.0.0.0 -p 9873"
+```
+Try:
+```
+curl 127.0.0.1:9873 #=> {"controller":"pages","action":"show_body"}
+```
 
 ## Contributing
 

data/lib/wrappi.rb

@@ -2,12 +2,17 @@ require "wrappi/version"
 require 'http'
 require 'fusu'
 require 'miller'
+require 'retryable'
 
 module Wrappi
-  # Your code goes here...
+  class TimeoutError < StandardError; end
+  class NotAuthorizedAccessError < StandardError; end
 end
 
 require 'wrappi/client'
+require 'wrappi/executer'
 require 'wrappi/endpoint'
 require 'wrappi/request'
 require 'wrappi/path_gen'
+require 'wrappi/uncalled_request'
+require 'wrappi/cached_response'

data/lib/wrappi/cached_response.rb

@@ -0,0 +1,52 @@
+module Wrappi
+  class CachedResponse
+    # input is a <Response>.to_h
+    # Example input
+    # {
+    #   raw_body: '{"foo": "bar"}',
+    #   code: 200,
+    #   uri: "http://hello.com",
+    #   success: true
+    # }
+    def initialize(cached_data)
+      @cached_data = Fusu::HashWithIndifferentAccess.new(cached_data)
+    end
+
+    def call
+      self
+    end
+
+    def called?
+      false
+    end
+
+    def body
+      @body ||= JSON.parse(cached_data[:raw_body])
+    end
+
+    def success?
+      cached_data[:success]
+    end
+
+    def error?
+      !success?
+    end
+
+    def raw_body
+      cached_data[:raw_body]
+    end
+
+    def uri
+      cached_data[:uri]
+    end
+
+    def status
+      cached_data[:code]
+    end
+    alias_method :status_code, :status
+
+    private
+
+    def cached_data; @cached_data end
+  end
+end

data/lib/wrappi/client.rb

@@ -20,6 +20,7 @@ module Wrappi
         'Accept' => 'application/json' }
     end
     config_accessor(:params) { {} }
+    config_accessor(:cache)
 
     def self.setup
       yield(self)

data/lib/wrappi/endpoint.rb

@@ -3,7 +3,7 @@ module Wrappi
   class Endpoint < Miller.base(
     :verb, :client, :path, :default_params,
     :headers, :follow_redirects, :basic_auth,
-    :body_type,
+    :body_type, :retry_options, :cache,
     default_config: {
       verb: :get,
       client: proc { raise 'client not set' }, # TODO: add proper error
@@ -11,7 +11,8 @@ module Wrappi
       default_params: {},
       headers: proc { client.headers },
       follow_redirects: true,
-      body_type: :json
+      body_type: :json,
+      cache: false
     }
   )
     attr_reader :input_params, :options
@@ -43,23 +44,8 @@ module Wrappi
       params
     end
 
-    # overridable
-    def before_request
-      true
-    end
-
-    # overridable
-    def after_request(response)
-      true
-    end
-
     def response
-      return unless before_request
-      @response ||= Response.new do
-                      Request.new(self).call
-                    end.tap(&:request)
-      after_request(@response)
-      @response
+      @response ||= Executer.call(self)
     end
     alias_method :call, :response
 
@@ -67,10 +53,42 @@ module Wrappi
     def success?; response.success? end
     def status; response.status end
 
+    # AROUND REQUEST
+    def self.around_request(&block)
+      @around_request = block
+    end
+    def around_request
+      self.class.instance_variable_get(:@around_request)
+    end
+
+    # RETRY
+    def self.retry_if(&block)
+      @retry_if = block
+    end
+    def retry_if
+      self.class.instance_variable_get(:@retry_if)
+    end
+
+    # Cache
+    def cache_key
+      # TODO: think headers have to be in the key as well
+      @cache_key ||= "[#{verb.to_s.upcase}]##{url}#{params_cache_key}"
+    end
+
+    def logger
+      client.logger
+    end
+
     private
 
+    def params_cache_key
+      return if params.empty?
+      d = Digest::MD5.hexdigest params.to_json
+      "?#{d}"
+    end
+
     def _url
-      URI.join("#{client.domain}/", path_gen.path)
+      URI.join("#{client.domain}/", path_gen.path) # TODO: remove heading "/" of path
     end
 
     def params

data/lib/wrappi/executer.rb

@@ -0,0 +1,49 @@
+module Wrappi
+  class Executer
+
+    def self.call(*args)
+      new(*args).call
+    end
+
+    attr_reader :endpoint, :retryer, :cacher
+    def initialize(endpoint)
+      @endpoint = endpoint
+      @retryer = Retryer.new(endpoint)
+      @cacher = Cacher.new(endpoint)
+    end
+
+    def call
+      if cache?
+        cacher.call do
+          request_with_retry
+        end
+      else
+        request_with_retry
+      end
+    end
+
+    private
+
+    def cache?
+      cacher.cache?
+    end
+
+    def request_with_retry
+      retryer.call do
+        make_request
+      end
+    end
+
+    def around_request
+      endpoint.around_request || proc { |res, endpoint| res.call }
+    end
+
+    def make_request
+      res = Response.new { Request.new(endpoint).call }
+      around_request.call(res, endpoint)
+      res.called? ? res : UncalledRequest.new
+    end
+  end
+end
+require 'wrappi/executer/retryer'
+require 'wrappi/executer/cacher'

data/lib/wrappi/executer/cacher.rb

@@ -0,0 +1,40 @@
+module Wrappi
+  class Executer
+    class Cacher
+      attr_reader :endpoint
+      def initialize(endpoint)
+        @endpoint = endpoint
+      end
+
+      def call
+        cached = cache.read(cache_key)
+        return CachedResponse.new(cached) if cached
+        response = yield
+        cache.write(cache_key, response.to_h) if response.success?
+        response
+      end
+
+      def cache?
+        endpoint.client.cache && endpoint.cache && cache_allowed_verb?
+      end
+
+      def cache_allowed_verb?
+        if [:get, :post].include?(endpoint.verb)
+          true
+        else
+          puts "Cache is only available to no side effect requests: :get and :post" # TODO: make a warning
+          false
+        end
+      end
+
+      def cache
+        endpoint.client.cache
+      end
+
+      def cache_key
+        endpoint.cache_key
+      end
+
+    end
+  end
+end

data/lib/wrappi/executer/retryer.rb

@@ -0,0 +1,46 @@
+module Wrappi
+  class Executer
+    class Retryer
+      class RetryError < StandardError; end
+      attr_reader :endpoint
+      def initialize(endpoint)
+        @endpoint = endpoint
+      end
+
+      def call
+        if retry?
+          Retryable.retryable(retry_options) do
+            res = yield
+            raise RetryError if retry_if.call(res, endpoint)
+            res
+          end
+        else
+          yield
+        end
+      end
+
+      def retry_options
+        default = { tries: 3, on: [RetryError] }
+        if endpoint.retry_options
+          end_opts = endpoint.retry_options.dup
+          {}.tap do |h|
+            h[:tries] = end_opts[:tries] || default[:tries]
+            if on = end_opts.delete(:on)
+              h[:on] = default[:on] + Fusu::Array.wrap(on)
+            end
+          end.merge(end_opts)
+        else
+          default
+        end
+      end
+
+      def retry?
+        !!endpoint.retry_if
+      end
+
+      def retry_if
+        endpoint.retry_if
+      end
+    end
+  end
+end

data/lib/wrappi/request.rb

@@ -23,6 +23,15 @@ module Wrappi
     def call
       @call ||= strategy.call
     end
+    alias_method :http, :call
+
+    def to_h
+      @to_h ||= {
+        raw_body: http.raw_body,
+        code: http.code,
+        uri: http.uri
+      }
+    end
   end
 end
 require 'wrappi/request/template'

data/lib/wrappi/response.rb

@@ -3,10 +3,8 @@ module Wrappi
   # check documentation at:
   # https://github.com/httprb/http/wiki/Response-Handling
   class Response
-    class TimeoutError < StandardError; end
-    class NotAuthorizedAccessError < StandardError; end
-    attr_reader :block
 
+    attr_reader :block
     def initialize(&block)
       @block = block
     end
@@ -17,6 +15,10 @@ module Wrappi
     end
     alias_method :call, :request
 
+    def called?
+      !!@request
+    end
+
     def body
       @body ||= request.parse
     end
@@ -40,6 +42,16 @@ module Wrappi
     def status
       request.code
     end
+    alias_method :status_code, :status
+
+    def to_h
+      @to_h ||= {
+        raw_body: raw_body,
+        code: code,
+        uri: uri,
+        success: success?
+      }
+    end
 
     def method_missing(method_name, *arguments, &block)
       if request.respond_to?(method_name)

data/lib/wrappi/uncalled_request.rb

@@ -0,0 +1,36 @@
+module Wrappi
+  class UncalledRequest
+    def request
+      nil
+    end
+    alias_method :call, :request
+
+    def called?
+      true
+    end
+
+    def body
+      { "message" => "uncalled response" }
+    end
+
+    def success?
+      false
+    end
+
+    def error?
+      true
+    end
+
+    def raw_body
+      body.to_json
+    end
+
+    def uri
+      'uncalled_response'
+    end
+
+    def status
+      100
+    end
+  end
+end

data/lib/wrappi/version.rb

@@ -1,3 +1,3 @@
 module Wrappi
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
 end

data/wrappi.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   spec.email         = ["arturictus@gmail.com"]
 
   spec.summary       = %q{Framework to create HTTP API clients}
-  spec.description   = %q{Framework to create HTTP API clients abstracting the best practices and improving readability to your code.}
+  spec.description   = %q{Framework to create HTTP API clients. The aim is to abstract the best practices using a declarative interface.}
   spec.homepage      = "https://github.com/arturictus/wrappi"
   spec.license       = "MIT"
 
@@ -26,4 +26,5 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'http', "~> 2.2"
   spec.add_dependency 'fusu', "~> 0.2.1"
   spec.add_dependency 'miller', "~> 0.1.1"
+  spec.add_dependency 'retryable'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wrappi
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Artur Pañach
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-01-18 00:00:00.000000000 Z
+date: 2019-01-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -108,8 +108,22 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.1.1
-description: Framework to create HTTP API clients abstracting the best practices and
-  improving readability to your code.
+- !ruby/object:Gem::Dependency
+  name: retryable
+  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'
+description: Framework to create HTTP API clients. The aim is to abstract the best
+  practices using a declarative interface.
 email:
 - arturictus@gmail.com
 executables: []
@@ -128,14 +142,19 @@ files:
 - bin/dev_server
 - bin/setup
 - lib/wrappi.rb
+- lib/wrappi/cached_response.rb
 - lib/wrappi/client.rb
 - lib/wrappi/endpoint.rb
+- lib/wrappi/executer.rb
+- lib/wrappi/executer/cacher.rb
+- lib/wrappi/executer/retryer.rb
 - lib/wrappi/path_gen.rb
 - lib/wrappi/request.rb
 - lib/wrappi/request/get.rb
 - lib/wrappi/request/template.rb
 - lib/wrappi/request/with_body.rb
 - lib/wrappi/response.rb
+- lib/wrappi/uncalled_request.rb
 - lib/wrappi/version.rb
 - wrappi.gemspec
 homepage: https://github.com/arturictus/wrappi