flexirest 1.3.33 → 1.3.34

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1c372f15d7e88d296232e1e055cb598419ca3d2c
-  data.tar.gz: c61b9f302f68cde71be0d091288e10f5b994c342
+  metadata.gz: 0aefbb07885064fa794f6680446e48a678682a6a
+  data.tar.gz: dae31dfd7a9522ac6e5f21b72037b1d4be9ed47c
 SHA512:
-  metadata.gz: '007239649da6105e553e6779858fc70951ff66825262300636254c34a749598839ad64c63bb145357b09bd07f85897b731d59b16c7a4354efd67d6f738fce30f'
-  data.tar.gz: fa9cbd5356984fc31ae87634833893cbc02b3586ad185324c85fe6458cedf6663e9303b93e437ffdecb09f09b5c88818e4570fd72508d402ba4da3807d74ac76
+  metadata.gz: 39aa00c5bc3ff7bce1ef08cfa646bf371dbeff2f13464c750cf462d2ee93cedbe90be9c4b3fa77788240c7a186568de55df382a7c287287fcd044dcc2dbfd49a
+  data.tar.gz: 56f5bdabdfb819ea43a2ea209700d330d05548e174ef3343c5e7cc15a00b69fd6b0ba6c705502263609d03481b72812204632f141bd6f1a90a72ac120fdc2cf4

data/.travis.yml

@@ -1,5 +1,6 @@
 language: ruby
 rvm:
+  - 2.4.0
   - 2.3.0
   - 2.2.2
   - 2.2.0

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 1.3.34
+
+Feature:
+
+- Added ActiveRecord/Mongoid style dirty/changed tracking methods (thanks to eshork for the PR)
+
+Bugfix:
+
+- Now can disable caching on subclasses after being enabled on a parent (thanks to yujideveloper for the PR)
+
 ## 1.3.33
 
 Feature:

data/README.md

