flexirest 1.2.1 → 1.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4da568b8c28266cae1d7a558ac054680514a16f6
-  data.tar.gz: bedf4e0b825d1fb5847b4342bfc2c1fa2b8604e4
+  metadata.gz: f549201f0bdade7d62e8972d7015cdf04f0f2aaa
+  data.tar.gz: b5ed62790c87fd8253bdb1d18bca02dfcbc8331c
 SHA512:
-  metadata.gz: ffc0a1c9d7115f009e1ae929784ce54accd3a904e8d5a040841959ace5d08e21b85c126650f43b09032aa6a365a3ec66d45b45dc50a0685f01f2d9cd07cffa49
-  data.tar.gz: 7414812a6efe50781c389235154a1b6971306cb316c5be20b5c60858946946d860c3487cb79468edb9df7c4e30ed8cee9c01e7489b1798602ec66650887be70a
+  metadata.gz: 4b6d0e9794750161edab543b97aec47a956f3bc570fa65e35c5216ed857fa8ed7830c661ce1fbc0092d0743298c68fc0734db9d38932597a9d3470d5164036a9
+  data.tar.gz: 5297d2f938e3777a5264212465270792dbe7202f758d5c4cfa572ad7e6fa32fc244f66931623933e8bbc0cd7a62ac5202051245c2cd4b10fdfffbdf3216e6140

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 1.2.2
+
+Features:
+
+- Adds `existence`, `numericality`, `presence` and `inclusion` validations (thanks Tom Hoen)
+- Adds `full_error_messages` method (thanks Tom Hoen)
+- Adds `requires` options to the method mapping
+
+## 1.2.1
+
+**Forked Which's ActiveRestClient to be Flexirest**
+
 ## 1.2.0
 
 Features:

data/README.md

@@ -241,8 +241,8 @@ end
 You can then access Ads by specifying their magazine IDs:
 
 ```ruby
-Add.all(magazine_id: 1)
-Add.create(magazine_id: 1, title: "My Add Title")
+Ad.all(magazine_id: 1)
+Ad.create(magazine_id: 1, title: "My Add Title")
 ```
 
 #### Combined Example
@@ -708,6 +708,19 @@ end
 @people = Person.all(active:false)
 ```
 
+### Required Parameters
+
+If you want to specify that certain parameters are required for a specific call, you can specify them like:
+
+```ruby
+class Person < Flexirest::Base
+  get :all, '/people', :requires => [:active]
+end
+
+@people = Person.all # raises Flexirest::MissingParametersException
+@people = Person.all(active:false)
+```
+
 ### 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):
@@ -728,10 +741,13 @@ You can create validations on your objects just like Rails' built in ActiveModel
 
 ```ruby
 class Person < Flexirest::Base
-  validates :first_name, presence:true
-  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 :first_name, presence: true #ensures that the value is present and not blank
+  validates :last_name, existence: true #ensures that the value is non-nil only
+  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: { minumum: 18, maximum: 65 }
+  validates :suffix, inclusion: { in: %w{Dr. Mr. Mrs. Ms.}}
 
   validates :first_name do |object, name, value|
     object.errors[name] << "must be over 4 chars long" if value.length <= 4
@@ -745,6 +761,8 @@ Note the block based validation is responsible for adding errors to `object.erro
 
 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"]`
+
 ### 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

@@ -225,6 +225,20 @@ module Flexirest
         @post_params = default_params.merge(params || {})
         @get_params = {}
       end
+
+      if @method[:options][:requires]
+        requires = @method[:options][:requires].dup
+        merged_params = @get_params.merge(@post_params || {})
+        missing = []
+        requires.each do |key|
+          if merged_params[key.to_sym].blank? && ![true, false].include?(merged_params[key.to_sym])
+            missing << key
+          end
+        end
+        if missing.any?
+          raise Flexirest::MissingParametersException.new("The following parameters weren't specifed: #{missing.join(", ")}")
+        end
+      end
     end
 
     def prepare_url
@@ -547,6 +561,7 @@ module Flexirest
   class RequestException < StandardError ; end
 
   class InvalidRequestException < RequestException ; end
+  class MissingParametersException < RequestException ; end
   class ResponseParseException < RequestException
     attr_accessor :status, :body
     def initialize(options)

data/lib/flexirest/validation.rb

@@ -24,7 +24,13 @@ module Flexirest
           if type == :presence
             if value.nil?
               @errors[validation[:field_name]] << "must be present"
+            elsif value.blank?
+              @errors[validation[:field_name]] << "must be present"
             end
+          elsif type == :existence
+            if value.nil?
+              @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 )
@@ -37,11 +43,24 @@ module Flexirest
             end
           elsif type == :numericality
             numeric = (true if Float(value) rescue false)
-            @errors[validation[:field_name]] << "must be numeric" unless numeric
+            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[:minimum]}" unless value.to_f <= options[:maximum]
+                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 == :inclusion
+            @errors[validation[:field_name]] << "must be included in #{options[:in].join(", ")}" unless options[:in].include?(value)
           end
         end
         if validation[:block]
@@ -51,6 +70,13 @@ module Flexirest
       @errors.empty?
     end
 
+    def full_error_messages
+      return "" unless _errors.present?
+      _errors.reduce([]) do |memo, (field, errors)|
+        memo << "#{field.to_s} #{errors.join(' and ')}"
+      end      
+    end
+
     def _errors
       @errors ||= Hash.new {|h,k| h[k] = []}
       @errors

data/lib/flexirest/version.rb

@@ -1,3 +1,3 @@
 module Flexirest
-  VERSION = "1.2.1"
+  VERSION = "1.2.2"
 end

data/spec/lib/request_spec.rb

@@ -37,6 +37,7 @@ describe Flexirest::Request do
       get :fake, "/fake", fake:"{\"result\":true, \"list\":[1,2,3,{\"test\":true}], \"child\":{\"grandchild\":{\"test\":true}}}"
       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]
     end
 
     class AuthenticatedExampleClient < Flexirest::Base
@@ -113,6 +114,24 @@ describe Flexirest::Request do
     ExampleClient.defaults overwrite:"yes"
   end
 
+  it "should ensure any required parameters are specified" do
+    expect_any_instance_of(Flexirest::Connection).to_not receive(:get)
+    expect{ExampleClient.requires}.to raise_error(Flexirest::MissingParametersException)
+    expect{ExampleClient.requires name: "John"}.to raise_error(Flexirest::MissingParametersException)
+    expect{ExampleClient.requires age: 21}.to raise_error(Flexirest::MissingParametersException)
+    expect{ExampleClient.requires name: nil, age: nil}.to raise_error(Flexirest::MissingParametersException)
+  end
+
+  it "should makes the request if all required parameters are specified" do
+    expect_any_instance_of(Flexirest::Connection).to receive(:get).and_return(::FaradayResponseMock.new(OpenStruct.new(body:'{"result":true}', response_headers:{})))
+    expect{ExampleClient.requires name: "John", age: 21}.not_to raise_error
+  end
+
+  it "should makes the request if all required parameters are specified, even if boolean" do
+    expect_any_instance_of(Flexirest::Connection).to receive(:get).and_return(::FaradayResponseMock.new(OpenStruct.new(body:'{"result":true}', response_headers:{})))
+    expect{ExampleClient.requires name: true, age: false}.not_to raise_error
+  end
+
   it "should pass through url parameters" do
     expect_any_instance_of(Flexirest::Connection).to receive(:get).with("/1234", an_instance_of(Hash)).and_return(::FaradayResponseMock.new(OpenStruct.new(body:'{"result":true}', response_headers:{})))
     ExampleClient.find id:1234

data/spec/lib/validation_spec.rb

@@ -3,100 +3,216 @@ require 'spec_helper'
 describe "Flexirest::Validation" do
   class SimpleValidationExample < OpenStruct
     include Flexirest::Validation
-    validates :first_name, presence:true
-    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 :first_name, presence: true
+    validates :last_name, existence: true
+    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.}}
   end
 
   it "should be able to register a validation" do
-    expect(SimpleValidationExample._validations.size).to eq(4)
+    expect(SimpleValidationExample._validations.size).to eq(7)
   end
 
-  it "should be invalid if a required value isn't present" do
-    a = SimpleValidationExample.new
-    a.first_name = nil
-    a.valid?
-    expect(a._errors[:first_name].size).to eq(1)
-  end
+  context "when validating presence" do
 
-  it "should be valid if a required value is present" do
-    a = SimpleValidationExample.new
-    a.first_name = "John"
-    a.valid?
-    expect(a._errors[:first_name]).to be_empty
-  end
+    it "should be invalid if a required value isn't present" do
+      a = SimpleValidationExample.new
+      a.first_name = nil
+      a.valid?
+      expect(a._errors[:first_name].size).to eq(1)
+    end
 
-  it "should be invalid if a length within value is outside the range" do
-    a = SimpleValidationExample.new(password:"12345")
-    a.valid?
-    expect(a._errors[:password].size).to eq(1)
-  end
+    it "should be invalid if a required value is present but blank" do
+      a = SimpleValidationExample.new
+      a.first_name = ""
+      a.valid?
+      expect(a._errors[:first_name].size).to eq(1)
+    end
 
-  it "should be valid if a length within value is inside the range" do
-    a = SimpleValidationExample.new(password:"123456")
-    a.valid?
-    expect(a._errors[:password].size).to eq(0)
-  end
+    it "should be invalid if a required value is present but is an empty array" do
+      a = SimpleValidationExample.new
+      a.first_name = []
+      a.valid?
+      expect(a._errors[:first_name].size).to eq(1)
+    end
 
-  it "should be invalid if a length is below the minimum" do
-    a = SimpleValidationExample.new(post_code:"12345")
-    a.valid?
-    expect(a._errors[:post_code].size).to eq(1)
-  end
+    it "should be invalid if a required value is present but is an empty hash" do
+      a = SimpleValidationExample.new
+      a.first_name = {}
+      a.valid?
+      expect(a._errors[:first_name].size).to eq(1)
+    end
 
-  it "should be valid if a length is above or equal to the minimum and below the maximum" do
-    a = SimpleValidationExample.new(post_code:"123456")
-    a.valid?
-    expect(a._errors[:post_code].size).to eq(0)
+    it "should be valid if a required value is present" do
+      a = SimpleValidationExample.new
+      a.first_name = "John"
+      a.valid?
+      expect(a._errors[:first_name]).to be_empty
+    end    
   end
 
-  it "should be invalid if a length is above the maximum" do
-    a = SimpleValidationExample.new(post_code:"123456789")
-    a.valid?
-    expect(a._errors[:post_code].size).to eq(1)
+  context "when validating existence" do
+    it "should be invalid if a required value isn't present" do
+      a = SimpleValidationExample.new
+      a.last_name = nil
+      a.valid?
+      expect(a._errors[:last_name].size).to eq(1)
+    end
+
+    it "should be valid if a required value is present but blank" do
+      a = SimpleValidationExample.new
+      a.last_name = ""
+      a.valid?
+      expect(a._errors[:last_name]).to be_empty
+    end
+
+    it "should be valid if a required value is present" do
+      a = SimpleValidationExample.new
+      a.last_name = "John"
+      a.valid?
+      expect(a._errors[:last_name]).to be_empty
+    end 
   end
 
-  it "should be able to validate that a field is numeric" do
-    a = SimpleValidationExample.new(salary:"Bob")
-    a.valid?
-    expect(a._errors[:salary].size).to be > 0
+  context "when validating length" do
+    it "should be invalid if a length within value is outside the range" do
+      a = SimpleValidationExample.new(password:"12345")
+      a.valid?
+      expect(a._errors[:password].size).to eq(1)
+    end
+
+    it "should be valid if a length within value is inside the range" do
+      a = SimpleValidationExample.new(password:"123456")
+      a.valid?
+      expect(a._errors[:password].size).to eq(0)
+    end
+
+    it "should be invalid if a length is below the minimum" do
+      a = SimpleValidationExample.new(post_code:"12345")
+      a.valid?
+      expect(a._errors[:post_code].size).to eq(1)
+    end
+
+    it "should be valid if a length is above or equal to the minimum and below the maximum" do
+      a = SimpleValidationExample.new(post_code:"123456")
+      a.valid?
+      expect(a._errors[:post_code].size).to eq(0)
+    end
+
+    it "should be invalid if a length is above the maximum" do
+      a = SimpleValidationExample.new(post_code:"123456789")
+      a.valid?
+      expect(a._errors[:post_code].size).to eq(1)
+    end
   end
 
-  it "should be able to validate that a numeric field is above or equal to a minimum" do
-    a = SimpleValidationExample.new(salary:10_000)
-    a.valid?
-    expect(a._errors[:salary].size).to be > 0
+
+  context "when validating numericality" do
+    context "using the original format with min and max as types" do
+      it "should be able to validate that a field is numeric" do
+        a = SimpleValidationExample.new(salary:"Bob")
+        a.valid?
+        expect(a._errors[:salary].size).to be > 0
+      end
+
+      it "should be able to validate that a numeric field is above or equal to a minimum" do
+        a = SimpleValidationExample.new(salary:10_000)
+        a.valid?
+        expect(a._errors[:salary].size).to be > 0
+      end
+
+      it "should be able to validate that a numeric field is above or equal to a minimum" do
+        a = SimpleValidationExample.new(salary:100_000)
+        a.valid?
+        expect(a._errors[:salary].size).to be > 0
+      end      
+
+      it "should be valid that a numeric field is above or equal to a minimum" do
+        a = SimpleValidationExample.new(salary:30_000)
+        a.valid?
+        expect(a._errors[:salary].size).to eq(0)
+      end 
+
+    end
+
+    context "using the original format with min and max as types" do
+      it "should be able to validate that a field is numeric" do
+        a = SimpleValidationExample.new(age:"Bob")
+        a.valid?
+        expect(a._errors[:age].size).to be > 0
+      end
+
+      it "should be able to validate that a numeric field is above or equal to a minimum" do
+        a = SimpleValidationExample.new(age: 17)
+        a.valid?
+        expect(a._errors[:age].size).to be > 0
+      end
+
+      it "should be able to validate that a numeric field is above or equal to a minimum" do
+        a = SimpleValidationExample.new(age: 70)
+        a.valid?
+        expect(a._errors[:age].size).to be > 0
+      end      
+
+      it "should be valid that a numeric field is above or equal to a minimum" do
+        a = SimpleValidationExample.new(age: 30)
+        a.valid?
+        expect(a._errors[:age].size).to eq(0)
+      end 
+
+    end
   end
 
-  it "should be able to validate that a numeric field is above or equal to a minimum" do
-    a = SimpleValidationExample.new(salary:100_000)
-    a.valid?
-    expect(a._errors[:salary].size).to be > 0
+  context "when validating inclusion" do
+    it "should be invalid if the value is not contained in the list" do
+      a = SimpleValidationExample.new(suffix: "Baz")
+      a.valid?
+      expect(a._errors[:suffix].size).to be > 0      
+    end
+
+    it "should be valid if the value is contained in the list" do
+      a = SimpleValidationExample.new(suffix: "Dr.")
+      a.valid?
+      expect(a._errors[:suffix].size).to eq(0)       
+    end
   end
 
-  it "should be invalid when a block adds an error" do
-    class ValidationExample1 < OpenStruct
-      include Flexirest::Validation
-      validates :first_name do |object, name, value|
-        object._errors[name] << "must be over 4 chars long" if value.length <= 4
+  context "when passing a block" do
+    it "should be invalid when a block adds an error" do
+      class ValidationExample1 < OpenStruct
+        include Flexirest::Validation
+        validates :first_name do |object, name, value|
+          object._errors[name] << "must be over 4 chars long" if value.length <= 4
+        end
       end
+      a = ValidationExample1.new(first_name:"John")
+      a.valid?
+      expect(a._errors[:first_name].size).to eq(1)
     end
-    a = ValidationExample1.new(first_name:"John")
-    a.valid?
-    expect(a._errors[:first_name].size).to eq(1)
-  end
 
-  it "should be valid when a block doesn't add an error" do
-    class ValidationExample2 < OpenStruct
-      include Flexirest::Validation
-      validates :first_name do |object, name, value|
-        object._errors[name] << "must be over 4 chars long" if value.length <= 4
+    it "should be valid when a block doesn't add an error" do
+      class ValidationExample2 < OpenStruct
+        include Flexirest::Validation
+        validates :first_name do |object, name, value|
+          object._errors[name] << "must be over 4 chars long" if value.length <= 4
+        end
       end
+      a = ValidationExample2.new(first_name:"Johnny")
+      a.valid?
+      expect(a._errors[:first_name]).to be_empty
+    end    
+  end
+
+  describe "#full_error_messages" do
+    it "should return an array of strings that combines the attribute name and the error message" do
+      a = SimpleValidationExample.new(age:"Bob", suffix: "Baz")
+      a.valid?
+      expect(a.full_error_messages).to include("age must be numeric")
+      expect(a.full_error_messages).to include("suffix must be included in Dr., Mr., Mrs., Ms.")
     end
-    a = ValidationExample2.new(first_name:"Johnny")
-    a.valid?
-    expect(a._errors[:first_name]).to be_empty
   end
 
   it "should call valid? before making a request" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: flexirest
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.2.2
 platform: ruby
 authors:
 - Andy Jeffries
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-22 00:00:00.000000000 Z
+date: 2015-11-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -315,7 +315,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: This gem is for accessing REST services in a flexible way.  ActiveResource
@@ -342,4 +342,3 @@ test_files:
 - spec/lib/validation_spec.rb
 - spec/lib/xml_spec.rb
 - spec/spec_helper.rb
-has_rdoc: