tiny_client 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8a1afc402b9bc240ed9b9b266ffd193a995641b9
+  data.tar.gz: cb6089a98ab2881b533461d25f8aa6d1f23cffc5
+SHA512:
+  metadata.gz: 9c3c53dd73646d52f0ffa0ffcfcb408e9c161701cdfbd38ef475d0d8f422e5dd7507e6bafcddf48a0e4c69e6f072b9960613399ddfa8e907d86d6992afbb614e
+  data.tar.gz: 8d376ef61b8abea735d90284ce1a43c6a3f2bb0a286da53bfb305948a9d62a71fffc9773171c678e7847e3d8ccc89f2f4971e61ab10cf81137dd78098472cbc9

data/.gitignore

@@ -0,0 +1,55 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/gems/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Byebug
+.byebug_history
+
+# Used by dotenv library to load environment variables.
+# .env
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+Gemfile.lock
+.ruby-version
+.ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+*tags

data/.rubocop.yml

@@ -0,0 +1,2 @@
+Metrics/LineLength:
+    Max: 100

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+rvm:
+- 2.4.0
+deploy:
+  provider: rubygems
+  api_key:
+    secure: ph/5I0x4nQebMsUUUJelts/S69KFLJxgPqDltsfrgATVesukd4XjCZXzCHq+1xtViKqzhOHm4LC1AaQlNjGpiJGe0/VeTnI/Xdp+YQsR8JiIE/FZ93CZ8qHJI6R5CgMqNi1rBgUi2qjZNoXOM3g0YJ0mTGVO6UlxhXrs+nU6Vf9vYypUMilHWuioWUVji2pvF3KK4yKssfpZ+jd+1z0d7Ei2sUE0CuOINcZ60HVK9dMvMVd2I98sPQZrnZYZ77R0Lp8pmTJ+bByZdcG28v1zCdf6m9pank4ABF2m8rDkbyieKJ280CgCv756pNzebQEu1ZiycitFO/n881PbHFRZRevvH6txFN3oc4Whg4VQkwI/O4NL2XmjgbiQPEldU3PFK6y7Vm/zbSdPEFBGkb7G5oyaDcxIeqxZzHXBPvVKHUX/GNMTGVli6PIt+tfX2HaGtC+k0NbxZP7g7+C1380d20rNKnokMiGZP+GgdBttHnnCdgXu7GjR2l/xNL7R48squ+LlH05haOaKJcybAGxOwEzRke6BQxsF0iHEg5/EYbpP5F7LEmxcOdep6n1c6X7yJHaAP8TTsivTMlBJKr3Oo9yXrBkAdZWRCpfWMkQabSxI+m6K/KU98ynm6Je8NYqmH0jLR4Wn6lZFyeBZlSBmXKpUlerdA34F09+OGE0sziY=
+  ruby: 2.4.0
+  on:
+    tags: true

data/Gemfile

@@ -0,0 +1,14 @@
+source 'https://rubygems.org'
+
+gemspec
+
+# gem are specified in tiny-client.gemspec
+
+group :test, :development do
+  gem 'rake'
+  gem 'minitest'
+  gem 'mocha'
+  gem 'webmock'
+  gem 'yard'
+  gem 'byebug'
+end

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2017 TINYpulse 
+
+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,203 @@
+# TINYclient, a tiny HTTP/JSON crud client toolkit
+[![Gem Version](https://badge.fury.io/rb/tiny_client.svg)](https://badge.fury.io/rb/tiny_client) [![Build Status](https://travis-ci.org/TINYhr/tiny-client.svg)](https://travis-ci.org/TINYhr/tiny-client) 
+
+TINYclient is inspired by [Active Record](http://guides.rubyonrails.org/active_record_basics.html) and based on [Curb](https://github.com/taf2/curb).
+
+### Setup
+
+* Be sure that Curb/Curl works properly on your machine.
+* install the gem
+
+```sh
+gem install tiny_client
+```
+
+### Getting Started
+
+
+#### Configuration
+
+You can initialize your API by extending the `TinyClient::Configuration`
+
+
+```ruby
+class MyConf < TinyClient::Configuration
+
+  def initialize
+    @url = 'http://localhost:3000/api/1.0'
+    @headers = { 'Authorization' => 'token asdfasf4ffsafasdf@12rfsdfa' }
+    @limit = 100
+    @connect_timeout = 30 # seconds
+  end
+end
+
+```
+
+You can use that configuration in your resource.
+
+
+```ruby
+class Author < TinyClient::Resource
+  conf MyConf.instance
+
+  path 'authors' # query will be made on http://localhost:3000/api/1.0/authors
+
+  fields :id, :name # your resource attributes
+
+  nested Books # your resource nested resource
+end
+
+class Book < TinyClient::Resource
+  conf MyConf.instance
+  path 'books'
+  fields :id, :title
+end
+```
+
+#### Usage
+
+Now you will be able to this:
+
+```ruby
+author = Author.show(1) # Get /authors/1.json
+author.name = 'P. K. D.'
+author.save!   # PUT /authors/1.json { "author" : { "name" : "Bob" } }
+
+book = Book.new
+book.title = 'Confessions of a crap artist'
+book = author.add_book(book) # POST /authors/1/books.json { "book" : { "title" : ".." }
+
+book.id.present? # true
+
+books = Book.index(limit: 10) # GET /books.json?limit=10
+
+ed = Author.new
+ed.name = 'Poe'
+ed.save! # POST /authors.json { "author" : { "name" : "Poe" } }
+ed.id.present?
+
+ed_books = ed.books(limit: 10) # GET /authors/{ed.id}/books.json
+first = ed_books.first
+first.load! # GET /books/{first.id}.json
+first.name.present?
+
+# You can also navigate through all resources
+
+Author.index_all do |author| # It will retrieve all the authors, using limit, and offset query params to paginate
+ # Do something for each author
+end
+
+
+Author.index_in_batches(limit: 1000) do |authors|
+  # retrieve authors by batch of 1000
+end
+
+```
+
+### Instance methods behavior
+
+#### load!
+
+It will perform a get request on the resource id and set the resource fields value to the value retrived by the response.
+
+```
+author.load! # GET /authors/{author.id}.json ->  { id: 1, name: 'Toto' ... }
+author.name # 'Toto'
+```
+
+#### save!
+
+It will create the resource if `id` is not set, otherwise it will update it.
+The resource fields value will be updated by the response body content.
+
+```
+toto = MyModule::Author.new
+toto.save! # POST /authors.json { author: {} }
+
+toto.id # should have been set by through the reponse
+
+toto.name = 'Toto'
+toto.save! # PUT {author: {name: 'Toto'}} -> /authors/{toto.id}.json
+```
+
+Only `changed` values will be passed through the body content.
+
+You can `clear` changes with `#clear_changes!`
+You can now which fields has been marked has changed with `#changes`
+
+Changes is automatically clear when you perform a request ( i.e call, `#show #index #get #put #post save!` and so on)
+
+### Nested resource
+
+You can add a nested resource thanks to the `nested` class methods.
+
+```ruby
+class Author < TinyClient::Resource
+  nested Books, Magazines
+end
+```
+
+It will allows you to call your nested resource directly from an instance of your parent resource.
+
+```ruby
+author = Author.show(1)
+author.books(limit: 100)  # index GET /authors/1/books.json?limit=100
+book = author.book(1)     # show  GET/authors/1/books/1.json
+book.title = 'New title'
+author.update_book(book)  # update  PUT /authors/1/books/1.json -- { 'book': { 'title': 'New title' } }
+author.remove_book(book)  # destroy DELETE /authors/1/books/1.json
+author.add_book(book)     # create  POST /author/1/books.json -- { 'book': { 'title': 'New title' } }
+author.books_all.each     # x GET /authors/1/books.json?limit=.. -- Enumerator -- Retrieve ALL books using limit and offset to handle pagination
+```
+
+This is equivalent to the following:
+
+```ruby
+author = Author.show(1)
+author.nested_index(Book, limit: 100)
+book = author.nested_show(Book, 1)
+book.title = 'New title'
+author.nested_update(book)
+author.nested_delete(book)
+author.nested_create(book)
+author.nested_all(Book, limit: 10) # retrieve all books, quering the server by batch of 10;
+```
+
+### Constraint & Support
+
+#### JSON only
+
+TinyClient supports only JSON data.
+`Accept: application/json` header is set.
+
+#### POST/PUT create/update
+
+The content passed to the server will always be prefixed by the class name in lower case.
+
+```
+toto = MyModule::Author.new
+toto.save! # POST { author: {} }
+
+```
+
+#### Pagination / Buffer
+
+Pagination, buffer is achieve through `limit` and `offset` params.
+
+```
+Author.index_all({limit: 100}) # Will queries the server by batch of 100, until all authors has been retrieved through the enumerator.
+
+```
+
+#### Content-Encoding support
+
+TinyClient support `gzip` Content-Encoding. Response with `gzip` Content-Encoding will be automatically decompressed.
+You can set the `Accept-Encoding: gzip` through the configuration headers.
+
+### Development
+
+You can run the test using:
+
+```shell
+rake
+```

data/Rakefile

@@ -0,0 +1,25 @@
+require 'rake/testtask'
+require 'yard'
+
+task default: [:test]
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.test_files = FileList['test/tiny_client/*_test.rb', 'test/tiny_client_test.rb']
+end
+
+YARD::Rake::YardocTask.new do |t|
+  t.files = ['lib/**/*.rb']
+  t.options = ['-o docs']
+end
+
+desc 'Build the gem'
+task gem: [:test] do
+  sh 'gem build tiny_client.gemspec'
+end
+
+desc 'Clean up'
+task :clean do
+  sh 'rm -rf docs'
+  sh 'rm -f tiny_client*.gem'
+end

data/lib/tiny_client.rb

@@ -0,0 +1,14 @@
+require 'tiny_client/curb_requestor'
+require 'tiny_client/response_error'
+require 'tiny_client/response'
+require 'tiny_client/nested_support'
+require 'tiny_client/pagination_support'
+require 'tiny_client/resource_error'
+require 'tiny_client/resource'
+require 'tiny_client/url_builder'
+require 'tiny_client/configuration'
+require 'tiny_client/remote_client'
+
+# Placeholder
+module TinyClient
+end

data/lib/tiny_client/configuration.rb

@@ -0,0 +1,36 @@
+module TinyClient
+  # Provides the default client configuration
+  # Subclass and override {#initialize} to implement a client confiuration.
+  # @abstract
+  # @attr_reader [String] url the api root url (i.e: http://localhost/api/1.0)
+  # @attr_reader [Integer] limit default limit used as a query param
+  class Configuration
+    include Singleton
+    attr_reader :url, :limit
+
+    # You need to initialize the api {#url}, default {#headers}, and default limit.
+    def initialize
+      raise NotImplementedError
+    end
+
+    # @return [Integer] request connection timeout in seconds
+    def connect_timeout
+      @connect_timeout ||= 30
+    end
+
+    # @return [Hash] headers default headers you want to pass along every request
+    def headers
+      @headers ||= {}
+    end
+
+    # @return [Boolean] true if curl verbose option is set
+    def verbose
+      @verbose = false if @verbose.nil?
+      @verbose
+    end
+
+    def requestor
+      @requestor ||= TinyClient::RemoteClient.new(self)
+    end
+  end
+end

data/lib/tiny_client/curb_requestor.rb

@@ -0,0 +1,83 @@
+require 'curb'
+
+module TinyClient
+  # Allows to perform request with Curb and wrapped the response.
+  # Curb client are attached to a current thread Fiber. ( One curb per Fiber. )
+  module CurbRequestor
+    class << self
+      # Perform a get request with Curl
+      # @param [String] url the full url
+      # @param [Hash] headers  the request headers
+      # @param [Integer] connect_timeout timeout if the request connection go over (in second)
+      # @param [Boolean] verbose set curl verbose mode
+      # @raise [ResponseError] if the server respond with an error status (i.e 404, 500..)
+      # @return [TinyClient::Response] the request response
+      def perform_get(url, headers, connect_timeout, verbose)
+        perform(:GET, url, nil, nil, headers: headers, connect_timeout: connect_timeout,
+                                     verbose: verbose)
+      end
+
+      # Perform a put request with Curl
+      # @param [String] url the full url
+      # @param [Hash] headers  the request headers
+      # @param [String] content the request body content
+      # @param [Integer] connect_timeout timeout if the request connection go over (in second)
+      # @param [Boolean] verbose set curl verbose mode
+      # @raise [ResponseError] if the server respond with an error status (i.e 404, 500..)
+      # @return [TinyClient::Response] the request response
+      def perform_put(url, headers, content, connect_timeout, verbose)
+        perform(:PUT, url, nil, content, headers: headers, connect_timeout: connect_timeout,
+                                         verbose: verbose)
+      end
+
+      # Perform a post request with Curl
+      # @param [String] url the full url
+      # @param [Hash] headers  the request headers
+      # @param [String] content the request body content
+      # @param [Integer] connect_timeout timeout if the request connection go over (in second)
+      # @param [Boolean] verbose set curl verbose mode
+      # @raise [ResponseError] if the server respond with an error status (i.e 404, 500..)
+      # @return [TinyClient::Response] the request response
+      def perform_post(url, headers, content, connect_timeout, verbose)
+        perform(:POST, url, content, nil, headers: headers, connect_timeout: connect_timeout,
+                                          verbose: verbose)
+      end
+
+      # Perform a delete request with Curl
+      # @param [String] url the full url
+      # @param [Hash] headers  the request headers
+      # @param [Integer] connect_timeout timeout if the request connection go over (in second)
+      # @param [Boolean] verbose set curl verbose mode
+      # @raise [ResponseError] if the server respond with an error status (i.e 404, 500..)
+      # @return [TinyClient::Response] the request response
+      def perform_delete(url, headers, connect_timeout, verbose)
+        perform(:DELETE, url, nil, nil, headers: headers, connect_timeout: connect_timeout,
+                                        verbose: verbose)
+      end
+
+      # Perform a head request with Curl
+      # @param [String] url the full url
+      # @param [Hash] headers  the request headers
+      # @param [Integer] connect_timeout timeout if the request connection go over (in second)
+      # @param [Boolean] verbose set curl verbose mode
+      # @raise [ResponseError] if the server respond with an error status (i.e 404, 500..)
+      # @return [TinyClient::Response] the request response
+      def perform_head(url, headers, connect_timeout, verbose)
+        perform(:HEAD, url, nil, nil, headers: headers, connect_timeout: connect_timeout,
+                                      verbose: verbose)
+      end
+
+      private
+
+      def perform(verb, url, post_body, put_data, options = {})
+        response = Response.new(Curl.http(verb, url, post_body, put_data) do |c|
+          c.headers = options[:headers]
+          c.connect_timeout = options[:connect_timeout]
+          c.verbose = options[:verbose]
+        end)
+        raise ResponseError, response if response.error?
+        response
+      end
+    end
+  end
+end

data/lib/tiny_client/nested_support.rb

@@ -0,0 +1,95 @@
+require 'active_support/inflector'
+
+module TinyClient
+  #
+  # Mixin that add support for nested resource to {TinyClient::Resource}
+  # Each nested resource will be accessible with:
+  #    <resource_name>s                 # List the existing     ( index )
+  #    <resource_name>(id)              # Show an existing      ( show )
+  #    add_<resource_name>(resource)    # To create a new one   ( post )
+  #    remove_<resource_name>(resource) # Remove an existing    ( delete )
+  #    update_<resource_name>(resource) # Update an existing    ( put )
+  # @see file:README.md#label-Nested+resource README - Nested Resource
+  module NestedSupport
+    # @raise [ArgumentError] if the given resource_class is not a Resource
+    def self.included(resource_class)
+      raise ArgumentError, 'Works only for TinyClient::Resource' unless resource_class <= Resource
+      resource_class.extend(ClassMethods)
+    end
+
+    # @raise [ArgumentError] if the given resource_class is not a Resource
+    # @raise [ResponseError] if the server respond with an error status (i.e 404, 500..)
+    def nested_show(resource_class, id, params = {})
+      raise ArgumentError, 'Works only for TinyClient::Resource' unless resource_class <= Resource
+      path = UrlBuilder.url(resource_class.path).path(id).build!
+      self.class.get(params, @id, path, resource_class)
+    end
+
+    # @raise [ArgumentError] if the given resource_class is not a Resource
+    # @raise [ResponseError] if the server respond with an error status (i.e 404, 500..)
+    def nested_index(resource_class, params = {})
+      raise ArgumentError, 'Works only for TinyClient::Resource' unless resource_class <= Resource
+      self.class.get(params, @id, resource_class.path, resource_class)
+    end
+
+    # @raise [ArgumentError] if the given resource does not have an id or is not Resource instance
+    # @raise [ResponseError] if the server respond with an error status (i.e 404, 500..)
+    def nested_update(resource)
+      raise ArgumentError, 'resource must be an TinyClient::Resource' unless resource.is_a? Resource
+      raise ArgumentError, 'resource must have id set' if resource.id.nil?
+      path = UrlBuilder.url(resource.class.path).path(resource.id).build!
+      data = resource.changes.to_a.each_with_object({}) { |fld, h| h[fld] = resource.send(fld) }
+      self.class.put({ resource.class.low_name => data }, @id, path, resource.class)
+    end
+
+    # @raise [ArgumentError] if the given resource does not have an id or is not a Resource instance
+    # @raise [ResponseError] if the server respond with an error status (i.e 404, 500..)
+    def nested_delete(resource)
+      raise ArgumentError, 'resource must be an TinyClient::Resource' unless resource.is_a? Resource
+      raise ArgumentError, 'resource must have id set' if resource.id.nil?
+      path = UrlBuilder.url(resource.class.path).path(resource.id).build!
+      self.class.delete(@id, path, resource.class)
+    end
+
+    # @raise [ResponseError] if the server respond with an error status (i.e 404, 500..)
+    def nested_create(resource)
+      raise ArgumentError, 'resource must be an TinyClient::Resource' unless resource.is_a? Resource
+      data = resource.changes.to_a.each_with_object({}) { |fld, h| h[fld] = resource.send(fld) }
+      self.class.post({ resource.class.low_name => data }, @id, resource.class.path, resource.class)
+    end
+
+    # @see PaginationSupport::ClassMethods.get_all
+    # @raise [ArgumentError] if the given resource_class is not a Resource
+    # @raise [ResponseError] if the server respond with an error status (i.e 404, 500..)
+    def nested_all(resource_class, params = {})
+      raise ArgumentError, 'Works only for TinyClient::Resource' unless resource_class <= Resource
+      self.class.get_all(params, @id, resource_class.path, resource_class)
+    end
+
+    # Add support for the {#nested} class methods as well as default actions.
+    module ClassMethods
+      # Set nested resources. Nested resource creation and getters method will be created.
+      # If the resource class is called Post, then `add_post` and `posts` methods will be created.
+      # @param [Resource] clazz the nested resource class.
+      def nested(*clazz)
+        @nested ||= nested_actions(clazz) && clazz
+      end
+
+      private
+
+      def nested_actions(nested)
+        nested.each do |clazz|
+          plural_name = ActiveSupport::Inflector.pluralize(clazz.low_name)
+          class_eval <<-RUBY
+            def #{plural_name}(params = {}); nested_index(#{clazz}, params) end
+            def #{clazz.low_name}(id, params = {}); nested_show(#{clazz}, id, params) end
+            def add_#{clazz.low_name}(#{clazz.low_name}); nested_create(#{clazz.low_name}) end
+            def update_#{clazz.low_name}(#{clazz.low_name}); nested_update(#{clazz.low_name}) end
+            def remove_#{clazz.low_name}(#{clazz.low_name}); nested_delete(#{clazz.low_name}) end
+            def #{plural_name}_all(params = {}); nested_all(#{clazz}, params) end
+          RUBY
+        end
+      end
+    end
+  end
+end

data/lib/tiny_client/pagination_support.rb

@@ -0,0 +1,53 @@
+module TinyClient
+  # Mixin that add support for limit/offset pagination to {TinyClient::Resource}
+  module PaginationSupport
+    def self.included(resource_class)
+      raise ArgumentError, 'Works only for TinyClient::Resource' unless resource_class <= Resource
+      resource_class.extend(ClassMethods)
+    end
+
+    # Add methods that allows to walk fully through collections thanks to limit/offset pagination.
+    # All methods return an enumerator that will query the server in batch based on the limit size
+    # and total number of items.
+    module ClassMethods
+      # Similar to {Resource.index} but return all resources available at this path.
+      # It use limit and offset
+      # params to retrieved all resources. ( buffered by the limit size)
+      def index_all(params = {})
+        get_all(params)
+      end
+
+      # Similar to {index_all}, the return enumerator will yield on the buffered ( limit )
+      # rather than each element.
+      def index_in_batches(params = {})
+        get_in_batches(params)
+      end
+
+      def get_all(params = {}, id = nil, name = nil, resource_class = nil)
+        Enumerator.new do |y|
+          count = limit = params.fetch(:limit, @conf.limit || 100)
+          offset = params.fetch(:offset, 0)
+          while limit == count
+            inner = get(params.merge(limit: limit, offset: offset), id, name, resource_class)
+            loop { y << inner.next }
+            offset += limit
+            count = inner.count
+          end
+        end
+      end
+
+      def get_in_batches(params = {}, id = nil, name = nil, resource_class = nil)
+        Enumerator.new do |y|
+          count = limit = params.fetch(:limit, @conf.limit || 100)
+          offset = params.fetch(:offset, 0)
+          while limit == count
+            inner = get(params.merge(limit: limit, offset: offset), id, name, resource_class)
+            loop { y << inner }
+            offset += limit
+            count = inner.count
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tiny_client/remote_client.rb

@@ -0,0 +1,60 @@
+module TinyClient
+  # Remote Http client which delegates to the {CurbRequestor}.
+  class RemoteClient
+    def initialize(config)
+      @config = config
+    end
+
+    #    GET /<path>/<id>/<name>?<params>
+    # @raise [ResponseError] if the server respond with an error status (i.e 404, 500..)
+    # @return [Response]
+    def get(path, params, id, name)
+      url = build_url(path, id, name).query(params).build!
+      CurbRequestor.perform_get(url, {
+        'Accept' => 'application/json',
+        'Content-Type' => 'application/x-www-form-urlencoded'
+      }.merge!(@config.headers), @config.connect_timeout, @config.verbose)
+    end
+
+    #    POST /<path>/<id>/<name>
+    # @param [Hash] data
+    # @raise [ResponseError] if the server respond with an error status (i.e 404, 500..)
+    # @return [Response]
+    def post(data, path, id, name)
+      url = build_url(path, id, name).build!
+      CurbRequestor.perform_post(url, {
+        'Accept' => 'application/json',
+        'Content-Type' => 'application/json'
+      }.merge!(@config.headers), data.to_json, @config.connect_timeout, @config.verbose)
+    end
+
+    #    PUT /<path>/<id>/<name>
+    # @param [Hash] data the resource data
+    # @raise [ResponseError] if the server respond with an error status (i.e 404, 500..)
+    # @return [Response]
+    def put(data, path, id, name)
+      url = build_url(path, id, name).build!
+      CurbRequestor.perform_put(url, {
+        'Accept' => 'application/json',
+        'Content-Type' => 'application/json'
+      }.merge!(@config.headers), data.to_json, @config.connect_timeout, @config.verbose)
+    end
+
+    #    DELETE /<path>/<id>.json
+    # @raise [ResponseError] if the server respond with an error status (i.e 404, 500..)
+    # @return [Response]
+    def delete(path, id, name)
+      url = build_url(path, id, name).build!
+      CurbRequestor.perform_delete(url, {
+        'Accept' => 'application/json',
+        'Content-Type' => 'application/x-www-form-urlencoded'
+      }.merge!(@config.headers), @config.connect_timeout, @config.verbose)
+    end
+
+    private
+
+    def build_url(path, id, name)
+      UrlBuilder.url(@config.url).path(path).path(id).path(name)
+    end
+  end
+end

data/lib/tiny_client/resource.rb

@@ -0,0 +1,235 @@
+require 'set'
+require 'active_support/json'
+require 'active_support/core_ext/object/json'
+module TinyClient
+  # This is the core of TinyClient.
+  # Subclass {TinyClient::Resource} in order to create an HTTP/JSON tiny client.
+  #
+  # {file:README.md Getting Started}
+  # @author @barjo
+  class Resource
+    include PaginationSupport
+    include NestedSupport
+
+    # A resource always have an id
+    attr_accessor :id
+
+    class << self
+      # Set this resource client configuration
+      # @param [Configuration] config the api url and client default headers.
+      def conf(config)
+        @conf ||= config
+      end
+
+      # Set the resource path, default is the class name in lower case.
+      # @param [String] path the resource path
+      def path(path = nil)
+        @path ||= path || low_name
+      end
+
+      # @param [*String] names the resource field names
+      def fields(*names)
+        @fields ||= field_accessor(names) && names
+      end
+
+      # GET /<path>.json
+      # @param [Hash] params query parameters
+      # @raise [ResponseError] if the server respond with an error status (i.e 404, 500..)
+      # @return [Enumerator] enumerate the resources available at this path.
+      def index(params = {})
+        get(params)
+      end
+
+      # POST /<resource_path>.json
+      # Create a new resource. The resource will be indexed by it's name.
+      # @param [Object] content the resource/attributes to be created.
+      # @raise [ResponseError] if the server respond with an error status (i.e 404, 500..)
+      # @return the created resource
+      def create(content)
+        data = { low_name => content }
+        post(data)
+      end
+
+      # GET /<resource_path>/{id}
+      # @param [String, Integer] id the resource id
+      # @raise [ResponseError] if the server respond with an error status (i.e 404, 500..)
+      # @return the resource available at that path
+      def show(id, params = {})
+        get(params, id)
+      end
+
+      # GET /<path>/{id}/<name>
+      # @raise [ResponseError] if the server respond with an error status (i.e 404, 500..)
+      def get(params = {}, id = nil, name = nil, resource_class = nil)
+        resp = @conf.requestor.get(@path, params, id, name)
+        (resource_class || self).from_response resp
+      end
+
+      # POST /<path>/{id}/<name>
+      # @raise [ResponseError] if the server respond with an error status (i.e 404, 500..)
+      # @raise [ArgumentError] if data cannot be serialized as a json string ( .to_json )
+      def post(data, id = nil, name = nil, resource_class = nil)
+        verify_json(data)
+        resp = @conf.requestor.post(data, @path, id, name)
+        (resource_class || self).from_response resp
+      end
+
+      # Will query PUT /<path>/{id}
+      # @param [String, Integer] id the id of the resource that needs to be updated
+      # @param [Object] content the updated attributes/fields/resource
+      # @raise [ResponseError] if the server respond with an error status (i.e 404, 500..)
+      # @return the updated resource
+      def update(id, content)
+        data = { low_name => content }
+        put(data, id)
+      end
+
+      # PUT /<path>/{id}/<name>
+      # @raise [ResponseError] if the server respond with an error status (i.e 404, 500..)
+      # @raise [ArgumentError] if data cannot be serialized as a json string ( .to_json )
+      def put(data, id = nil, name = nil, resource_class = nil)
+        verify_json(data)
+        resp = @conf.requestor.put(data, @path, id, name)
+        (resource_class || self).from_response resp
+      end
+
+      # delete /<path>/{id}.json
+      # @raise [ResponseError] if the server respond with an error status (i.e 404, 500..)
+      def delete(id = nil, name = nil, resource_class = nil)
+        resp = @conf.requestor.delete(@path, id, name)
+        (resource_class || self).from_response resp
+      end
+
+      def low_name
+        @low_name ||= name.demodulize.underscore
+      end
+
+      # Create a resouce instance from an Hash.
+      # @param [Hash] hash the resource fields with their values
+      # @param [Boolean] track_changes if true all fields will be marked has changed
+      # @return [Resource] the newly created resource
+      def build(hash, track_changes = true)
+        resource = fields.each_with_object(new) do |field, r|
+          value = hash.fetch(field.to_s, hash[field.to_sym])
+          r.send("#{field}=", value)
+        end
+        resource.clear_changes! unless track_changes
+        resource
+      end
+
+      # @return [Response] the last response that has been received for that resource
+      def last_response
+        Thread.current[:_tclr]
+      end
+
+      protected
+
+      # Create a resource instance from a {Response}.
+      # If the response contains an Array of resource hash, an Enumerator will be return.
+      # @param [Response] response obtained from making a request.
+      # @raise [ResponseError] if the server respond with an error status (i.e 404, 500..)
+      # @return [Resource, Enumerator, nil] the resources created from the given response.
+      def from_response(response)
+        Thread.current[:_tclr] = response
+        body = response.parse_body
+        return build(body, false) if body.is_a? Hash
+        return Enumerator.new(body.size) do |yielder|
+          inner = body.each
+          loop { yielder << build(inner.next, false) }
+        end if body.is_a? Array
+        body # no content
+      end
+
+      private
+
+      def verify_json(data)
+        raise ArgumentError, 'data must respond to .to_json' unless data.respond_to? :to_json
+      end
+
+      def field_accessor(names)
+        names.each do |name|
+          class_eval <<-RUBY
+            def #{name}; @#{name} end
+
+            def #{name}=(#{name})
+              @#{name}= #{name}
+              @changes << :#{name} # keep track of fields that has been modified
+            end
+            RUBY
+        end
+      end
+    end
+
+    # the fields that has beem modified, and will be save on {save!}
+    attr_reader :changes
+
+    def initialize(*_args)
+      @changes = Set.new # store the fields change here
+    end
+
+    # Save the resource fields that has changed, or create it, if it's a new one!
+    #    Create the a new resource if id is not set or update the corresonding resource.
+    #    Create is done by calling POST on the resource path
+    #    Update is done by calling PUT on the resource id ( path/id )
+    # @raise [ResponseError] if the server respond with an error status (i.e 404, 500..)
+    # @return [Resource] the updated resource
+    def save!
+      data = @changes.to_a.each_with_object({}) { |field, h| h[field] = send(field) }
+      saved = id.present? ? self.class.update(id, data) : self.class.create(data)
+      clone_fields(saved)
+      clear_changes!
+      self
+    end
+
+    # Destroy this resource. It will call delete on this resource id.
+    # DELETE /path/id
+    # @raise [ResponseError] if the server respond with an error status (i.e 404, 500..)
+    # @raise [ResourceError] if this resource does not have an id.
+    # @return the deleted resource
+    def destroy!
+      raise ResourceError, 'Cannot delete resource if @id not present' if id.blank?
+      self.class.delete(id)
+      self
+    end
+
+    # Load/Reload this resource from the server.
+    # It will reset all fields that has been retrieved through the request.
+    # It will do a GET request on the resource id (:show)
+    # @param [Hash] params optional query parameters
+    # @raise [ResponseError] if the server respond with an error status (i.e 404, 500..)
+    # @raise [ResourceError] if this resource does not have an id.
+    # @return self with updated fields.
+    def load!(params = {})
+      raise ResourceError, 'Cannot load resource if @id not present' if id.blank?
+      # get the values from the persistence layer
+      reloaded = self.class.show(@id, params)
+      clone_fields(reloaded)
+      clear_changes!
+      reloaded
+    end
+
+    # Mark all fields has not changed. This mean that calling save! will not modify this resource
+    # until a field attribute has been changed.
+    def clear_changes!
+      @changes.clear
+    end
+
+    # see http://edgeguides.rubyonrails.org/active_support_core_extensions.html#json-support
+    # @param [Hash] options for the hash transformation
+    # @option [Array] only limit the hash content to those fields
+    # @return [Hash] a json ready representation of this resource
+    def as_json(options = {})
+      self.class.fields.each_with_object({}) do |field, h|
+        h[field] = send(field)
+      end.as_json(options)
+    end
+
+    alias to_h as_json
+
+    private
+
+    def clone_fields(resource)
+      self.class.fields.each { |f| send("#{f}=", resource.send(f)) }
+    end
+  end
+end

data/lib/tiny_client/resource_error.rb

@@ -0,0 +1,5 @@
+module TinyClient
+  # Raised when an trying to {Resource#load!} or {Resource#destroy!} a resource that does not have
+  # an id.
+  class ResourceError < StandardError; end
+end

data/lib/tiny_client/response.rb

@@ -0,0 +1,73 @@
+require 'active_support/json/decoding'
+require 'active_support/gzip'
+
+module TinyClient
+  # Wrap the curl request response.
+  class Response
+    attr_reader :status, :body_str, :header_str, :url, :code
+
+    def initialize(curb)
+      @status = curb.status
+      @body_str = curb.body_str
+      @header_str = curb.header_str
+      @code = @status.to_i
+      @url = curb.url
+    end
+
+    # Convert the response json body into an hash.
+    # @return the parsed response body
+    def parse_body
+      body = gzip? ? gzip_decompress : body_str
+      ActiveSupport::JSON.decode(body) if body.present?
+    end
+
+    # Parse the X-Total-Count header
+    # @return [Integer] the value of the X-Total-Count header, or nil if not present
+    def total_count
+      count = header_str[/X-Total-Count: ([0-9]+)/, 1]
+      count.present? ? count.to_i : nil
+    end
+
+    # @return true if this response Content-Encoding is gzip
+    def gzip?
+      /Content-Encoding: gzip/ =~ header_str
+    end
+
+    # @return true if the http request has been successful.
+    def success?
+      (200..299).cover?(@code)
+    end
+
+    # @return true if the HTTP status code of this response correspond to an client or server error.
+    def error?
+      @code >= 400
+    end
+
+    def client_error?
+      (400..499).cover?(@code)
+    end
+
+    def server_error?
+      @code >= 500
+    end
+
+    def redirect?
+      (300..399).cover?(@code)
+    end
+
+    def to_s
+      {
+        url: url,
+        status: status,
+        body: body_str,
+        headers: header_str
+      }.to_s
+    end
+
+    protected
+
+    def gzip_decompress
+      ActiveSupport::Gzip.decompress(body_str)
+    end
+  end
+end

data/lib/tiny_client/response_error.rb

@@ -0,0 +1,11 @@
+module TinyClient
+  # Raised when an HTTP error occured during the request. See {Response#error?}
+  class ResponseError < StandardError
+    attr_reader :response
+
+    def initialize(response)
+      @response = response
+      @message = "Error #{response.status} occured when calling #{response.url}"
+    end
+  end
+end

data/lib/tiny_client/url_builder.rb

@@ -0,0 +1,43 @@
+require 'active_support/core_ext/hash'
+
+module TinyClient
+  # Convenient class used to build a request URL.
+  class UrlBuilder
+    SEPARATOR = '/'.freeze
+    attr_writer :query
+
+    def self.url(url)
+      new(url)
+    end
+
+    def path(path)
+      @path << fix_path(path) unless path.blank?
+      self
+    end
+
+    def query(params = {})
+      @query.merge!(params) unless params.empty?
+      self
+    end
+
+    def build!
+      query_s = "?#{@query.to_query}" unless @query.empty?
+      "#{@path.join(SEPARATOR)}.json#{query_s}"
+    end
+
+    private
+
+    def initialize(url)
+      @path = [url]
+      @query = {}
+    end
+
+    def fix_path(path)
+      if path.respond_to?(:gsub)
+        path.gsub(/\.json$/, '')
+      else
+        path
+      end
+    end
+  end
+end

data/tiny_client.gemspec

@@ -0,0 +1,27 @@
+Gem::Specification.new do |s|
+  s.name    = 'tiny_client'
+  s.authors = ['TINYpulse swat team']
+  s.version = '0.4.0'
+  s.description = 'TINYclient, an HTTP/JSON crud client toolkit.'
+  s.email = 'jonathan@tinypulse.com'
+  s.extra_rdoc_files = ['LICENSE', 'README.md']
+  s.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+
+  #### Load-time details
+  s.require_paths = %w(lib ext)
+  s.rubyforge_project = 'tiny_client'
+  s.summary = 'TINYclient is an HTTP/JSON crud toolkit inspired by ActiveRecord and based on Curb.'
+  s.test_files = ['test/tiny_client/']
+
+  #### Documentation and testing.
+  s.has_rdoc = 'yard'
+  s.homepage = 'https://github.com/TINYhr/tiny_client'
+  s.rdoc_options = ['--main', 'README.md']
+
+  s.platform = Gem::Platform::RUBY
+
+  s.license = 'MIT'
+
+  s.add_runtime_dependency 'curb', '> 0.7.0', '< 1.0.0'
+  s.add_runtime_dependency 'activesupport', '>= 4.0', '< 6.0'
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: tiny_client
+version: !ruby/object:Gem::Version
+  version: 0.4.0
+platform: ruby
+authors:
+- TINYpulse swat team
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-05-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: curb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+description: TINYclient, an HTTP/JSON crud client toolkit.
+email: jonathan@tinypulse.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/tiny_client.rb
+- lib/tiny_client/configuration.rb
+- lib/tiny_client/curb_requestor.rb
+- lib/tiny_client/nested_support.rb
+- lib/tiny_client/pagination_support.rb
+- lib/tiny_client/remote_client.rb
+- lib/tiny_client/resource.rb
+- lib/tiny_client/resource_error.rb
+- lib/tiny_client/response.rb
+- lib/tiny_client/response_error.rb
+- lib/tiny_client/url_builder.rb
+- tiny_client.gemspec
+homepage: https://github.com/TINYhr/tiny_client
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--main"
+- README.md
+require_paths:
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: tiny_client
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: TINYclient is an HTTP/JSON crud toolkit inspired by ActiveRecord and based
+  on Curb.
+test_files: []