@@ -44,6 +44,7 @@ If you are a previous user of ActiveRestClient, there's some more information on
 	- [Default Parameters](#default-parameters)
 	- [Root element removal](#root-element-removal)
 	- [Required Parameters](#required-parameters)
+	- [Updating Only Changed/Dirty](#updating-only-changed-dirty)
 	- [HTTP/Parse Error Handling](#httpparse-error-handling)
 	- [Validation](#validation)
 		- [Permitting nil values](#permitting-nil-values)
@@ -937,6 +938,38 @@ end
 @people = Person.all(active:false)
 ```
 
+### Updating Only Changed/Dirty
+
+The most common RESTful usage of the PATCH http-method is to only send fields that have changed. The default action for all calls is to send all known object attributes for POST/PUT/PATCH calls, but this can be altered by setting the `only_changed` option on your call declaration.
+
+```ruby
+class Person < Flexirest::Base
+  get :all, '/people'
+  patch :update, '/people/:id', :only_changed => true # only send attributes that are changed/dirty
+end
+
+person = Person.all.first
+person.first_name = 'Billy'
+person.update # performs a PATCH request, sending only the now changed 'first_name' attribute
+```
+
+This functionality is per-call, and there is some additional flexibility to control which attributes are sent and when.
+
+```ruby
+class Person < Flexirest::Base
+  get :all, '/people'
+  patch :update_1, '/people/:id', :only_changed => true # only send attributes that are changed/dirty (all known attributes on this object are subject to evaluation)
+  patch :update_2, "/people/:id", :only_changed => [:first_name, :last_name, :dob] # only send these listed attributes, and only if they are changed/dirty
+  patch :update_3, "/people/:id", :only_changed => {first_name: true, last_name: true, dob: false} # include the listed attributes marked 'true' only when changed; attributes marked 'false' are always included (changed or not, and if not present will be sent as nil); unspecified attributes are never sent
+end
+```
+
+#### Additional Notes:
+
+* The above examples specifically showed PATCH methods, but this is also available for POST and PUT methods for flexibility purposes (even though they break typical REST methodology).
+* This logic is currently evaluated before Required Parameters, so it is possible to ensure that requirements are met by some clever usage.
+ - This means that if a method is `:requires => [:active], :only_changed => {active: false}` then `active` will always have a value and would always pass the `:requires` directive (so you need to be very careful because the answer may end up being `nil` if you didn't specifically set it).
+
 ### HTTP/Parse Error Handling
 
 Sometimes the backend server may respond with a non-200/304 header, in which case the code will raise an `Flexirest::HTTPClientException` for 4xx errors or an `Flexirest::HTTPServerException` for 5xx errors.  These both have a `status` accessor and a `result` accessor (for getting access to the parsed body):
@@ -977,7 +1010,15 @@ Note: the block based validation is responsible for adding errors to `object._er
 
 Validations are run when calling `valid?` or when calling any API on an instance (and then only if it is `valid?` will the API go on to be called).
 
-`full_error_messages` returns an array of attributes with their associated error messages, i.e. `["age must be at least 18"]`. Custom messages can be specified by passing a `:message` option to `validates`. This differs slightly from ActiveRecord in that it's an option to `validates` itself, not a part of a final hash.
+`full_error_messages` returns an array of attributes with their associated error messages, i.e. `["age must be at least 18"]`. Custom messages can be specified by passing a `:message` option to `validates`. This differs slightly from ActiveRecord in that it's an option to `validates` itself, not a part of a final hash of other options. This is because the author doesn't like the ActiveRecord format (but will accept pull requests that make both syntaxes valid). To make this clearer, an example may help:
+
+```ruby
+# ActiveRecord
+validates :name, presence: { message: "must be given please" }
+
+# Flexirest
+validates :name, :presence, message: "must be given please"
+```
 
 #### Permitting nil values
 The default behavior for `:length`, `:numericality` and `:inclusion` validators is to fail when a `nil` value is encountered. You can prevent `nil` attribute values from triggering validation errors for attributes that may permit `nil` by adding the `:allow_nil => true` option. Adding this option with a `true` value to `:length`, `:numericality` and `:inclusion` validators will permit `nil` values and not trigger errors. Some examples are:

data/flexirest.gemspec

@@ -22,7 +22,11 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec", "~> 3"
-  spec.add_development_dependency "webmock"
+  if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.1.0')
+    spec.add_development_dependency "webmock", "~> 2.1.0"
+  else
+    spec.add_development_dependency "webmock"
+  end
   spec.add_development_dependency "rspec_junit_formatter"
   spec.add_development_dependency "simplecov"
   spec.add_development_dependency "simplecov-rcov"

data/lib/flexirest/base.rb

@@ -20,19 +20,19 @@ module Flexirest
 
     def initialize(attrs={})
       @attributes = {}
-      @dirty_attributes = Set.new
+      @dirty_attributes = Hash.new
 
       raise Exception.new("Cannot instantiate Base class") if self.class.name == "Flexirest::Base"
 
       attrs.each do |attribute_name, attribute_value|
         attribute_name = attribute_name.to_sym
         @attributes[attribute_name] = parse_date?(attribute_name) ? parse_attribute_value(attribute_value) : attribute_value
-        @dirty_attributes << attribute_name
+        @dirty_attributes[attribute_name] = [nil, attribute_value]
       end
     end
 
     def _clean!
-      @dirty_attributes = Set.new
+      @dirty_attributes = Hash.new
     end
 
     def _attributes
@@ -48,6 +48,20 @@ module Flexirest
       @dirty_attributes.size > 0
     end
 
+    def changed?
+      dirty?
+    end
+
+    # Returns an array of changed fields
+    def changed
+      @dirty_attributes.keys
+    end
+
+    # Returns hash of old and new vaules for each changed field
+    def changes
+      @dirty_attributes
+    end
+
     def errors
       @attributes[:errors] || (_errors != {} ? _errors : nil)
     end
@@ -87,8 +101,7 @@ module Flexirest
     end
 
     def []=(key, value)
-      @attributes[key.to_sym] = value
-      @dirty_attributes << key
+      _set_attribute(key, value)
     end
 
     def each
@@ -107,15 +120,14 @@ module Flexirest
                    end
       inspection += "#{"," if @attributes.any?} ETag: #{@_etag}" unless @_etag.nil?
       inspection += "#{"," if @attributes.any?} Status: #{@_status}" unless @_status.nil?
-      inspection += " (unsaved: #{@dirty_attributes.map(&:to_s).join(", ")})" if @dirty_attributes.any?
+      inspection += " (unsaved: #{@dirty_attributes.keys.map(&:to_s).join(", ")})" if @dirty_attributes.any?
       "#<#{self.class} #{inspection}>"
     end
 
     def method_missing(name, *args)
       if name.to_s[-1,1] == "="
         name = name.to_s.chop.to_sym
-        @attributes[name] = args.first
-        @dirty_attributes << name
+        _set_attribute(name, args.first)
       else
         name_sym = name.to_sym
         name = name.to_s
@@ -124,13 +136,25 @@ module Flexirest
           @attributes[name_sym]
         else
           if name[/^lazy_/] && mapped = self.class._mapped_method(name_sym)
-            raise ValidationFailedException.new unless valid?
+            if mapped[:method] != :delete
+              raise ValidationFailedException.new unless valid?
+            end
+
             request = Request.new(mapped, self, args.first)
             Flexirest::LazyLoader.new(request)
           elsif mapped = self.class._mapped_method(name_sym)
-            raise ValidationFailedException.new unless valid?
+            if mapped[:method] != :delete
+              raise ValidationFailedException.new unless valid?
+            end
+
             request = Request.new(mapped, self, args.first)
             request.call
+          elsif name[/_was$/] and @attributes.has_key? (name.sub(/_was$/,'').to_sym)
+            k = (name.sub(/_was$/,'').to_sym)
+            @dirty_attributes[k][0]
+          elsif name[/^reset_.*!$/] and @attributes.has_key? (name.sub(/^reset_/,'').sub(/!$/,'').to_sym)
+            k = (name.sub(/^reset_/,'').sub(/!$/,'').to_sym)
+            _reset_attribute(k)
           elsif self.class.whiny_missing
             raise NoAttributeException.new("Missing attribute #{name_sym}")
           else
@@ -165,6 +189,20 @@ module Flexirest
 
     private
 
+    def _set_attribute(key, value)
+      old_value = @dirty_attributes[key.to_sym]
+      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]
+      @attributes[key.to_sym] = value
+    end
+
+    def _reset_attribute(key)
+      old_value = @dirty_attributes[key.to_sym]
+      @attributes[key.to_sym] = old_value[0] if old_value and old_value.is_a? Array
+      @dirty_attributes.delete(key.to_sym)
+    end
+
     def value_for_inspect(value)
       if value.is_a?(String) && value.length > 50
         "#{value[0..50]}...".inspect

data/lib/flexirest/caching.rb

@@ -4,7 +4,7 @@ module Flexirest
       @@perform_caching = true
 
       def perform_caching(value = nil)
-        @perform_caching ||= nil
+        @perform_caching = nil unless instance_variable_defined?(:@perform_caching)
         if value.nil?
           value = if @perform_caching.nil?
             @@perform_caching

data/lib/flexirest/connection.rb

@@ -2,8 +2,9 @@ require 'faraday'
 
 module Flexirest
 
-  class TimeoutException < StandardError ; end
-  class ConnectionFailedException < StandardError ; end
+  class BaseException < StandardError ; end
+  class TimeoutException < BaseException ; end
+  class ConnectionFailedException < BaseException ; end
 
   class Connection
     attr_accessor :session, :base_url
@@ -25,11 +26,17 @@ module Flexirest
       block.call
     rescue Faraday::Error::TimeoutError
       raise Flexirest::TimeoutException.new("Timed out getting #{full_url(path)}")
-    rescue Faraday::Error::ConnectionFailed
+    rescue Faraday::Error::ConnectionFailed => e1
+      if e1.respond_to?(:cause) && e1.cause.is_a?(Net::OpenTimeout)
+        raise Flexirest::TimeoutException.new("Timed out getting #{full_url(path)}")
+      end
       begin
         reconnect
         block.call
-      rescue Faraday::Error::ConnectionFailed
+      rescue Faraday::Error::ConnectionFailed => e2
+        if e2.respond_to?(:cause) && e2.cause.is_a?(Net::OpenTimeout)
+          raise Flexirest::TimeoutException.new("Timed out getting #{full_url(path)}")
+        end
         raise Flexirest::ConnectionFailedException.new("Unable to connect to #{full_url(path)}")
       end
     end

data/lib/flexirest/request.rb

@@ -224,7 +224,7 @@ module Flexirest
 
     def prepare_params
       params = @params || @object._attributes rescue {}
-      if params.is_a?(String) || params.is_a?(Fixnum)
+      if params.is_a?(String) || params.is_a?(Integer)
         params = {id:params}
       end
 
@@ -245,6 +245,39 @@ module Flexirest
         @get_params = {}
       end
 
+      # Evaluate :only_changed
+      if @method[:options][:only_changed]
+        if http_method == :post or http_method == :put or http_method == :patch
+          # we only ever mess with @post_params in here, because @get_params will/should never match our method criteria
+          if @method[:options][:only_changed].is_a? Hash
+            # only include the listed attributes marked 'true' when they are changed; attributed marked false are always included
+            newPostHash = {}
+            @method[:options][:only_changed].each_pair do |changed_attr_k,changed_attr_v|
+              if changed_attr_v == false or @object.changes.has_key? changed_attr_k.to_sym
+                newPostHash[changed_attr_k.to_sym] = @object[changed_attr_k.to_sym]
+              end
+            end
+            @post_params = newPostHash
+          elsif @method[:options][:only_changed].is_a? Array
+            # only send these listed attributes, and only if they are changed
+            newPostHash = {}
+            @method[:options][:only_changed].each do |changed_attr|
+              if @object.changes.has_key? changed_attr.to_sym
+                newPostHash[changed_attr.to_sym] = @object[changed_attr.to_sym]
+              end
+            end
+            @post_params = newPostHash
+          else
+            # only send attributes if they are changed, drop the rest
+            newPostHash = {}
+            @object.changed.each do |k|
+              newPostHash[k] = @object[k]
+            end
+            @post_params = newPostHash
+          end
+        end
+      end
+
       if @method[:options][:requires]
         requires = @method[:options][:requires].dup
         merged_params = @get_params.merge(@post_params || {})
@@ -270,7 +303,10 @@ module Flexirest
         @post_params ||= {}
         matches.each do |token|
           token = token.first[1,999]
+          # pull URL path variables out of @get_params/@post_params
           target = @get_params.delete(token.to_sym) || @post_params.delete(token.to_sym) || @get_params.delete(token.to_s) || @post_params.delete(token.to_s) || ""
+          # it's possible the URL path variable may not be part of the request, in that case, try to resolve it from the object attributes
+          target = @object._attributes[token.to_sym] || "" if target == ""
           @url.gsub!(":#{token}", URI.escape(target.to_s))
         end
       end

data/lib/flexirest/version.rb

@@ -1,3 +1,3 @@
 module Flexirest
-  VERSION = "1.3.33"
+  VERSION = "1.3.34"
 end

data/spec/lib/base_spec.rb

@@ -133,6 +133,35 @@ describe Flexirest::Base do
     expect(client).to be_dirty
   end
 
+  it "should track changed attributes and provide access to previous values (similar to ActiveRecord/Mongoid)" do
+    client = EmptyExample.new()
+    client["test"] = "Something"
+
+    client._clean! # force a clean state so we can proceed with tests
+
+    expect(client).to_not be_dirty # clean state should have set in (dirty?)
+    expect(client).to_not be_changed # clean state should have set in (changed?)
+    expect(client["test"].to_s).to eq("Something") # verify attribute value persists
+
+    client["test"] = "SomethingElse" # change the attribute value
+    expect(client["test"].to_s).to eq("SomethingElse") # most current set value should be returned
+    expect(client).to be_dirty # an attribute was changed, so the entire object is dirty
+    expect(client).to be_changed # an attribute was changed, so the entire object is changed
+    expect(client.changed).to be_a(Array) # the list of changed attributes should be an Array
+    expect(client.changed).to eq([:test]) # the list of changed attributes should provide the name of the changed attribute
+    expect(client.changes).to be_a(Hash) # changes are returned as a hash
+    expect(client.changes).to eq({test: ["Something", "SomethingElse"]}) # changes include [saved,unsaved] values, keyed by attribute name
+    expect(client.test_was).to eq("Something") # dynamic *_was notation provides original value
+
+    client["test"] = "SomethingElseAgain" # change the attribute value again
+    expect(client.test_was).to eq("Something") # dynamic *_was notation provides original value (from most recent save/load, not most recent change)
+    expect(client.changes).to eq({test: ["Something", "SomethingElseAgain"]}) # changes include [saved,unsaved] values, keyed by attribute name
+
+    # resets the test attribute back to the original value
+    expect( client.reset_test! ).to eq(["Something", "SomethingElseAgain"]) # reseting an attribute returns the previous pending changeset
+    expect(client).to_not be_dirty # reseting an attribute should makeit not dirty again
+  end
+
   it "should overwrite attributes already set and mark them as dirty" do
     client = EmptyExample.new(:hello => "World")
     client._clean!
@@ -177,10 +206,10 @@ describe Flexirest::Base do
     expect(client).to_not be_dirty
   end
 
-  it "should not overly pollute the instance method namespace to reduce chances of clashing (<10 instance methods)" do
+  it "should not overly pollute the instance method namespace to reduce chances of clashing (<13 instance methods)" do
     instance_methods = EmptyExample.instance_methods - Object.methods
     instance_methods = instance_methods - instance_methods.grep(/^_/)
-    expect(instance_methods.size).to be < 10
+    expect(instance_methods.size).to be < 13
   end
 
   it "should raise an exception for missing attributes if whiny_missing is enabled" do

data/spec/lib/caching_spec.rb

@@ -35,6 +35,20 @@ describe Flexirest::Caching do
       Flexirest::Base._reset_caching!
     end
 
+    it "should be possible to disable caching for each objects" do
+      Flexirest::Base.perform_caching = true
+
+      class CachingExample4 < Flexirest::Base; end
+      class CachingExample5 < Flexirest::Base
+        perform_caching false
+      end
+      expect(Flexirest::Base.perform_caching).to be_truthy
+      expect(CachingExample4.perform_caching).to be_truthy
+      expect(CachingExample5.perform_caching).to be_falsey
+
+      Flexirest::Base._reset_caching!
+    end
+
     it "should use Rails.cache if available" do
       begin
         class Rails

data/spec/lib/connection_spec.rb

@@ -187,12 +187,12 @@ describe Flexirest::Connection do
 
   it "should retry once in the event of a connection failed" do
     stub_request(:get, "www.example.com/foo").to_raise(Faraday::Error::ConnectionFailed.new("Foo"))
-    expect { @connection.get("/foo") }.to raise_error(Flexirest::ConnectionFailedException)
+    expect { @connection.get("/foo") }.to raise_error(Flexirest::BaseException)
   end
 
   it "should raise an exception on timeout" do
     stub_request(:get, "www.example.com/foo").to_timeout
-    expect { @connection.get("/foo") }.to raise_error(Flexirest::TimeoutException)
+    expect { @connection.get("/foo") }.to raise_error(Flexirest::BaseException)
   end
 
   it "should raise an exception on timeout" do

data/spec/lib/request_spec.rb

@@ -42,6 +42,9 @@ describe Flexirest::Request do
       get :fake_proc, "/fake", fake:->(request) { "{\"result\":#{request.get_params[:id]}}" }
       get :defaults, "/defaults", defaults:{overwrite:"no", persist:"yes"}
       get :requires, "/requires", requires:[:name, :age]
+      patch :only_changed_1, "/changed1", only_changed: true
+      patch :only_changed_2, "/changed2", only_changed: [:debug1, :debug2]
+      patch :only_changed_3, "/changed3", only_changed: { :debug1 => false, :debug2 => true }
     end
 
     class ExampleLoadBalancedClient < Flexirest::Base
@@ -390,6 +393,46 @@ describe Flexirest::Request do
     #TODO
   end
 
+  it "should only send changed attributes if only_changed:true" do
+    expect_any_instance_of(Flexirest::Connection).to receive(:patch).with("/changed1", "debug=true", an_instance_of(Hash)).and_return(::FaradayResponseMock.new(OpenStruct.new(body:"[{\"first_name\":\"Johnny\"}, {\"first_name\":\"Billy\"}, {\"debug\":\"true\"}]", status:200, response_headers:{})))
+    object = ExampleClient.new
+    object.bad_debug = true
+    object._clean!
+    object.debug = true
+    object.only_changed_1
+  end
+  it "should only send changed attributes within the :only_changed array if :only_changed is an array" do
+    expect_any_instance_of(Flexirest::Connection).to receive(:patch).with("/changed2", "debug2=true", an_instance_of(Hash)).and_return(::FaradayResponseMock.new(OpenStruct.new(body:"[{\"first_name\":\"Johnny\"}, {\"first_name\":\"Billy\"}, {\"debug\":\"true\"}]", status:200, response_headers:{})))
+    object = ExampleClient.new
+    object.bad_debug1 = true
+    object.debug1 = true
+    object._clean!
+    object.bad_debug2 = true
+    object.debug2 = true
+    object.only_changed_2
+  end
+  it "should only send changed attributes marked true within the :only_changed hash when :only_changed is a hash" do
+    expect_any_instance_of(Flexirest::Connection).to receive(:patch).with("/changed3", "debug1=false&debug2=true", an_instance_of(Hash)).and_return(::FaradayResponseMock.new(OpenStruct.new(body:"[{\"first_name\":\"Johnny\"}, {\"first_name\":\"Billy\"}, {\"debug\":\"true\"}]", status:200, response_headers:{})))
+    object = ExampleClient.new
+    object.bad_debug1 = true
+    object.debug1 = true
+    object._clean!
+    object.bad_debug2 = true
+    object.debug1 = false
+    object.debug2 = true
+    object.only_changed_3
+  end
+  it "should always send changed attributes marked false within the :only_changed hash when :only_changed is an hash" do
+    expect_any_instance_of(Flexirest::Connection).to receive(:patch).with("/changed3", "debug1=true", an_instance_of(Hash)).and_return(::FaradayResponseMock.new(OpenStruct.new(body:"[{\"first_name\":\"Johnny\"}, {\"first_name\":\"Billy\"}, {\"debug\":\"true\"}]", status:200, response_headers:{})))
+    object = ExampleClient.new
+    object.bad_debug1 = true
+    object.debug1 = true
+    object._clean!
+    object.bad_debug2 = true
+    object.only_changed_3
+  end
+
+
   it "should instantiate other classes using has_many when required to do so" do
     expect_any_instance_of(Flexirest::Connection).to receive(:get).with("/", an_instance_of(Hash)).and_return(::FaradayResponseMock.new(OpenStruct.new(body:"{\"first_name\":\"Johnny\", \"expenses\":[{\"amount\":1}, {\"amount\":2}]}", status:200, response_headers:{})))
     object = ExampleClient.all
@@ -890,4 +933,41 @@ describe Flexirest::Request do
   it "should ignore a specified root element" do
     expect(IgnoredRootExampleClient.root.title).to eq("Example Feed")
   end
+
+  context "Parameter preparation" do
+    method = {url: "http://www.example.com", method: :get}
+    object = nil
+
+    it "should properly handle Hash params" do
+      req = Flexirest::Request.new method, object, {hello: {}}
+      req.prepare_params
+
+      expect(req.get_params.is_a?(Hash)).to be_truthy
+      expect(req.get_params[:hello]).to eq({})
+    end
+
+    it "should properly handle String params" do
+      req = Flexirest::Request.new method, object, String.new
+      req.prepare_params
+
+      expect(req.get_params.is_a?(Hash)).to be_truthy
+      expect(req.get_params[:id].is_a?(String)).to be_truthy
+    end
+
+    it "should properly handle Integer (Fixnum) params" do
+      req = Flexirest::Request.new method, object, 1234
+      req.prepare_params
+
+      expect(req.get_params.is_a?(Hash)).to be_truthy
+      expect(req.get_params[:id].is_a?(Integer)).to be_truthy
+    end
+
+    it "should properly handle Integer (Bignum) params" do
+      req = Flexirest::Request.new method, object, 12345678901234567890
+      req.prepare_params
+
+      expect(req.get_params.is_a?(Hash)).to be_truthy
+      expect(req.get_params[:id].is_a?(Integer)).to be_truthy
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: flexirest
 version: !ruby/object:Gem::Version
-  version: 1.3.33
+  version: 1.3.34
 platform: ruby
 authors:
 - Andy Jeffries
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-21 00:00:00.000000000 Z
+date: 2017-04-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler