flexirest 1.9.18 → 1.10.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a602c593b7748bb16605a196b249920ad733152fee9c7969fa56445b8c07003
-  data.tar.gz: 1e75b70398bcc73ee2fbd68a169c9f30ed1cbdd968e2f0d74272a1ed1b254737
+  metadata.gz: 9a072753fe6a84d8f13ae90d26cdff777e78fc129d4555b5188ae0c0be35ad78
+  data.tar.gz: 7e6ecfe247cc9f021a3e35f9cf4d3b28a6743694b53a2ca32c0ea988a2113276
 SHA512:
-  metadata.gz: 1d868df5a25277b88e0482e5cae4ba4398aa0ae4082766321988172365d7e1d955f6254f4a29eccd927f6d95d3734e81333f55760c1fbc0847f1ba6a249ae922
-  data.tar.gz: 2710c351b4f5770a4cc177d5ca7509aff9e988ff7b89a892bf4f57c35bb5834c5f41ca193ae22023b15de71118b19799c52491682dad86d041fd21dad9773a32
+  metadata.gz: 561fdb72c84a9bd3d0a353f46d4761179df66f3e45967bec4b4b620c6f818dca0058388b5f83c2d2455da1f21fa90a72ec0f73ab056fbf086dab522cc8f48fd7
+  data.tar.gz: 95d6f2852392a23c82a5ae0e157a9ad1bc391c4846e79946eab75236c1c3b409c8193a3550e42b9e19676b94a3cccda28e6f0ddf438e47b3e77de9c66669006a

data/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## 1.10.4
+
+Enhancement:
+
+- Implement support for in-header Basic Auth (thanks to François Ferrandis for the PR)
+
+## 1.10.3
+
+Enhancement:
+
+- Ignore/wrap root functionality available for all routes, rather than just route specifically (thanks to Sampat Badhe for the PR)
+
+## 1.10.2
+
+Bugfix:
+
+- JSON-API calls do not include linked resources when no other parameter is passed (thanks to Stevo-S for the bug report and François Ferrandis for the PR)
+
+## 1.10.1
+
+Enhancement:
+
+- Nested objects now report their dirty/changed status up to the parent (thanks to Matthias Hähnel for the bug report)
+
+## 1.10.0
+
+Enhancement:
+
+- Add specific exceptions for the most common 5xx server-side errors
+
 ## 1.9.18
 
 Security:

data/docs/authentication.md

@@ -40,6 +40,30 @@ Or if it's called from a class context:
 Person.find(id: 1234)
 ```
 
+### Basic authentication method
+
+Flexirest provides two methods for HTTP Basic Auth. The default method is `:url`:
+
+```ruby
+class Person < Flexirest::Base
+  basic_auth_method :url
+end
+# Includes the credentials in the URL:
+#   https://my_username:my_password@example.com/
+```
+
+But you might want to keep the credentials out of your logs and use the `:header` method:
+
+```ruby
+class Person < Flexirest::Base
+  basic_auth_method :header
+end
+# Clean URL:
+#   https://example.com/
+# with the base64 encoded credentials:
+#   Authorization: Basic YXBpOmViNjkzZWMtODI1MmMtZDYzMDEtMDJmZDAtZDBmYjctYzM0ODU=
+```
+
 ## Api-Auth
 
 Using the [Api-Auth](https://github.com/mgomes/api_auth) integration it is very easy to sign requests. Include the Api-Auth gem in your `Gemfile` and  then add it to your application. Then simply configure Api-Auth one time in your app and all requests will be signed from then on.

data/docs/filtering-result-lists.md

@@ -1,6 +1,6 @@
 # *Flexirest:* Filtering result lists
 
-If the API returns a JSON list of items, this is retured to you as a `Flexirest::ResultIterator` object. A `ResultIterator` sorts simple filtering of the list using a `where` method based on values matching a specified criteria (or matching using regular expressions):
+If the API returns a JSON list of items, this is returned to you as a `Flexirest::ResultIterator` object. A `ResultIterator` sorts simple filtering of the list using a `where` method based on values matching a specified criteria (or matching using regular expressions):
 
 ```ruby
 class Article < Flexirest::Base

data/docs/json-api.md

@@ -12,17 +12,26 @@ This proxy translates requests according to the JSON API specifications, parses
 
 It supports lazy loading by default. Unless a compound document is returned from the connected JSON API service, it will make another request to the service for the specified linked resource.
 
+
+## Including associations
+
 To reduce the number of requests to the service, you can ask the service to include the linked resources in the response. Such responses are called "compound documents". To do this, use the `includes` method:
 
 ```ruby
-# Makes a call to /articles with parameters: include=images
+# Makes a call to: /articles?include=images
 Article.includes(:images).all
 
-# For nested resources, the include parameter becomes: include=images.tags,images.photographer
+# Fetch nested resources: /articles?include=images.tags,images.photographer
 Article.includes(:images => [:tags, :photographer]).all
+
+# Note: the `includes` method takes precedence over the passed `:include` parameter.
+# This will result in query: /articles?include=images
+Article.includes(:images).all(include: "author")
 ```
 
-For POST and PATCH requests, the proxy formats a JSON API compliant request, and adds a `Content-Type: application/vnd.api+json` header. It guesses the `type` value in the resource object from the class name, but it can be set specifically with `alias_type`:
+## Resource type
+
+The `type` value is guessed from the class name, but it can be set specifically with `alias_type`:
 
 ```ruby
 class Photographer < Flexirest::Base
@@ -34,7 +43,10 @@ class Photographer < Flexirest::Base
 end
 ```
 
-NB: Updating relationships is not yet supported.
+
+## Notes
+
+Updating relationships is not yet supported.
 
 
 -----

data/docs/plain-requests.md

@@ -7,7 +7,7 @@ class Person < Flexirest::Base
 end
 
 people = Person._plain_request('http://api.example.com/v1/people') # Defaults to get with no parameters
-# people is a normal Flexirest object, implementing iteration, HAL loading, etc.
+# people is a string containing the response
 
 Person._plain_request('http://api.example.com/v1/people', :post, {id:1234,name:"John"}) # Post with parameters
 ```

data/docs/proxying-apis.md

@@ -40,7 +40,7 @@ Article.all.first_name == "Billy"
 This example does two things:
 
 1. It rewrites the incoming URL for any requests matching "_/all_" to "/all_people"
-2. It uses the `translate` method to move the "fname" attribute from the response body to be called "first_name". The translate method must return the new object at the end (either the existing object alterered, or a new object to replace it with)
+2. It uses the `translate` method to move the "fname" attribute from the response body to be called "first_name". The translate method must return the new object at the end (either the existing object altered, or a new object to replace it with)
 
 As the comment shows, you can use `url value` to set the request URL to a particular value, or you can call `gsub!` on the url to replace parts of it using more complicated regular expressions.
 

data/docs/raw-requests.md

@@ -1,6 +1,6 @@
 # *Flexirest:* Raw requests
 
-Sometimes you have have a URL that you just want to force through, but have the response handled in the same way as normal objects or you want to have the callbacks run (say for authentication). The easiest way to do that is to call `_request` on the class:
+Sometimes you have a URL that you just want to force through, but have the response handled in the same way as normal objects or you want to have the callbacks run (say for authentication). The easiest way to do that is to call `_request` on the class:
 
 ```ruby
 class Person < Flexirest::Base
@@ -12,7 +12,7 @@ people = Person._request('http://api.example.com/v1/people') # Defaults to get w
 Person._request('http://api.example.com/v1/people', :post, {id:1234,name:"John"}) # Post with parameters
 ```
 
-When you need to specify custom headers (for example for authentication) you can do this with a fourth option to the `_request` method. If you are using the default paramaters you'll need to specify them. For example:
+When you need to specify custom headers (for example for authentication) you can do this with a fourth option to the `_request` method. If you are using the default parameters you'll need to specify them. For example:
 
 ```ruby
 Person._request("http://api.example.com/v1/people", :get, {}, {headers:{"X-Something": "foo/bar"}})

data/docs/root-elements.md

@@ -2,13 +2,32 @@
 
 If your response comes back with a root node and you'd like to ignore it, you can define the mapping as:
 
+```ruby
+Flexirest::Base.ignore_root = "data"
+```
+
+Any `ignore_root` setting in specific class overrides this declared default.
+
 ```ruby
 class Feed < Flexirest::Base
-  post :list, "/feed", ignore_root: "feed"
+  ignore_root: "feed"
+
+  post :list, "/feed"
+end
+```
+
+And any `ignore_root` setting in specific request overrides the both default and class specific setting.
+
+
+```ruby
+class Feed < Flexirest::Base
+  ignore_root: 'feed'
+
+  post :list, "/feed", ignore_root: "result"
 end
 ```
 
-This also works if you'd want to remove a tree of root nodes:
+You can also assign an array to `ignore_root` if you'd want to remove a tree of root nodes.
 
 ```ruby
 class Feed < Flexirest::Base
@@ -26,16 +45,32 @@ Alternatively if you want to wrap your JSON request body in a root element, e.g.
 }
 ```
 
-You can do it like this:
+You can do it using `wrap_root`:
+
+```ruby
+Flexirest::Base.wrap_root = "data"
+```
+
+Any `wrap_root` setting in specific class overrides this declared default.
 
 ```ruby
 class Feed < Flexirest::Base
-  post :list, "/feed", wrap_root: "feed"
-end
+  wrap_root: "feed"
 
-Feed.list(id: 1)
+  post :list, "/feed"
+end
 ```
 
+And any `wrap_root` setting in specific request overrides the both default and class specific setting.
+
+
+```ruby
+class Feed < Flexirest::Base
+  wrap_root: 'feed'
+
+  post :list, "/feed", wrap_root: "data"
+end
+```
 
 -----
 

data/docs/using-callbacks.md

@@ -66,6 +66,7 @@ After callbacks work in exactly the same way:
 ```ruby
 class Person < Flexirest::Base
   get :all, "/people"
+  get :all, "/people"
 
   after_request :fix_empty_content
   after_request :cache_all_people
@@ -88,6 +89,32 @@ end
 
 **Note:** since v1.3.21 the empty response trick above isn't necessary, empty responses for 204 are accepted normally (the method returns `true`), but this is here to show an example of an `after_request` callback adjusting the body. The `cache_all_people` example shows how to cache a response even if the server doesn't send the correct headers.
 
+If you manually set caching responses like the above, you may want to invalidate that cache when you make a create, update, delete etc request for the resource, for example:
+
+```ruby
+class Animal < Flexirest::Base
+  after_request :cache
+  before_request :cache_cleanup
+
+  get :get, '/animals/:id'
+  post :update, '/animals/:id'
+  delete :delete, '/animals/:id'
+
+  def cache_cleanup(name, request)
+    if name == :update || name == :delete
+      Flexirest::Logger.info("  \033[1;4;32m#{Flexirest.name}\033[0m Invalidating cache for #{self.class.name} #{request.url}")
+      Rails.cache.delete("#{self.class.name}:#{request.url}")
+    end
+  end
+
+  def cache(name, response)
+    if name == :get
+      response.response_headers["Expires"] = 1.hour.from_now.iso8601
+    end
+  end
+end
+```
+
 If you want to trap an error in an `after_request` callback and retry the request, this can be done - but retries will only happen once for each request (so we'd recommend checking all conditions in a single `after_request` and then retrying after fixing them all). You achieve this by raising a `Flexirest::CallbackRetryRequestException` from the callback.
 
 ```ruby
@@ -100,7 +127,7 @@ class Person < Flexirest::Base
 
   def fix_invalid_request(name, response)
     if response.status == 401
-      # Do something to fix the state of caches/variables used in the 
+      # Do something to fix the state of caches/variables used in the
       # before_request, etc
       raise Flexirest::CallbackRetryRequestException.new
     end

data/flexirest.gemspec

@@ -39,7 +39,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "api-auth", ">= 1.3.1", "< 2.4"
   spec.add_development_dependency 'typhoeus'
   spec.add_development_dependency 'activemodel'
-  spec.add_development_dependency 'rest-client', ">= 1.8.0"
+  spec.add_development_dependency 'rest-client'
 
   spec.add_runtime_dependency "mime-types"
   spec.add_runtime_dependency "multi_json"
@@ -53,12 +53,4 @@ Gem::Specification.new do |spec|
   else
     spec.add_runtime_dependency "activesupport", "< 5.0.0"
   end
-  # JSON is an implicit dependency of something, but JSON v2+ requires Ruby 2+
-  # Same with "tins" which is a dependency of coveralls
-  if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.0.0')
-    spec.add_runtime_dependency "json", "< 2.0.0"
-    spec.add_runtime_dependency "tins", "~> 1.6.0"
-    spec.add_runtime_dependency "term-ansicolor", "~> 1.3.2"
-    spec.add_runtime_dependency "public_suffix", "~> 1.4.6"
-  end
 end

data/lib/flexirest/base_without_validation.rb

@@ -11,6 +11,8 @@ module Flexirest
     attr_accessor :_status
     attr_accessor :_etag
     attr_accessor :_headers
+    attr_accessor :_parent
+    attr_accessor :_parent_attribute_name
 
     instance_methods.each do |m|
       next unless %w{display presence load require untrust trust freeze method enable_warnings with_warnings suppress capture silence quietly debugger breakpoint}.map(&:to_sym).include? m
@@ -41,6 +43,13 @@ module Flexirest
     def _copy_from(result)
       @attributes = result._attributes
       @_status = result._status
+      self._parent = result._parent
+      self._parent_attribute_name = result._parent_attribute_name
+      @attributes.each do |k,v|
+        if v.respond_to?(:_parent) && v._parent.present?
+          @attributes[k]._parent = self
+        end
+      end
       _clean!
     end
 
@@ -184,6 +193,10 @@ module Flexirest
       output.to_json
     end
 
+    def _set_dirty(key)
+      @dirty_attributes[key.to_sym] = true
+    end
+
     private
 
     def _set_attribute(key, value)
@@ -191,6 +204,9 @@ module Flexirest
       old_value = @attributes[key.to_sym] unless old_value
       old_value = old_value[0] if old_value and old_value.is_a? Array
       @dirty_attributes[key.to_sym] = [old_value, value] if old_value != value
+      if _parent
+        _parent._set_dirty(_parent_attribute_name)
+      end
       @attributes[key.to_sym] = value
     end
 

data/lib/flexirest/configuration.rb

@@ -13,6 +13,32 @@ module Flexirest
       @api_auth_access_id = nil
       @api_auth_secret_key = nil
       @api_auth_options = {}
+      @ignore_root = nil
+      @wrap_root = nil
+
+      def ignore_root(value=nil)
+        if value.nil?
+          value = if @ignore_root.nil? && superclass.respond_to?(:ignore_root)
+            superclass.ignore_root
+          else
+            @ignore_root
+          end
+        else
+          @ignore_root = value
+        end
+      end
+
+      def wrap_root(value=nil)
+        if value.nil?
+          value = if @wrap_root.nil? && superclass.respond_to?(:wrap_root)
+            superclass.wrap_root
+          else
+            @wrap_root
+          end
+        else
+          @wrap_root = value
+        end
+      end
 
       def base_url(value = nil)
         @base_url ||= nil
@@ -109,6 +135,23 @@ module Flexirest
         @@password = value
       end
 
+      DEFAULT_BASIC_URL_METHOD = :url
+
+      def basic_auth_method(value = nil)
+        if value.nil? # Used as a getter method
+          if @basic_auth_method.nil? && superclass.respond_to?(:basic_auth_method)
+            superclass.basic_auth_method
+          else
+            @basic_auth_method || DEFAULT_BASIC_URL_METHOD
+          end
+        else # Used as a setter method
+          unless [:header, :url].include?(value)
+            raise %(Invalid basic_auth_method #{value.inspect}. Valid methods are :url (default) and :header.)
+          end
+          @basic_auth_method = value
+        end
+      end
+
       def alias_type(value = nil)
         @alias_type ||= nil
         if value.nil?
@@ -285,6 +328,7 @@ module Flexirest
         @adapter              = Faraday.default_adapter
         @api_auth_access_id   = nil
         @api_auth_secret_key  = nil
+        @basic_auth_method    = :url
       end
 
       private

data/lib/flexirest/json_api_proxy.rb

@@ -50,11 +50,8 @@ module Flexirest
         end
 
         def translate(params, include_associations)
-          # Return to caller if nothing is to be done
-          return params unless params.present? && include_associations.present?
-
           # Format the linked resources array, and assign to include key
-          params[:include] = format_include_params(include_associations)
+          params[:include] = format_include_params(include_associations) if include_associations.present?
         end
 
         private

data/lib/flexirest/lazy_association_loader.rb

@@ -94,6 +94,10 @@ module Flexirest
         request = Flexirest::Request.new(method, @request.object)
         request.url = request.forced_url = @url
         @object = request.call
+        if @object.respond_to?(:_parent=)
+          @object._parent = @options[:parent]
+          @object._parent_attribute_name = @options[:parent_attribute_name]
+        end
       end
     end
   end

data/lib/flexirest/request.rb

@@ -32,6 +32,10 @@ module Flexirest
       !@object.respond_to?(:dirty?)
     end
 
+    def model_class
+      object_is_class? ? @object : @object.class
+    end
+
     def class_name
       if object_is_class?
         @object.name
@@ -124,6 +128,18 @@ module Flexirest
       ret
     end
 
+    def inject_basic_auth_in_url(url)
+      url.gsub!(%r{//(.)}, "//#{username}:#{password}@\\1") if !url[%r{//[^/]*:[^/]*@}]
+    end
+
+    def using_basic_auth?
+      !!username
+    end
+
+    def basic_auth_digest
+      Base64.strict_encode64("#{username}:#{password}")
+    end
+
     def request_body_type
       if @method[:options][:request_body_type]
         @method[:options][:request_body_type]
@@ -136,6 +152,30 @@ module Flexirest
       end
     end
 
+    def ignore_root
+      if @method[:options][:ignore_root]
+        @method[:options][:ignore_root]
+      elsif @object.nil?
+        nil
+      elsif object_is_class?
+        @object.ignore_root
+      else
+        @object.class.ignore_root
+      end
+    end
+
+    def wrap_root
+      if @method[:options][:wrap_root]
+        @method[:options][:wrap_root]
+      elsif @object.nil?
+        nil
+      elsif object_is_class?
+        @object.wrap_root
+      else
+        @object.class.wrap_root
+      end
+    end
+
     def verbose?
       if object_is_class?
         @object.verbose
@@ -438,8 +478,8 @@ module Flexirest
           @post_params
         else
           p = (params || @post_params || {})
-          if @method[:options][:wrap_root].present?
-            p = {@method[:options][:wrap_root] => p}
+          if wrap_root.present?
+            p = {wrap_root => p}
           end
           p.to_query
         end
@@ -452,8 +492,8 @@ module Flexirest
           @post_params
         else
           p = (params || @post_params || {})
-          if @method[:options][:wrap_root].present?
-            p = {@method[:options][:wrap_root] => p}
+          if wrap_root.present?
+            p = {wrap_root => p}
           end
           data, mp_headers = Flexirest::Multipart::Post.prepare_query(p)
           mp_headers.each do |k,v|
@@ -467,8 +507,8 @@ module Flexirest
         elsif @post_params.is_a?(String)
           @post_params
         else
-          if @method[:options][:wrap_root].present?
-            {@method[:options][:wrap_root] => (params || @post_params || {})}.to_json
+          if wrap_root.present?
+            {wrap_root => (params || @post_params || {})}.to_json
           else
             (params || @post_params || {}).to_json
           end
@@ -503,7 +543,9 @@ module Flexirest
           else
             _, @base_url, @url = parts
           end
-          base_url.gsub!(%r{//(.)}, "//#{username}:#{password}@\\1") if username && !base_url[%r{//[^/]*:[^/]*@}]
+          if using_basic_auth? && model_class.basic_auth_method == :url
+            inject_basic_auth_in_url(base_url)
+          end
           connection = Flexirest::ConnectionManager.get_connection(base_url)
         end
       else
@@ -516,7 +558,9 @@ module Flexirest
         else
           base_url = parts[0]
         end
-        base_url.gsub!(%r{//(.)}, "//#{username}:#{password}@\\1") if username && !base_url[%r{//[^/]*:[^/]*@}]
+        if using_basic_auth? && model_class.basic_auth_method == :url
+          inject_basic_auth_in_url(base_url)
+        end
         connection = Flexirest::ConnectionManager.get_connection(base_url)
       end
       if @method[:options][:direct]
@@ -542,6 +586,8 @@ module Flexirest
           :api_auth_secret_key => api_auth_secret_key,
           :api_auth_options => api_auth_options
         }
+      elsif using_basic_auth? && model_class.basic_auth_method == :header
+        http_headers["Authorization"] = "Basic #{basic_auth_digest}"
       end
       if @method[:options][:timeout]
         request_options[:timeout] = @method[:options][:timeout]
@@ -601,7 +647,7 @@ module Flexirest
           else
             Flexirest::Logger.debug "  \033[1;4;32m#{Flexirest.name}\033[0m #{@instrumentation_name} - Response received #{@response.body.size} bytes"
           end
-          result = generate_new_object(ignore_root: @method[:options][:ignore_root], ignore_xml_root: @method[:options][:ignore_xml_root])
+          result = generate_new_object(ignore_root: ignore_root, ignore_xml_root: @method[:options][:ignore_xml_root])
           # TODO: Cleanup when ignore_xml_root is removed
         else
           raise ResponseParseException.new(status:status, body:@response.body, headers: @response.headers)
@@ -630,6 +676,16 @@ module Flexirest
           raise HTTPConflictClientException.new(status:status, result:error_response, raw_response: @response.body, url:@url, method: http_method)
         elsif status == 429
           raise HTTPTooManyRequestsClientException.new(status:status, result:error_response, raw_response: @response.body, url:@url, method: http_method)
+        elsif status == 500
+          raise HTTPInternalServerException.new(status:status, result:error_response, raw_response: @response.body, url:@url, method: http_method)
+        elsif status == 501
+          raise HTTPNotImplementedServerException.new(status:status, result:error_response, raw_response: @response.body, url:@url, method: http_method)
+        elsif status == 502
+          raise HTTPBadGatewayServerException.new(status:status, result:error_response, raw_response: @response.body, url:@url, method: http_method)
+        elsif status == 503
+          raise HTTPServiceUnavailableServerException.new(status:status, result:error_response, raw_response: @response.body, url:@url, method: http_method)
+        elsif status == 504
+          raise HTTPGatewayTimeoutServerException.new(status:status, result:error_response, raw_response: @response.body, url:@url, method: http_method)
         elsif (400..499).include? status
           raise HTTPClientException.new(status:status, result:error_response, raw_response: @response.body, url:@url, method: http_method)
         elsif (500..599).include? status
@@ -641,7 +697,7 @@ module Flexirest
       result
     end
 
-    def new_object(attributes, name = nil)
+    def new_object(attributes, name = nil, parent = nil, parent_attribute_name = nil)
       @method[:options][:has_many] ||= {}
       name = name.to_sym rescue nil
       if @method[:options][:has_many][name]
@@ -654,6 +710,9 @@ module Flexirest
         object = create_object_instance
       end
 
+      object._parent = parent
+      object._parent_attribute_name = parent_attribute_name
+
       if hal_response? && name.nil?
         attributes = handle_hal_links_embedded(object, attributes)
       end
@@ -681,9 +740,9 @@ module Flexirest
       v = value
       assignable_hash = value_from_object ? object._attributes : {}
       if value_from_object && @method[:options][:lazy].include?(k)
-        assignable_hash[k] = Flexirest::LazyAssociationLoader.new(overridden_name, v, self, overridden_name:(overridden_name))
+        assignable_hash[k] = Flexirest::LazyAssociationLoader.new(overridden_name, v, self, overridden_name:(overridden_name), parent: object, parent_attribute_name: k)
       elsif v.is_a? Hash
-        assignable_hash[k] = new_object(v, overridden_name )
+        assignable_hash[k] = new_object(v, overridden_name, object, k)
       elsif v.is_a? Array
         if @method[:options][:array].include?(k)
           assignable_hash[k] = Array.new
@@ -801,15 +860,15 @@ module Flexirest
           body = JsonAPIProxy::Response.parse(body, @object)
         end
 
-        if options[:ignore_root]
-          [options[:ignore_root]].flatten.each do |key|
+        if ignore_root
+          [ignore_root].flatten.each do |key|
             body = body[key.to_s]
           end
         end
       elsif is_xml_response?
         body = @response.body.blank? ? {} : Crack::XML.parse(@response.body)
-        if options[:ignore_root]
-          [options[:ignore_root]].flatten.each do |key|
+        if ignore_root
+          [ignore_root].flatten.each do |key|
             body = body[key.to_s]
           end
         elsif options[:ignore_xml_root]
@@ -901,5 +960,9 @@ module Flexirest
   class HTTPNotFoundClientException < HTTPClientException ; end
   class HTTPTooManyRequestsClientException < HTTPClientException ; end
   class HTTPServerException < HTTPException ; end
-
+  class HTTPInternalServerException < HTTPServerException ; end
+  class HTTPNotImplementedServerException < HTTPServerException ; end
+  class HTTPBadGatewayServerException < HTTPServerException ; end
+  class HTTPServiceUnavailableServerException < HTTPServerException ; end
+  class HTTPGatewayTimeoutServerException < HTTPServerException ; end
 end

data/lib/flexirest/result_iterator.rb

@@ -4,6 +4,8 @@ module Flexirest
 
     attr_accessor :_status, :items
     attr_reader :_headers
+    attr_accessor :_parent
+    attr_accessor :_parent_attribute_name
 
     def initialize(response = nil)
       @_status  = response.try :status

data/lib/flexirest/version.rb

@@ -1,3 +1,3 @@
 module Flexirest
-  VERSION = "1.9.18"
+  VERSION = "1.10.4"
 end

data/spec/lib/base_without_validation_spec.rb

@@ -12,6 +12,11 @@ class TranslatorExample
   end
 end
 
+class NestedExample < Flexirest::BaseWithoutValidation
+  get :all, "/all", fake:"{\"person\":{\"name\": \"Billy\"}}"
+end
+
+
 class AlteringClientExample < Flexirest::BaseWithoutValidation
   translator TranslatorExample
   base_url "http://www.example.com"
@@ -140,6 +145,31 @@ describe Flexirest::BaseWithoutValidation do
     expect(client).to be_dirty
   end
 
+  it "should store attribute changes on nested objects and mark them as dirty in the parent" do
+    client = NestedExample.all
+    client.person.name = "John"
+    expect(client.person.name.to_s).to eq("John")
+
+    expect(client).to be_dirty
+    expect(client.changes.keys).to include(:person)
+
+    expect(client.person).to be_dirty
+    expect(client.person.changes.keys).to include(:name)
+  end
+
+  it "should store attribute changes on nested objects loaded via instance methods and mark them as dirty in the parent" do
+    client = NestedExample.new()
+    client.all
+    client.person.name = "John"
+    expect(client.person.name.to_s).to eq("John")
+
+    expect(client).to be_dirty
+    expect(client.changes.keys).to include(:person)
+
+    expect(client.person).to be_dirty
+    expect(client.person.changes.keys).to include(:name)
+  end
+
   it "should track changed attributes and provide access to previous values (similar to ActiveRecord/Mongoid)" do
     client = EmptyExample.new()
     client["test"] = "Something"

data/spec/lib/json_api_spec.rb

@@ -303,7 +303,7 @@ describe 'JSON API' do
   let(:tags) { JsonAPIExample::Tag }
   let(:author) { JsonAPIExample::Author }
 
-  context 'responses' do
+  describe 'responses' do
     it 'should return the data object if the response contains only one data instance' do
       expect(subject.find(1)).to be_an_instance_of(JsonAPIExampleArticle)
     end
@@ -370,17 +370,17 @@ describe 'JSON API' do
     end
   end
 
-  context 'attributes' do
+  describe 'attributes' do
     it 'should return the attributes as part of the data instance' do
-      expect(subject.find(1).item).to_not be_nil
+      expect(subject.find(1).item).to eq("item one")
     end
 
     it 'should return the association\'s attributes as part of the association instance' do
-      expect(subject.includes(:author).find_single_author(1).author.item).to_not be_nil
+      expect(subject.includes(:author).find_single_author(1).author.item).to eq("item two")
     end
   end
 
-  context 'associations' do
+  describe 'associations' do
     it 'should retrieve the resource\'s associations via its relationships object' do
       expect(subject.includes(:tags).find(1).tags.size).to eq(2)
     end
@@ -415,6 +415,40 @@ describe 'JSON API' do
     end
   end
 
+  describe 'requests' do
+    describe 'the `include=` parameter' do
+      before { stub_request(:get, %r{example\.com/articles}) }
+
+      context 'when using `.includes(:tags)`' do
+        it 'equal "tags"' do
+          JsonAPIExample::Article.includes(:tags).real_index
+          expect(WebMock).to have_requested(:get, 'http://www.example.com/articles?include=tags')
+        end
+      end
+
+      context 'when using `.includes(tags: [:authors, :articles])`' do
+        it 'equal "tags.authors,tags.articles"' do
+          JsonAPIExample::Article.includes(tags: [:authors, :articles]).real_index
+          expect(WebMock).to have_requested(:get, 'http://www.example.com/articles?include=tags.authors,tags.articles')
+        end
+      end
+
+      context 'when using both `.includes(:tags)` and other params in the final call' do
+        it 'uses the values passed to the `includes() method`' do
+          JsonAPIExample::Article.includes(:tags).real_index(filter: { author_id: 4 })
+          expect(WebMock).to have_requested(:get, 'http://www.example.com/articles?filter%5Bauthor_id%5D=4&include=tags')
+        end
+      end
+
+      context 'when using both `.includes(:tags)` and the :include param in final call' do
+        it 'uses the values passed to the `includes() method`' do
+          JsonAPIExample::Article.includes(:tags).real_index(include: "author")
+          expect(WebMock).to have_requested(:get, 'http://www.example.com/articles?include=tags')
+        end
+      end
+    end
+  end
+
   context 'lazy loading' do
     it 'should fetch association lazily' do
       stub_request(:get, /www.example.com\/articles\/1\/tags/)
@@ -434,7 +468,7 @@ describe 'JSON API' do
     end
   end
 
-  context 'client' do
+  describe 'client' do
     it 'should request with json api format, and expect a json api response' do
       expect_any_instance_of(Flexirest::Connection).to receive(:post) { |_, _, _, options|
         expect(options[:headers]).to include('Content-Type' => 'application/vnd.api+json')

data/spec/lib/request_spec.rb

@@ -81,6 +81,26 @@ describe Flexirest::Request do
       get :all, "/"
     end
 
+    class AuthenticatedBasicHeaderExampleClient < Flexirest::Base
+      base_url "http://www.example.com"
+      username "john"
+      password "smith"
+      basic_auth_method :header
+      get :all, "/"
+    end
+
+    class AuthenticatedBasicHeaderExampleClientChildClass < AuthenticatedBasicHeaderExampleClient
+      get :child_method, "/"
+    end
+
+    class AuthenticatedBasicUrlExampleClient < Flexirest::Base
+      base_url "http://www.example.com"
+      username "john"
+      password "smith"
+      basic_auth_method :url
+      get :all, "/"
+    end
+
     class AuthenticatedProcExampleClient < Flexirest::Base
       base_url "http://www.example.com"
       username Proc.new { |obj| obj ? "bill-#{obj.id}" : "bill" }
@@ -199,6 +219,89 @@ describe Flexirest::Request do
       }
     end
 
+    class LocalIgnoredRootExampleClient < ExampleClient
+      ignore_root "feed"
+
+      get :root, "/root", fake: %Q{
+        {
+          "feed": {
+            "title": "Example Feed"
+          }
+        }
+      }
+    end
+
+    class LocalIgnoredMultiLevelRootExampleClient < ExampleClient
+      ignore_root [:response, "data", "object"]
+
+      get :multi_level_root, "/multi-level-root", fake: %Q{
+        {
+          "response": {
+            "data": {
+              "object": {
+                "title": "Example Multi Level Feed"
+              }
+            }
+          }
+        }
+      }
+    end
+
+    class BaseIgnoredRootExampleClient < Flexirest::Base
+      base_url "http://www.example.com"
+      ignore_root "feed"
+    end
+
+    class GlobalIgnoredRootExampleClient < BaseIgnoredRootExampleClient
+      get :root, "/root", fake: %Q{
+        {
+          "feed": {
+            "title": "Example Feed"
+          }
+        }
+      }
+    end
+
+    class OverrideGlobalIgnoredRootForFileExampleClient < BaseIgnoredRootExampleClient
+      ignore_root "data"
+
+      get :root, "/root", fake: %Q{
+        {
+          "data": {
+            "title": "Example Feed"
+          }
+        }
+      }
+    end
+
+    class OverrideGlobalIgnoredRootForRequestExampleClient < BaseIgnoredRootExampleClient
+      get :root, "/root", ignore_root: "data", fake: %Q{
+        {
+          "data": {
+            "title": "Example Feed"
+          }
+        }
+      }
+    end
+
+    class BaseWrappedRootExampleClient < Flexirest::Base
+      base_url "http://www.example.com"
+      wrap_root "base_data"
+    end
+
+    class GlobalWrappedRootExampleClient < BaseWrappedRootExampleClient
+      put :wrapped, "/put/:id"
+    end
+
+    class OverrideGlobalWrappedRootForFileExampleClient < BaseWrappedRootExampleClient
+      wrap_root "class_specific_data"
+      put :wrapped, "/put/:id"
+    end
+
+    class OverrideGlobalWrappedRootForRequestExampleClient < BaseWrappedRootExampleClient
+      put :wrapped, "/put/:id", wrap_root: "request_specific_data"
+    end
+
     class WhitelistedDateClient < Flexirest::Base
       base_url "http://www.example.com"
       put :conversion, "/put/:id"
@@ -231,13 +334,53 @@ describe Flexirest::Request do
     expect(servers.uniq.count).to eq(2)
   end
 
-  it "should get an HTTP connection with authentication when called" do
+  it "should use the URL method for Basic HTTP Auth when no basic_auth_method is set" do
+    mocked_response = ::FaradayResponseMock.new(OpenStruct.new(body:'{"result":true}', response_headers:{}))
+
     connection = double(Flexirest::Connection).as_null_object
     expect(Flexirest::ConnectionManager).to receive(:get_connection).with("http://john:smith@www.example.com").and_return(connection)
-    expect(connection).to receive(:get).with("/", an_instance_of(Hash)).and_return(::FaradayResponseMock.new(OpenStruct.new(body:'{"result":true}', response_headers:{})))
+    expect(connection).to receive(:get).with("/", an_instance_of(Hash)).and_return(mocked_response)
     AuthenticatedExampleClient.all
   end
 
+  it "should use the headers method for Basic auth when basic_auth_method is set to :header" do
+    mocked_response = ::FaradayResponseMock.new(OpenStruct.new(body:'{"result":true}', response_headers:{}))
+    headers_including_auth = hash_including({ "Authorization" => "Basic am9objpzbWl0aA==" })
+
+    connection = double(Flexirest::Connection).as_null_object
+    expect(Flexirest::ConnectionManager).to receive(:get_connection).with("http://www.example.com").and_return(connection)
+    expect(connection).to receive(:get).with("/", hash_including(headers: headers_including_auth)).and_return(mocked_response)
+    AuthenticatedBasicHeaderExampleClient.all
+  end
+
+  it "should raise an error if Basic HTTP method is not :header or :url" do
+    expect do
+      AuthenticatedExampleClient.class_eval do
+        basic_auth_method :some_invalid_value
+      end
+    end.to raise_error(RuntimeError, "Invalid basic_auth_method :some_invalid_value. Valid methods are :url (default) and :header.")
+  end
+
+  it "should use the setting set on the parent class" do
+    mocked_response = ::FaradayResponseMock.new(OpenStruct.new(body:'{"result":true}', response_headers:{}))
+    headers_including_auth = hash_including({ "Authorization" => "Basic am9objpzbWl0aA==" })
+
+    connection = double(Flexirest::Connection).as_null_object
+    expect(Flexirest::ConnectionManager).to receive(:get_connection).with("http://www.example.com").and_return(connection)
+    expect(connection).to receive(:get).with("/", hash_including(headers: headers_including_auth)).and_return(mocked_response)
+    AuthenticatedBasicHeaderExampleClientChildClass.child_method
+  end
+
+  it "should use the URL method for Basic auth when basic_auth_method is set to :url (and not include Authorization header)" do
+    mocked_response = ::FaradayResponseMock.new(OpenStruct.new(body:'{"result":true}', response_headers:{}))
+    headers_not_including_auth = hash_excluding("Authorization")
+
+    connection = double(Flexirest::Connection).as_null_object
+    expect(Flexirest::ConnectionManager).to receive(:get_connection).with("http://john:smith@www.example.com").and_return(connection)
+    expect(connection).to receive(:get).with("/", headers: headers_not_including_auth).and_return(mocked_response)
+    AuthenticatedBasicUrlExampleClient.all
+  end
+
   it "should get an HTTP connection with basic authentication using procs when called in a class context" do
     connection = double(Flexirest::Connection).as_null_object
     expect(Flexirest::ConnectionManager).to receive(:get_connection).with("http://bill:jones@www.example.com").and_return(connection)
@@ -1005,7 +1148,7 @@ describe Flexirest::Request do
     rescue Flexirest::HTTPServerException => e
       e
     end
-    expect(e).to be_instance_of(Flexirest::HTTPServerException)
+    expect(e).to be_instance_of(Flexirest::HTTPInternalServerException)
     expect(e.status).to eq(500)
     expect(e.result.first_name).to eq("John")
   end
@@ -1021,7 +1164,7 @@ describe Flexirest::Request do
     rescue Flexirest::HTTPServerException => e
       e
     end
-    expect(e.message).to eq(%q{The POST to '/create' returned a 500 status, which raised a Flexirest::HTTPServerException with a body of: \{"first_name":"John", "id":1234\}})
+    expect(e.message).to eq(%q{The POST to '/create' returned a 500 status, which raised a Flexirest::HTTPInternalServerException with a body of: \{"first_name":"John", "id":1234\}})
   end
 
   it "should raise a parse exception for invalid JSON returns" do
@@ -1036,7 +1179,7 @@ describe Flexirest::Request do
     rescue => e
       e
     end
-    expect(e).to be_instance_of(Flexirest::HTTPServerException)
+    expect(e).to be_instance_of(Flexirest::HTTPInternalServerException)
     expect(e.status).to eq(500)
     expect(e.result).to eq(error_content)
   end
@@ -1355,6 +1498,62 @@ describe Flexirest::Request do
     expect(IgnoredMultiLevelRootExampleClient.multi_level_root.title).to eq("Example Multi Level Feed")
   end
 
+  it "should ignore a specified root element" do
+    expect(LocalIgnoredRootExampleClient.root.title).to eq("Example Feed")
+  end
+
+  it "should ignore a specified multi-level root element" do
+    expect(LocalIgnoredMultiLevelRootExampleClient.multi_level_root.title).to eq("Example Multi Level Feed")
+  end
+
+  it "should ignore a specified root element" do
+    expect(GlobalIgnoredRootExampleClient.root.title).to eq("Example Feed")
+  end
+
+  it "should ignore a specified root element" do
+    expect(OverrideGlobalIgnoredRootForFileExampleClient.root.title).to eq("Example Feed")
+  end
+
+  it "should ignore a specified root element" do
+    expect(OverrideGlobalIgnoredRootForRequestExampleClient.root.title).to eq("Example Feed")
+  end
+
+  it "should wrap elements if specified, in form-encoded format" do
+    expect_any_instance_of(Flexirest::Connection).to receive(:put).with("/put/1234", %q(base_data%5Bdebug%5D=true&base_data%5Btest%5D=foo), an_instance_of(Hash)).and_return(::FaradayResponseMock.new(OpenStruct.new(body:"{\"result\":true}", response_headers:{})))
+    GlobalWrappedRootExampleClient.request_body_type :form_encoded
+    GlobalWrappedRootExampleClient.wrapped id:1234, debug:true, test:'foo'
+  end
+
+  it "should wrap elements if specified, in form-encoded format" do
+    expect_any_instance_of(Flexirest::Connection).to receive(:put).with("/put/1234", %q(class_specific_data%5Bdebug%5D=true&class_specific_data%5Btest%5D=foo), an_instance_of(Hash)).and_return(::FaradayResponseMock.new(OpenStruct.new(body:"{\"result\":true}", response_headers:{})))
+    OverrideGlobalWrappedRootForFileExampleClient.request_body_type :form_encoded
+    OverrideGlobalWrappedRootForFileExampleClient.wrapped id:1234, debug:true, test:'foo'
+  end
+
+  it "should wrap elements if specified, in form-encoded format" do
+    expect_any_instance_of(Flexirest::Connection).to receive(:put).with("/put/1234", %q(request_specific_data%5Bdebug%5D=true&request_specific_data%5Btest%5D=foo), an_instance_of(Hash)).and_return(::FaradayResponseMock.new(OpenStruct.new(body:"{\"result\":true}", response_headers:{})))
+    OverrideGlobalWrappedRootForRequestExampleClient.request_body_type :form_encoded
+    OverrideGlobalWrappedRootForRequestExampleClient.wrapped id:1234, debug:true, test:'foo'
+  end
+
+  it "should encode the body wrapped in a root element in a JSON format if specified" do
+    expect_any_instance_of(Flexirest::Connection).to receive(:put).with("/put/1234", %q({"base_data":{"debug":true,"test":"foo"}}), an_instance_of(Hash)).and_return(::FaradayResponseMock.new(OpenStruct.new(body:"{\"result\":true}", response_headers:{})))
+    GlobalWrappedRootExampleClient.request_body_type :json
+    GlobalWrappedRootExampleClient.wrapped id:1234, debug:true, test:'foo'
+  end
+
+  it "should encode the body wrapped in a root element in a JSON format if specified" do
+    expect_any_instance_of(Flexirest::Connection).to receive(:put).with("/put/1234", %q({"class_specific_data":{"debug":true,"test":"foo"}}), an_instance_of(Hash)).and_return(::FaradayResponseMock.new(OpenStruct.new(body:"{\"result\":true}", response_headers:{})))
+    OverrideGlobalWrappedRootForFileExampleClient.request_body_type :json
+    OverrideGlobalWrappedRootForFileExampleClient.wrapped id:1234, debug:true, test:'foo'
+  end
+
+  it "should encode the body wrapped in a root element in a JSON format if specified" do
+    expect_any_instance_of(Flexirest::Connection).to receive(:put).with("/put/1234", %q({"request_specific_data":{"debug":true,"test":"foo"}}), an_instance_of(Hash)).and_return(::FaradayResponseMock.new(OpenStruct.new(body:"{\"result\":true}", response_headers:{})))
+    OverrideGlobalWrappedRootForRequestExampleClient.request_body_type :json
+    OverrideGlobalWrappedRootForRequestExampleClient.wrapped id:1234, debug:true, test:'foo'
+  end
+
   context "Parameter preparation" do
     method = {url: "http://www.example.com", method: :get}
     object = nil

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: flexirest
 version: !ruby/object:Gem::Version
-  version: 1.9.18
+  version: 1.10.4
 platform: ruby
 authors:
 - Andy Jeffries
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-08-24 00:00:00.000000000 Z
+date: 2021-03-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -176,14 +176,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.8.0
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.8.0
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: mime-types
   requirement: !ruby/object:Gem::Requirement