rest-in-peace 1.4.0 → 2.0.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZmYzY2NhN2JjMjNiZWRlOTZkY2ZiMjY0MzA1MDIzNTI5ZWFjMWYwOQ==
+  data.tar.gz: !binary |-
+    YjA3MTliNWE4MDA3MDhlYzAzM2M1NzRlMWNhYzVjNzExYmRhNTE1MA==
+SHA512:
+  metadata.gz: !binary |-
+    NTU2NWQ2NTc4NGMzMzgxMmY1OTVlYTc1NDE5ODkxMDEyODJkNTliMDhhZTYx
+    NzFlZjRmMDdkNTEwODZiMTA1YjJlYmFkMWZlMmIyNmIwNzZmNjdmZTFlNTVi
+    ZjE2MWIzZDE1YTI3NWI3ZGM5MDNkOWUxMWEwOWNjYjg3YjM2MjE=
+  data.tar.gz: !binary |-
+    ZWFlOTFkNTNkMTQ3MTFhMTA2YTBlYjczMzdiZTlmNTE4ZTM5ODhhM2E0ZjY0
+    ZDMwYjhhOWMyMTc5YzdjMDUxNWEyOWMzNDE3ZjdmMDU0ODFkMjRlNmNlZjRj
+    NzQ0OWUxNmUzYTg4MjQ1M2Y2NTliMjAwNTIwNDcxMTk2ZWRjYTg=

data/README.md

@@ -22,6 +22,22 @@ There is no dependency on a specific HTTP client library but the client has been
 
 ### Configuration
 
+#### Attributes
+
+You need to specify all the attributes which should be read out of the parsed JSON. You have to specify whether an attribute
+is readonly or writeable:
+
+```ruby
+rest_in_peace do
+  attributes do
+    read :id
+    write :name
+  end
+end
+```
+
+#### API Endpoints
+
 You need to define all the API endpoints you want to consume with `RESTinPeace`. Currently the four HTTP Verbs `GET`, `POST`, `PATCH` and `DELETE` are supported.
 
 There are two sections where you can specify endpoints: `resource` and `collection`:
@@ -73,6 +89,8 @@ resource.create # calls "POST /rip"
 resource.reload # calls "GET /rip/1"
 ```
 
+**For any writing action (`:post`, `:put`, `:patch`) RESTinPeace will include the writable attributes in the body and `id`.**
+
 #### Collection
 
 If you define anything inside the `collection` block, it will define a method on the class:
@@ -107,6 +125,42 @@ end
 
 An example pagination mixin with HTTP headers can be found in the [examples directory](https://github.com/ninech/REST-in-Peace/blob/master/examples) of this repo.
 
+#### ActiveModel Support
+
+For easy interoperability with Rails, there is the ability to include ActiveModel into your class. To enable this support, follow these steps:
+
+* Define a `create` method (To be called for saving new objects)
+* Define a `save` method (To be called for updates)
+* Call `acts_as_active_model` **after** your *API endpoints* and *attribute* definitions
+
+##### Example
+
+```ruby
+require 'rest_in_peace'
+
+module MyClient
+  class Fabric < Struct.new(:id, :name, :ip)
+    include RESTinPeace
+
+    rest_in_peace do
+      use_api ->() { MyClient.api }
+    
+      attributes do
+        read :id
+        write :name
+      end
+
+      resource do
+        post :create, '/fabrics'
+        patch :save, '/fabrics/:id'
+      end
+      
+      acts_as_active_model
+    end
+  end
+end
+```
+
 #### Complete Configuration
 
 ```ruby
@@ -114,12 +168,17 @@ require 'my_client/paginator'
 require 'rest_in_peace'
 
 module MyClient
-  class Fabric < Struct.new(:id, :name, :ip)
+  class Fabric
     include RESTinPeace
 
     rest_in_peace do
       use_api ->() { MyClient.api }
     
+      attributes do
+        read :id
+        write :name
+      end
+
       resource do
         patch :save, '/fabrics/:id'
         post :create, '/fabrics'
@@ -131,6 +190,8 @@ module MyClient
         get :all, '/fabrics', paginate_with: MyClient::Paginator
         get :find, '/fabrics/:id'
       end
+
+      acts_as_active_model
     end
   end
 end
@@ -149,7 +210,7 @@ ssl_config = {
   "ca_cert"     => "/etc/ssl/certs/ca-chain.crt"
 }
 
-ssl_config_creator = RESTinPeace::SSLConfigCreator.new(ssl_config, :peer)
+ssl_config_creator = RESTinPeace::Faraday::SSLConfigCreator.new(ssl_config, :peer)
 ssl_config_creator.faraday_options.inspect
 # =>
 {
@@ -158,4 +219,16 @@ ssl_config_creator.faraday_options.inspect
   :ca_file     => "/etc/ssl/certs/ca-chain.crt",
   :verify_mode => 1
 }
+```
+
+### Faraday Middleware: RIP Raise Errors
+
+This middleware is mostly equivalent to [this one](https://github.com/lostisland/faraday/blob/cf549f4d883a3cae15db0d835628daa33f6f3a2b/lib/faraday/response/raise_error.rb) but it does not raise an error when the HTTP status code is `422` as this code is used to return validation errors.
+
+```ruby
+Faraday.new do |faraday|
+  # ...
+  faraday.response :rip_raise_errors
+  # ...
+end
 ```

data/VERSION

@@ -1 +1 @@
-1.4.0
+2.0.0

data/lib/rest_in_peace/active_model_api.rb

@@ -0,0 +1,72 @@
+require 'active_model'
+
+module RESTinPeace
+  module ActiveModelAPI
+    class MissingMethod < RESTinPeace::DefaultError
+      def initialize(method)
+        super "No #{method} method has been defined. "\
+              'Maybe you called acts_as_active_model before defining the api endpoints?'
+      end
+    end
+
+    def self.included(base)
+      check_for_missing_methods(base)
+
+      base.send(:include, ActiveModel::Dirty)
+      base.send(:include, ActiveModel::Conversion)
+      base.extend ActiveModel::Naming
+
+      base.send(:alias_method, :save_without_dirty_tracking, :save)
+      base.send(:alias_method, :save, :save_with_dirty_tracking)
+
+      base.send :define_attribute_methods, base.rip_attributes[:write]
+
+      base.rip_attributes[:write].each do |attribute|
+        base.send(:define_method, "#{attribute}_with_dirty_tracking=") do |value|
+          attribute_will_change!(attribute) unless send(attribute) == value
+          send("#{attribute}_without_dirty_tracking=", value)
+        end
+
+        base.send(:alias_method, "#{attribute}_without_dirty_tracking=", "#{attribute}=")
+        base.send(:alias_method, "#{attribute}=", "#{attribute}_with_dirty_tracking=")
+      end
+
+      def base.human_attribute_name(attr, options = {})
+        attr.to_s
+      end
+
+      def base.lookup_ancestors
+        [self]
+      end
+    end
+
+    def self.check_for_missing_methods(base)
+      raise MissingMethod, :save unless base.instance_methods.include?(:save)
+      raise MissingMethod, :create unless base.instance_methods.include?(:create)
+    end
+
+    def save_with_dirty_tracking
+      save_without_dirty_tracking.tap do
+        @changed_attributes.clear if @changed_attributes
+      end
+    end
+
+    def persisted?
+      !!id
+    end
+
+    def read_attribute_for_validation(attr)
+      send(attr)
+    end
+
+    def errors
+      @errors ||= ActiveModel::Errors.new(self)
+    end
+
+    def errors=(new_errors)
+      new_errors.each do |key, value|
+        errors.set(key.to_sym, [value].flatten)
+      end
+    end
+  end
+end

data/lib/rest_in_peace/definition_proxy/attributes_definitions.rb

@@ -0,0 +1,20 @@
+module RESTinPeace
+  class DefinitionProxy
+    class AttributesDefinitions
+      def initialize(target)
+        @target = target
+      end
+
+      def read(*attributes)
+        @target.send(:attr_reader, *attributes)
+        @target.rip_attributes[:read].concat(attributes)
+      end
+
+      def write(*attributes)
+        read(*attributes)
+        @target.send(:attr_writer, *attributes)
+        @target.rip_attributes[:write].concat(attributes)
+      end
+    end
+  end
+end

data/lib/rest_in_peace/definition_proxy/collection_method_definitions.rb

@@ -11,6 +11,7 @@ module RESTinPeace
       def get(method_name, url_template, default_params = {})
         @target.rip_registry[:collection] << { method: :get, name: method_name, url: url_template }
         @target.send(:define_singleton_method, method_name) do |given_params = {}|
+          raise RESTinPeace::DefinitionProxy::InvalidArgument unless given_params.respond_to?(:merge)
           params = default_params.merge(given_params)
 
           call = RESTinPeace::ApiCall.new(api, url_template, self, params)

data/lib/rest_in_peace/definition_proxy/resource_method_definitions.rb

@@ -8,7 +8,7 @@ module RESTinPeace
       def get(method_name, url_template, default_params = {})
         @target.rip_registry[:resource] << { method: :get, name: method_name, url: url_template }
         @target.send(:define_method, method_name) do
-          call = RESTinPeace::ApiCall.new(api, url_template, self, to_h)
+          call = RESTinPeace::ApiCall.new(api, url_template, self, hash_for_updates)
           call.get
         end
       end
@@ -16,7 +16,7 @@ module RESTinPeace
       def patch(method_name, url_template)
         @target.rip_registry[:resource] << { method: :patch, name: method_name, url: url_template }
         @target.send(:define_method, method_name) do
-          call = RESTinPeace::ApiCall.new(api, url_template, self, to_h)
+          call = RESTinPeace::ApiCall.new(api, url_template, self, hash_for_updates)
           call.patch
         end
       end
@@ -24,7 +24,7 @@ module RESTinPeace
       def post(method_name, url_template)
         @target.rip_registry[:resource] << { method: :post, name: method_name, url: url_template }
         @target.send(:define_method, method_name) do
-          call = RESTinPeace::ApiCall.new(api, url_template, self, to_h)
+          call = RESTinPeace::ApiCall.new(api, url_template, self, hash_for_updates)
           call.post
         end
       end
@@ -32,16 +32,15 @@ module RESTinPeace
       def put(method_name, url_template)
         @target.rip_registry[:resource] << { method: :put, name: method_name, url: url_template }
         @target.send(:define_method, method_name) do
-          call = RESTinPeace::ApiCall.new(api, url_template, self, to_h)
+          call = RESTinPeace::ApiCall.new(api, url_template, self, hash_for_updates)
           call.put
         end
       end
 
-      def delete(method_name, url_template, default_params = {})
+      def delete(method_name, url_template)
         @target.rip_registry[:resource] << { method: :delete, name: method_name, url: url_template }
-        @target.send(:define_method, method_name) do |params = {}|
-          merged_params = default_params.merge(to_h).merge(params)
-          call = RESTinPeace::ApiCall.new(api, url_template, self, merged_params)
+        @target.send(:define_method, method_name) do
+          call = RESTinPeace::ApiCall.new(api, url_template, self, id: id)
           call.delete
         end
       end

data/lib/rest_in_peace/definition_proxy.rb

@@ -1,8 +1,16 @@
 require 'rest_in_peace/definition_proxy/resource_method_definitions'
 require 'rest_in_peace/definition_proxy/collection_method_definitions'
+require 'rest_in_peace/definition_proxy/attributes_definitions'
+require 'rest_in_peace/active_model_api'
 
 module RESTinPeace
   class DefinitionProxy
+    class InvalidArgument < RESTinPeace::DefaultError
+      def initialize
+        super('Given parameter must respond to `merge`.')
+      end
+    end
+
     def initialize(target)
       @target = target
     end
@@ -17,6 +25,19 @@ module RESTinPeace
       method_definitions.instance_eval(&block)
     end
 
+    def attributes(&block)
+      method_definitions = RESTinPeace::DefinitionProxy::AttributesDefinitions.new(@target)
+      method_definitions.instance_eval(&block)
+    end
+
+    def acts_as_active_model
+      @target.send(:include, RESTinPeace::ActiveModelAPI)
+    end
+
+    def namespace_attributes_with(namespace)
+      @target.rip_namespace = namespace
+    end
+
     def use_api(api)
       @target.api = api
     end

data/lib/rest_in_peace/faraday/raise_errors_middleware.rb

@@ -0,0 +1,34 @@
+require 'faraday'
+
+module RESTinPeace
+  module Faraday
+    class RaiseErrorsMiddleware < ::Faraday::Response::Middleware
+      CLIENT_ERROR_STATUSES = 400...600
+
+      def on_complete(env)
+        case env[:status]
+        when 404
+          raise Faraday::Error::ResourceNotFound, response_values(env)
+        when 407
+          # mimic the behavior that we get with proxy requests with HTTPS
+          raise Faraday::Error::ConnectionFailed, %{407 "Proxy Authentication Required "}
+        when 422
+          # do not raise an error as 422 from a rails app means validation errors
+          # and response body contains the validation errors
+        when CLIENT_ERROR_STATUSES
+          raise Faraday::Error::ClientError, response_values(env)
+        end
+      end
+
+      def response_values(env)
+        {
+          status: env.status,
+          headers: env.response_headers,
+          body: env.body,
+        }
+      end
+    end
+
+    ::Faraday::Response.register_middleware rip_raise_errors: RaiseErrorsMiddleware
+  end
+end

data/lib/rest_in_peace/faraday/ssl_config_creator.rb

@@ -0,0 +1,66 @@
+require 'openssl'
+
+module RESTinPeace
+  module Faraday
+    class SSLConfigCreator
+      class MissingParam < Exception; end
+
+      def initialize(config, verify = :peer)
+        @config = config
+        @verify = verify
+
+        raise MissingParam, 'Specify :ca_cert in ssl options' unless @config[:ca_cert]
+        raise MissingParam, 'Specify :client_key in ssl options' unless @config[:client_key]
+        raise MissingParam, 'Specify :client_cert in ssl options' unless @config[:client_cert]
+      end
+
+      def faraday_options
+        {
+          client_cert: client_cert,
+          client_key: client_key,
+          ca_file: ca_cert_path,
+          verify_mode: verify_mode,
+        }
+      end
+
+      def client_cert
+        OpenSSL::X509::Certificate.new(open_file(client_cert_path))
+      end
+
+      def client_cert_path
+        path(@config[:client_cert])
+      end
+
+      def client_key
+        OpenSSL::PKey::RSA.new(open_file(client_key_path))
+      end
+
+      def client_key_path
+        path(@config[:client_key])
+      end
+
+      def ca_cert_path
+        path(@config[:ca_cert])
+      end
+
+      def verify_mode
+        case @verify
+        when :peer
+          OpenSSL::SSL::VERIFY_PEER
+        else
+          raise "Unknown verify variant '#{@verify}'"
+        end
+      end
+
+      private
+
+      def open_file(file)
+        File.open(file)
+      end
+
+      def path(file)
+        File.join(file)
+      end
+    end
+  end
+end

data/lib/rest_in_peace/response_converter.rb

@@ -1,35 +1,51 @@
 module RESTinPeace
   class ResponseConverter
-    def initialize(response, klass)
-      @response = response
-      @klass = klass
+    class UnknownConvertStrategy < RESTinPeace::DefaultError
+      def initialize(klass)
+        super("Don't know how to convert #{klass}")
+      end
+    end
+
+    attr_accessor :body, :klass, :existing_instance
+
+    def initialize(response, instance_or_class)
+      self.body = response.body
+
+      if instance_or_class.respond_to?(:new)
+        self.klass = instance_or_class
+        self.existing_instance = new_instance
+      else
+        self.klass = instance_or_class.class
+        self.existing_instance = instance_or_class
+      end
     end
 
     def result
-      case @response.body.class.to_s
+      case body.class.to_s
       when 'Array'
         convert_from_array
       when 'Hash'
         convert_from_hash
       when 'String'
-        @response.body
+        body
       else
-        raise "Don't know how to convert #{@response.body.class}"
+        raise UnknownConvertStrategy, body.class
       end
     end
 
     def convert_from_array
-      @response.body.map do |entity|
-        convert_from_hash(entity)
+      body.map do |entity|
+        convert_from_hash(entity, new_instance)
       end
     end
 
-    def convert_from_hash(entity = @response.body)
-      klass.new entity
+    def convert_from_hash(entity = body, instance = existing_instance)
+      instance.force_attributes_from_hash entity
+      instance
     end
 
-    def klass
-      @klass.respond_to?(:new) ? @klass : @klass.class
+    def new_instance
+      klass.new
     end
   end
 end

data/lib/rest_in_peace/template_sanitizer.rb

@@ -16,7 +16,7 @@ module RESTinPeace
       tokens.each do |token|
         param = @params.delete(token.to_sym)
         raise IncompleteParams, "Unknown parameter for token :#{token} found" unless param
-        @url.gsub!(%r{:#{token}}, param.to_s)
+        @url.sub!(%r{:#{token}}, param.to_s)
       end
       @url
     end

data/lib/rest_in_peace.rb

@@ -11,28 +11,57 @@ module RESTinPeace
   end
 
   def initialize(attributes = {})
-    update_from_hash(attributes)
+    force_attributes_from_hash(attributes)
   end
 
-  def to_h
-    Hash[each_pair.to_a]
+  def hash_for_updates
+    hash_representation = { id: id }
+    self.class.rip_attributes[:write].map do |key|
+      value = send(key)
+      hash_representation[key] = hash_representation_of_object(value)
+    end
+    if self.class.rip_namespace
+      { id: id, self.class.rip_namespace => hash_representation }
+    else
+      hash_representation
+    end
   end
 
   def update_attributes(attributes)
-    update_from_hash(attributes)
+    attributes.each do |key, value|
+      next unless respond_to?("#{key}=")
+      send("#{key}=", value)
+    end
   end
 
-  protected
+  def to_h
+    hash_representation = {}
+    self.class.rip_attributes.values.flatten.each do |attr|
+      hash_representation[attr] = send(attr)
+    end
+    hash_representation
+  end
 
-  def update_from_hash(hash)
-    hash.each do |key, value|
-      next unless self.class.members.map(&:to_s).include?(key.to_s)
-      send("#{key}=", value)
+  def force_attributes_from_hash(attributes)
+    attributes.each do |key, value|
+      next unless respond_to?(key)
+      if respond_to?("#{key}=")
+        send("#{key}=", value)
+      else
+        instance_variable_set("@#{key}", value)
+      end
     end
   end
 
+  def hash_representation_of_object(object)
+    return object.hash_for_updates if object.respond_to?(:hash_for_updates)
+    return object.map { |element| hash_representation_of_object(element) } if object.is_a?(Array)
+    object
+  end
+
   module ClassMethods
     attr_accessor :api
+    attr_accessor :rip_namespace
 
     def rest_in_peace(&block)
       definition_proxy = RESTinPeace::DefinitionProxy.new(self)
@@ -45,5 +74,12 @@ module RESTinPeace
         collection: [],
       }
     end
+
+    def rip_attributes
+      @rip_attributes ||= {
+        read: [],
+        write: [],
+      }
+    end
   end
 end

data/rest-in-peace.gemspec

@@ -17,9 +17,11 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ['lib']
 
+  s.add_runtime_dependency 'activemodel', '> 3.2', '<= 4.1'
+
   s.add_development_dependency 'rake', '~> 10.0'
   s.add_development_dependency 'rspec', '~> 3.0'
-  s.add_development_dependency 'guard', '~> 2.6.1'
-  s.add_development_dependency 'guard-rspec', '~> 4.2.0'
-  s.add_development_dependency 'simplecov', '~> 0.8.2'
+  s.add_development_dependency 'guard', '~> 2.6', '>= 2.6.1'
+  s.add_development_dependency 'guard-rspec', '~> 4.2', '>= 4.2.0'
+  s.add_development_dependency 'simplecov', '~> 0.8', '>= 0.8.2'
 end