flexirest 1.2.17 → 1.2.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 74460a02097196ff9ac4e73815ad1be63f1664dd
-  data.tar.gz: 6b138a264aeb07a1012ccfbfbca944f0074f27bf
+  metadata.gz: 951a773aca32f3710bae2ee3ed2f4a34c4ee9232
+  data.tar.gz: d0857284056ec1f1c6b563e1d67f92c8fcae81bd
 SHA512:
-  metadata.gz: cd6868bc4b2de02129bb7078fdd5742a32246ad7275af9d9811dc6f2c2ed005ead6bcc243eff491e6240f05852614dad1899ce529526e21a9c2a6ceb497081cd
-  data.tar.gz: 94548faeb9a21ce22b6227ef3f3ccf100357f090b71a177b393a893e19c37b7c8113a16f148fe5f26e6750ac5020a2b5b13e6e3a67b7416b7e09343c6ea8ac44
+  metadata.gz: 29904f4d2b02428fbb1d056667c3ade2bf42cae9f859e4f328c4cd3ebde47a57160f6c8df00fab0f4967e23cc734bbd26f27e54714b6ebbdb4b46a53986f92fa
+  data.tar.gz: bf945048697c7dc7aa235cc4ef4fffe6a5d6260731d806395f413b797f05e95aa4b1d5f1ab9d1b58f02880bf5c53dd3ca5a14bf4dda1a0673eba34d7c4eac522

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 1.2.18
+
+Features:
+
+- Allow nil option in validators (thanks to Jurgen Jocubeit)
+- Added array feature for returning simple scalar values (thanks to Jurgen Jocubeit)
+
 ## 1.2.17
 
 Bugfixes:

data/README.md

@@ -176,6 +176,34 @@ puts @person.expenses.reduce {|e| e.inc_vat}
 puts @person.address.full_string
 ```
 
+Sometimes we want attributes to just return a simple Ruby Array. To achieve this we can add an `:array` option to the method. This is especially useful when the attribute contains an array of scalar values. If you don't specify the `:array` option Flexirest will return a `Flexirest::ResultIterator`. To illustrate the difference consider the following example:
+
+```ruby
+class Book < Flexirest::Base
+  # :authors attribute ["Robert T. Kiyosaki", "Sharon L. Lechter C.P.A"]
+  # :genres attribute ["self-help", "finance", "education"]
+  get :find, "/books/:name", array: [:authors]
+end
+```
+
+In the example above, the following results can be observed:
+
+```ruby
+@book = Book.find("rich-dad-poor-dad")
+puts @book.authors
+#=> ["Robert T. Kiyosaki", "Sharon L. Lechter C.P.A"]
+puts @book.authors.class
+#=> Array
+puts @book.genres
+#=> #<Flexirest::ResultIterator:0x007ff420fe7a88 @_status=nil, @_headers=nil, @items=["self-help", "finance", "education"]>
+puts @books.genres.class
+#=> Flexirest::ResultIterator
+puts @books.genres.items
+#=> ["self-help", "finance", "education"]
+```
+
+When the `:array` option includes an attribute, it is assumed the values were returned with the request, and they will not be lazily loaded. It is also assumed the attribute values do not map to a Flexirest resource.
+
 #### Association Type 2 - Lazy Loading From Other URLs
 
 When mapping the method, passing a list of attributes will cause any requests for those attributes to mapped to the URLs given in their responses.  The response for the attribute may be one of the following:
@@ -773,6 +801,54 @@ Validations are run when calling `valid?` or when calling any API on an instance
 
 `full_error_messages` returns an array of attributes with their associated error messages, i.e. `["age must be at least 18"]`
 
+#### 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:
+
+```ruby
+class Person < Flexirest::Base
+  validates :first_name, presence: true
+  validates :middle_name, length: { minimum: 2, maximum: 30 }, allow_nil: true
+  validates :last_name, existence: true
+  validates :nick_name, length: { minimum: 2, maximum: 30 }
+  validates :alias, length: { minimum: 2, maximum: 30 }, allow_nil: false
+  validates :password, length: { within: 6..12 }
+  validates :post_code, length: { minimum: 6, maximum: 8 }
+  validates :salary, numericality: true, minimum: 20_000, maximum: 50_000
+  validates :age, numericality: { minimum: 18, maximum: 65 }
+  validates :suffix, inclusion: { in: %w{Dr. Mr. Mrs. Ms.}}
+  validates :golf_score, numericality: true, allow_nil: true
+  validates :retirement_age, numericality: { minimum: 65 }, allow_nil: true
+  validates :cars_owned, numericality: true
+  validates :houses_owned, numericality: true, allow_nil: false
+  validates :favorite_authors, inclusion: { in: ["George S. Klason", "Robert T. Kiyosaki", "Lee Child"] }, allow_nil: true
+  validates :favorite_artists, inclusion: { in: ["Claude Monet", "Vincent Van Gogh", "Andy Warhol"] }
+  validates :favorite_composers, inclusion: { in: ["Mozart", "Bach", "Pachelbel", "Beethoven"] }, allow_nil: false
+end
+```
+
+In the example above, the following results would occur when calling `valid?` on an instance where all attributes have `nil` values:
+
+- `:first_name` must be present
+- `:last_name` must be not be nil
+- `:nick_name` must be not be nil
+- `:alias` must not be nil
+- `:password` must not be nil
+- `:post_code` must not be nil
+- `:salary` must not be nil
+- `:age` must not be nil
+- `:suffix` must not be nil
+- `:cars_owned` must not be nil
+- `:houses_owned` must not be nil
+- `:favorite_artists` must not be nil
+- `:favorite_composers` must not be nil
+
+The following attributes will pass validation since they explicitly `allow_nil`:
+
+- `:middle_name`
+- `:golf_score`
+- `:retirement_age`
+- `:favorite_authors`
+
 ### Debugging
 
 You can turn on verbose debugging to see what is sent to the API server and what is returned in one of these two ways:

data/lib/flexirest/request.rb

@@ -13,8 +13,9 @@ module Flexirest
       @method                     = method
       @method[:options]           ||= {}
       @method[:options][:lazy]    ||= []
+      @method[:options][:array]   ||= []
       @method[:options][:has_one] ||= {}
-      @overridden_name             = @method[:options][:overridden_name]
+      @overridden_name            = @method[:options][:overridden_name]
       @object                     = object
       @response_delegate          = Flexirest::RequestDelegator.new(nil)
       @params                     = params
@@ -440,7 +441,11 @@ module Flexirest
         elsif v.is_a? Hash
           object._attributes[k] = new_object(v, overridden_name )
         elsif v.is_a? Array
-          object._attributes[k] = Flexirest::ResultIterator.new
+          if @method[:options][:array].include?(k)
+            object._attributes[k] = Array.new
+          else
+            object._attributes[k] = Flexirest::ResultIterator.new
+          end
           v.each do |item|
             if item.is_a? Hash
               object._attributes[k] << new_object(item, overridden_name)
@@ -514,7 +519,7 @@ module Flexirest
       if @method[:options][:has_many][name] || @method[:options][:has_one][name]
         return name
       end
-
+      
       parent_name || name
     end
 

data/lib/flexirest/validation.rb

@@ -20,6 +20,7 @@ module Flexirest
       @errors = Hash.new {|h,k| h[k] = []}
       self.class._validations.each do |validation|
         value = self.send(validation[:field_name])
+        allow_nil = validation[:options].fetch(:allow_nil, false)
         validation[:options].each do |type, options|
           if type == :presence
             if value.nil?
@@ -32,35 +33,55 @@ module Flexirest
               @errors[validation[:field_name]] << "must be not be nil"
             end
           elsif type == :length
-            if options[:within]
-              @errors[validation[:field_name]] << "must be within range #{options[:within]}" unless options[:within].include?(value.to_s.length )
-            end
-            if options[:minimum]
-              @errors[validation[:field_name]] << "must be at least #{options[:minimum]} characters long" unless value.to_s.length >= options[:minimum]
-            end
-            if options[:maximum]
-              @errors[validation[:field_name]] << "must be no more than #{options[:maximum]} characters long" unless value.to_s.length <= options[:maximum]
+            if value.nil?
+              @errors[validation[:field_name]] << "must be not be nil" unless allow_nil
+            else
+              if options[:within]
+                @errors[validation[:field_name]] << "must be within range #{options[:within]}" unless options[:within].include?(value.to_s.length )
+              end
+              if options[:minimum]
+                @errors[validation[:field_name]] << "must be at least #{options[:minimum]} characters long" unless value.to_s.length >= options[:minimum]
+              end
+              if options[:maximum]
+                @errors[validation[:field_name]] << "must be no more than #{options[:maximum]} characters long" unless value.to_s.length <= options[:maximum]
+              end
             end
           elsif type == :numericality
-            numeric = (true if Float(value) rescue false)
-            if !numeric
-              @errors[validation[:field_name]] << "must be numeric"
+            if value.nil?
+              @errors[validation[:field_name]] << "must be not be nil" unless allow_nil
             else
-              if options.is_a?(Hash)
-                if options[:minimum]
-                  @errors[validation[:field_name]] << "must be at least #{options[:minimum]}" unless value.to_f >= options[:minimum]
-                end
-                if options[:maximum]
-                  @errors[validation[:field_name]] << "must be no more than #{options[:maximum]}" unless value.to_f <= options[:maximum]
+              numeric = (true if Float(value) rescue false)
+              if !numeric
+                @errors[validation[:field_name]] << "must be numeric"
+              else
+                if options.is_a?(Hash)
+                  if options[:minimum]
+                    @errors[validation[:field_name]] << "must be at least #{options[:minimum]}" unless value.to_f >= options[:minimum]
+                  end
+                  if options[:maximum]
+                    @errors[validation[:field_name]] << "must be no more than #{options[:maximum]}" unless value.to_f <= options[:maximum]
+                  end
                 end
               end
             end
-          elsif type == :minimum && !value.nil?
-            @errors[validation[:field_name]] << "must be at least #{options}" unless value.to_f >= options.to_f
-          elsif type == :maximum && !value.nil?
-            @errors[validation[:field_name]] << "must be no more than #{options}" unless value.to_f <= options.to_f
+          elsif type == :minimum
+            if value.nil?
+              @errors[validation[:field_name]] << "must be not be nil" unless allow_nil
+            else
+              @errors[validation[:field_name]] << "must be at least #{options}" unless value.to_f >= options.to_f
+            end
+          elsif type == :maximum
+            if value.nil?
+              @errors[validation[:field_name]] << "must be not be nil" unless allow_nil
+            else
+              @errors[validation[:field_name]] << "must be no more than #{options}" unless value.to_f <= options.to_f
+            end
           elsif type == :inclusion
-            @errors[validation[:field_name]] << "must be included in #{options[:in].join(", ")}" unless options[:in].include?(value)
+            if value.nil?
+              @errors[validation[:field_name]] << "must be not be nil" unless allow_nil
+            else
+              @errors[validation[:field_name]] << "must be included in #{options[:in].join(", ")}" unless options[:in].include?(value)
+            end
           end
         end
         if validation[:block]

data/lib/flexirest/version.rb

@@ -1,3 +1,3 @@
 module Flexirest
-  VERSION = "1.2.17"
+  VERSION = "1.2.18"
 end

data/spec/lib/request_spec.rb

@@ -22,6 +22,7 @@ describe Flexirest::Request do
       end
 
       get :all, "/", :has_many => {:expenses => ExampleOtherClient}
+      get :array, "/johnny", array: [:likes, :dislikes]
       get :babies, "/babies", :has_many => {:children => ExampleOtherClient}
       get :single_association, "/single", :has_one => {:single => ExampleSingleClient}, :has_many => {:children => ExampleOtherClient}
       get :headers, "/headers"
@@ -261,6 +262,21 @@ describe Flexirest::Request do
     expect(object[1].first_name).to eq("Billy")
     expect(object._status).to eq(200)
   end
+  
+  it "should parse an attribute to be an array if attribute included in array option" do
+    expect_any_instance_of(Flexirest::Connection).to receive(:get).with("/johnny", an_instance_of(Hash)).and_return(::FaradayResponseMock.new(OpenStruct.new(body:"{\"first_name\":\"Johnny\", \"likes\":[\"donuts\", \"bacon\"], \"dislikes\":[\"politicians\", \"lawyers\", \"taxes\"]}", status:200, response_headers:{})))
+    object = ExampleClient.array
+    expect(object.likes).to be_instance_of(Array)
+    expect(object.likes.size).to eq(2)
+    expect(object.likes[0]).to eq("donuts")
+    expect(object.likes[1]).to eq("bacon")
+    expect(object.dislikes).to be_instance_of(Array)
+    expect(object.dislikes.size).to eq(3)
+    expect(object.dislikes[0]).to eq("politicians")
+    expect(object.dislikes[1]).to eq("lawyers")
+    expect(object.dislikes[2]).to eq("taxes")
+    #TODO
+  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:{})))

data/spec/lib/validation_spec.rb

@@ -4,20 +4,29 @@ describe "Flexirest::Validation" do
   class SimpleValidationExample < OpenStruct
     include Flexirest::Validation
     validates :first_name, presence: true
+    validates :middle_name, length: { minimum: 2, maximum: 30 }, allow_nil: true
     validates :last_name, existence: true
+    validates :nick_name, length: { minimum: 2, maximum: 30 }
+    validates :alias, length: { minimum: 2, maximum: 30 }, allow_nil: false
     validates :password, length: { within: 6..12 }
     validates :post_code, length: { minimum: 6, maximum: 8 }
     validates :salary, numericality: true, minimum: 20_000, maximum: 50_000
     validates :age, numericality: { minimum: 18, maximum: 65 }
     validates :suffix, inclusion: { in: %w{Dr. Mr. Mrs. Ms.}}
+    validates :golf_score, numericality: true, allow_nil: true
+    validates :retirement_age, numericality: { minimum: 65 }, allow_nil: true
+    validates :cars_owned, numericality: true
+    validates :houses_owned, numericality: true, allow_nil: false
+    validates :favorite_authors, inclusion: { in: ["George S. Klason", "Robert T. Kiyosaki", "Lee Child"] }, allow_nil: true
+    validates :favorite_artists, inclusion: { in: ["Claude Monet", "Vincent Van Gogh", "Andy Warhol"] }
+    validates :favorite_composers, inclusion: { in: ["Mozart", "Bach", "Pachelbel", "Beethoven"] }, allow_nil: false
   end
 
   it "should be able to register a validation" do
-    expect(SimpleValidationExample._validations.size).to eq(7)
+    expect(SimpleValidationExample._validations.size).to eq(17)
   end
 
   context "when validating presence" do
-
     it "should be invalid if a required value isn't present" do
       a = SimpleValidationExample.new
       a.first_name = nil
@@ -107,6 +116,24 @@ describe "Flexirest::Validation" do
       a.valid?
       expect(a._errors[:post_code].size).to eq(1)
     end
+    
+    it "should be valid if a length is nil and allow_nil option is true" do
+      a = SimpleValidationExample.new
+      a.valid?
+      expect(a._errors[:middle_name]).to be_empty
+    end
+
+    it "should be invalid if a length is nil and allow_nil option is not provided" do
+      a = SimpleValidationExample.new
+      a.valid?
+      expect(a._errors[:nick_name].size).to eq(1)
+    end
+
+    it "should be invalid if a length is nil and allow_nil option is false" do
+      a = SimpleValidationExample.new
+      a.valid?
+      expect(a._errors[:alias].size).to eq(1)
+    end
   end
 
 
@@ -136,6 +163,29 @@ describe "Flexirest::Validation" do
         expect(a._errors[:salary].size).to eq(0)
       end 
 
+      it "should be valid if a value is nil and allow_nil option is true" do
+        a = SimpleValidationExample.new
+        a.valid?
+        expect(a._errors[:golf_score]).to be_empty
+      end
+
+      it "should be valid if a value is nil and allow_nil option is true and a hash of options is passed to numericality" do
+        a = SimpleValidationExample.new
+        a.valid?
+        expect(a._errors[:retirement_age]).to be_empty
+      end
+
+      it "should be invalid if a value is nil and allow_nil option is not provided" do
+        a = SimpleValidationExample.new
+        a.valid?
+        expect(a._errors[:cars_owned].size).to eq(1)
+      end
+
+      it "should be invalid if a value is nil and allow_nil option is false" do
+        a = SimpleValidationExample.new
+        a.valid?
+        expect(a._errors[:houses_owned].size).to eq(1)
+      end
     end
 
     context "using the original format with min and max as types" do
@@ -162,7 +212,6 @@ describe "Flexirest::Validation" do
         a.valid?
         expect(a._errors[:age].size).to eq(0)
       end 
-
     end
   end
 
@@ -178,6 +227,24 @@ describe "Flexirest::Validation" do
       a.valid?
       expect(a._errors[:suffix].size).to eq(0)       
     end
+    
+    it "should be valid if the value is nil and allow_nil option is true" do
+      a = SimpleValidationExample.new
+      a.valid?
+      expect(a._errors[:favorite_authors]).to be_empty
+    end
+
+    it "should be invalid if the value is nil and allow_nil option is not provided" do
+      a = SimpleValidationExample.new
+      a.valid?
+      expect(a._errors[:favorite_artists].size).to eq(1)
+    end
+
+    it "should be invalid if the value is nil and allow_nil option is false" do
+      a = SimpleValidationExample.new
+      a.valid?
+      expect(a._errors[:favorite_composers].size).to eq(1)
+    end
   end
 
   context "when passing a block" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: flexirest
 version: !ruby/object:Gem::Version
-  version: 1.2.17
+  version: 1.2.18
 platform: ruby
 authors:
 - Andy Jeffries
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-05 00:00:00.000000000 Z
+date: 2016-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler