schema_validations 2.2.0 → 2.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f722b7a85eff3f3def8a6355153476f9801da846
-  data.tar.gz: 1e6eb1107162cd7eb637473d59ebd1d4de2ec33e
+  metadata.gz: 4d32813f578be832c807834e301af6646a5de2e8
+  data.tar.gz: 8f6d05bc4a8ee9230d2db146823ffa87ac2b16a1
 SHA512:
-  metadata.gz: b5dfa087e36e5a81ac6f3e38fa6912db50e43785bb0d6c46959d1c48dc1a208cf6108d5eabab8c255a159ca65ed5de5994f6519f039dcca155e3548ad7963534
-  data.tar.gz: 102c7dda2cc81cb0c0dbbc0e5518ee6c14368b365ce34c0181c69405b7521964b764a978b2e3ca598446894d3ee54a01bd8cbfaff3e420a6974c2351db12733a
+  metadata.gz: e41b110b12a186b3cacce1280ae74279e83b8b8be5296cdcedd43fe27fa258609ce79226b6b8c9cf0b034ac78633c319d696a76c6cc67d119119defb396edabd
+  data.tar.gz: ae10f5ffc2434e9e0f4470225fed144f37bc217864f487c8b391df20836d43f42029136a75213b4117623199ec967a97f8f97f87bb804038885becdb2f090e22

data/README.md

@@ -187,6 +187,11 @@ Earlier versions of SchemaValidations supported:
 
 ## Release Notes
 
+### 2.2.1
+
+* Bug fix: don't create presence validation for `null: false` with a
+  default defined (#18, #49)
+
 ### 2.2.0
 
 * Works with AR 5.0.  Thanks to [@plicjo](https://github.coms/plicjo).

data/gemfiles/activerecord-5.0/Gemfile.base

@@ -1,3 +1,3 @@
 eval File.read File.expand_path('../../Gemfile.base', __FILE__)
 
-gem "activerecord", "~> 5.0.0"
+gem "activerecord", "~> 5.0.1"

data/lib/schema_validations.rb

@@ -2,6 +2,7 @@ require 'valuable'
 
 require 'schema_plus_columns'
 require 'schema_validations/version'
+require 'schema_validations/validators/not_nil_validator'
 require 'schema_validations/active_record/validations'
 require 'schema_validations/active_record/type'
 

data/lib/schema_validations/active_record/validations.rb

@@ -123,7 +123,12 @@ module SchemaValidations
               if datatype == :boolean
                 validate_logged :validates_inclusion_of, name, :in => [true, false], :message => :blank
               else
-                validate_logged :validates_presence_of, name
+                if !column.default.nil? && column.default.blank?
+                  validate_logged :validates_with, SchemaValidations::Validators::NotNilValidator, attributes: [name]
+                else
+                  # Validate presence
+                  validate_logged :validates_presence_of, name
+                end
               end
             end
 

data/lib/schema_validations/validators/not_nil_validator.rb

@@ -0,0 +1,11 @@
+module SchemaValidations
+  module Validators
+    # Validates that the field is not nil?
+    # (Unlike the standard PresenceValidator which uses #blank?)
+    class NotNilValidator < ActiveModel::EachValidator
+      def validate_each(record, attr_name, value)
+        record.errors.add(attr_name, :blank, options) if value.nil?
+      end
+    end
+  end
+end

data/lib/schema_validations/version.rb

@@ -1,3 +1,3 @@
 module SchemaValidations
-  VERSION = "2.2.0"
+  VERSION = "2.2.1"
 end

data/spec/validations_spec.rb

@@ -5,34 +5,34 @@ describe "Validations" do
   before(:each) do
     ActiveRecord::Schema.define do
 
-      create_table :articles, :force => true do |t|
-        t.string :title, :limit => 50
-        t.text  :content, :null => false
+      create_table :articles, force: true do |t|
+        t.string :title, limit: 50
+        t.text  :content, null: false
         t.integer :state
         t.integer :votes
-        t.float   :average_mark, :null => false
-        t.boolean :active, :null => false
-        t.decimal :max10, :precision => 2, :scale => 1
-        t.decimal :arbitrary, :precision => nil, :scale => nil
-        t.decimal :max100, :precision => 2, :scale => nil
+        t.float   :average_mark, null: false
+        t.boolean :active, null: false
+        t.decimal :max10, precision: 2, scale: 1
+        t.decimal :arbitrary, precision: nil, scale: nil
+        t.decimal :max100, precision: 2, scale: nil
       end
-      add_index :articles, :title, :unique => true
-      add_index :articles, [:state, :active], :unique => true
+      add_index :articles, :title, unique: true
+      add_index :articles, [:state, :active], unique: true
 
-      create_table :reviews, :force => true do |t|
-        t.integer :article_id, :null => false
-        t.string :author, :null => false
-        t.string :content, :limit => 200
+      create_table :reviews, force: true do |t|
+        t.integer :article_id, null: false
+        t.string :author, null: false
+        t.string :content, limit: 200
         t.string :type
-        t.timestamps :null => false
+        t.timestamps null: false
       end
-      add_index :reviews, :article_id, :unique => true
+      add_index :reviews, :article_id, unique: true
 
-      create_table :article_reviews, :force => true do |t|
+      create_table :article_reviews, force: true do |t|
         t.integer :article_id
         t.integer :review_id
       end
-      add_index :article_reviews, [:article_id, :review_id], :unique => true
+      add_index :article_reviews, [:article_id, :review_id], unique: true
     end
   end
 
@@ -43,8 +43,8 @@ describe "Validations" do
 
         class Review < ActiveRecord::Base
           belongs_to :article
-          belongs_to :news_article, :class_name => 'Article', :foreign_key => :article_id
-          schema_validations :except => :content
+          belongs_to :news_article, class_name: 'Article', foreign_key: :article_id
+          schema_validations except: :content
         end
 
         class ArticleReview < ActiveRecord::Base
@@ -81,15 +81,15 @@ describe "Validations" do
     end
 
     it "should check title length" do
-      expect(Article.new(:title => 'a' * 100).error_on(:title).size).to eq(1)
+      expect(Article.new(title: 'a' * 100).error_on(:title).size).to eq(1)
     end
 
     it "should validate state numericality" do
-      expect(Article.new(:state => 'unknown').error_on(:state).size).to eq(1)
+      expect(Article.new(state: 'unknown').error_on(:state).size).to eq(1)
     end
 
     it "should validate if state is integer" do
-      expect(Article.new(:state => 1.23).error_on(:state).size).to eq(1)
+      expect(Article.new(state: 1.23).error_on(:state).size).to eq(1)
     end
 
     it "should validate the range of votes" do
@@ -115,28 +115,28 @@ describe "Validations" do
       expect(Article.new(max100: -100).error_on(:max100).size).to eq(1)
     end
 
-    it "should not validate the range of arbitrary decimal", :mysql => :skip do  # mysql provides a default precision
+    it "should not validate the range of arbitrary decimal", mysql: :skip do  # mysql provides a default precision
       expect(Article.new(arbitrary: Float::MAX).error_on(:arbitrary).size).to eq(0)
     end
 
     it "should validate average_mark numericality" do
-      expect(Article.new(:average_mark => "high").error_on(:average_mark).size).to eq(1)
+      expect(Article.new(average_mark: "high").error_on(:average_mark).size).to eq(1)
     end
 
     it "should validate boolean fields" do
-      expect(Article.new(:active => nil).error_on(:active).size).to eq(1)
+      expect(Article.new(active: nil).error_on(:active).size).to eq(1)
     end
 
     it "should validate title uniqueness" do
       article1 = Article.create(valid_article_attributes)
-      article2 = Article.new(:title => valid_article_attributes[:title])
+      article2 = Article.new(title: valid_article_attributes[:title])
       expect(article2.error_on(:title).size).to eq(1)
       article1.destroy
     end
 
     it "should validate state uniqueness in scope of 'active' value" do
       article1 = Article.create(valid_article_attributes)
-      article2 = Article.new(valid_article_attributes.merge(:title => 'SchemaPlus 2.0 released'))
+      article2 = Article.new(valid_article_attributes.merge(title: 'SchemaPlus 2.0 released'))
       expect(article2).not_to be_valid
       article2.toggle(:active)
       expect(article2).to be_valid
@@ -151,9 +151,9 @@ describe "Validations" do
     it "should validate uniqueness of belongs_to association" do
       article = Article.create(valid_article_attributes)
       expect(article).to be_valid
-      review1 = Review.create(:article => article, :author => 'michal')
+      review1 = Review.create(article: article, author: 'michal')
       expect(review1).to be_valid
-      review2 = Review.new(:article => article, :author => 'michal')
+      review2 = Review.new(article: article, author: 'michal')
       expect(review2.error_on(:article_id).size).to be >= 1
     end
 
@@ -162,18 +162,81 @@ describe "Validations" do
     end
 
     it "should not validate uniqueness when scope is absent" do
-      article_review_1 = ArticleReview.create(:article_id => 1, :review_id => nil)
+      article_review_1 = ArticleReview.create(article_id: 1, review_id: nil)
       expect(article_review_1).to be_valid
 
-      article_review_2 = ArticleReview.create(:article_id => 1, :review_id => nil)
+      article_review_2 = ArticleReview.create(article_id: 1, review_id: nil)
       expect(article_review_2).to be_valid
 
-      article_review_3 = ArticleReview.create(:article_id => nil, :review_id => 1)
+      article_review_3 = ArticleReview.create(article_id: nil, review_id: 1)
       expect(article_review_3).to be_valid
 
-      article_review_4 = ArticleReview.create(:article_id => nil, :review_id => 1)
+      article_review_4 = ArticleReview.create(article_id: nil, review_id: 1)
       expect(article_review_4).to be_valid
     end
+
+    context 'when NOT NULL validations' do
+      before(:each) do
+        ActiveRecord::Schema.define do
+          create_table :anti_nulls, force: true do |t|
+            t.string :no_default, null: false
+            t.string :blank_default, default: '', null: false
+            t.string :non_blank_default, default: 'not blank', null: false
+          end
+        end
+        with_auto_validations do
+          class AntiNull < ActiveRecord::Base
+            def self.all_blank
+              @all_blank ||= AntiNull.new(
+                no_default: '',
+                blank_default: '',
+                non_blank_default: ''
+              )
+            end
+
+            def self.all_non_blank
+              @all_non_blank ||= AntiNull.new(
+                no_default: 'foo',
+                blank_default: 'bar',
+                non_blank_default: 'baz'
+              )
+            end
+
+            def self.all_nil
+              @all_nil ||= AntiNull.new(
+                no_default: nil,
+                blank_default: nil,
+                non_blank_default: nil
+              )
+            end
+
+            def self.non_null_with(**fields)
+              opts = { no_default: 'foo' }.merge!(fields)
+              AntiNull.new **opts
+            end
+          end
+        end
+
+
+      end
+
+      it 'should fail validation on empty fields only if the default value is not blank' do
+        expect(AntiNull.all_nil.error_on(:no_default).size).to eq(1)
+        expect(AntiNull.all_nil.error_on(:blank_default).size).to eq(1)
+        expect(AntiNull.all_nil.error_on(:non_blank_default).size).to eq(1)
+      end
+
+      it 'should fail validation on empty fields only if the default value is not blank' do
+        expect(AntiNull.all_blank.error_on(:no_default).size).to eq(1)
+        expect(AntiNull.all_blank.error_on(:non_blank_default).size).to eq(1)
+        expect(AntiNull.all_blank.error_on(:blank_default)).to be_empty
+      end
+
+      it 'should not fail if fields are neither nil nor empty' do
+        expect(AntiNull.all_non_blank).to be_valid
+      end
+
+    end
   end
 
   context "auto-created but changed" do
@@ -182,62 +245,62 @@ describe "Validations" do
         class Article < ActiveRecord::Base ; end
         class Review < ActiveRecord::Base
           belongs_to :article
-          belongs_to :news_article, :class_name => 'Article', :foreign_key => :article_id
+          belongs_to :news_article, class_name: 'Article', foreign_key: :article_id
         end
       end
       @too_big_content = 'a' * 1000
     end
 
     it "would normally have an error" do
-      @review = Review.new(:content => @too_big_content)
+      @review = Review.new(content: @too_big_content)
       expect(@review.error_on(:content).size).to eq(1)
       expect(@review.error_on(:author).size).to eq(1)
     end
 
     it "shouldn't validate fields passed to :except option" do
-      Review.schema_validations :except => :content
-      @review = Review.new(:content => @too_big_content)
+      Review.schema_validations except: :content
+      @review = Review.new(content: @too_big_content)
       expect(@review.errors_on(:content).size).to eq(0)
       expect(@review.error_on(:author).size).to eq(1)
     end
 
     it "shouldn't validate the fields in default whitelist" do
-      Review.schema_validations :except => :content
+      Review.schema_validations except: :content
       expect(Review.new.error_on(:updated_at).size).to eq(0)
       expect(Review.new.error_on(:created_at).size).to eq(0)
     end
 
     it "shouldn't validate the fields in whitelist" do
-      Review.schema_validations :except => :content, whitelist: [:updated_at]
+      Review.schema_validations except: :content, whitelist: [:updated_at]
       expect(Review.new.error_on(:updated_at).size).to eq(0)
       expect(Review.new.error_on(:created_at).size).to eq(1)
     end
 
     it "shouldn't validate types passed to :except_type option using full validation" do
-      Review.schema_validations :except_type => :validates_length_of
-      @review = Review.new(:content => @too_big_content)
+      Review.schema_validations except_type: :validates_length_of
+      @review = Review.new(content: @too_big_content)
       expect(@review.errors_on(:content).size).to eq(0)
       expect(@review.error_on(:author).size).to eq(1)
     end
 
     it "shouldn't validate types passed to :except_type option using shorthand" do
-      Review.schema_validations :except_type => :length
-      @review = Review.new(:content => @too_big_content)
+      Review.schema_validations except_type: :length
+      @review = Review.new(content: @too_big_content)
       expect(@review.errors_on(:content).size).to eq(0)
       expect(@review.error_on(:author).size).to eq(1)
     end
 
     it "should only validate type passed to :only_type option" do
-      Review.schema_validations :only_type => :length
-      @review = Review.new(:content => @too_big_content)
+      Review.schema_validations only_type: :length
+      @review = Review.new(content: @too_big_content)
       expect(@review.error_on(:content).size).to eq(1)
       expect(@review.errors_on(:author).size).to eq(0)
     end
 
 
     it "shouldn't create validations if locally disabled" do
-      Review.schema_validations :auto_create => false
-      @review = Review.new(:content => @too_big_content)
+      Review.schema_validations auto_create: false
+      @review = Review.new(content: @too_big_content)
       expect(@review.errors_on(:content).size).to eq(0)
       expect(@review.error_on(:author).size).to eq(0)
     end
@@ -251,23 +314,23 @@ describe "Validations" do
     before(:each) do
       class Review < ActiveRecord::Base
         belongs_to :article
-        belongs_to :news_article, :class_name => 'Article', :foreign_key => :article_id
+        belongs_to :news_article, class_name: 'Article', foreign_key: :article_id
       end
       @too_big_content = 'a' * 1000
     end
 
     it "should not create validation" do
-      expect(Review.new(:content => @too_big_title).errors_on(:content).size).to eq(0)
+      expect(Review.new(content: @too_big_title).errors_on(:content).size).to eq(0)
     end
 
     it "should create validation if locally enabled explicitly" do
-      Review.schema_validations :auto_create => true
-      expect(Review.new(:content => @too_big_content).error_on(:content).size).to eq(1)
+      Review.schema_validations auto_create: true
+      expect(Review.new(content: @too_big_content).error_on(:content).size).to eq(1)
     end
 
     it "should create validation if locally enabled implicitly" do
       Review.schema_validations
-      expect(Review.new(:content => @too_big_content).error_on(:content).size).to eq(1)
+      expect(Review.new(content: @too_big_content).error_on(:content).size).to eq(1)
     end
 
   end
@@ -275,18 +338,18 @@ describe "Validations" do
   context "manually invoked" do
     before(:each) do
       class Article < ActiveRecord::Base ; end
-      Article.schema_validations :only => [:title, :state]
+      Article.schema_validations only: [:title, :state]
 
       class Review < ActiveRecord::Base
         belongs_to :dummy_association
-        schema_validations :except => :content
+        schema_validations except: :content
       end
     end
 
     it "should validate fields passed to :only option" do
       too_big_title = 'a' * 100
       wrong_state = 'unknown'
-      article = Article.new(:title => too_big_title, :state => wrong_state)
+      article = Article.new(title: too_big_title, state: wrong_state)
       expect(article.error_on(:title).size).to eq(1)
       expect(article.error_on(:state).size).to eq(1)
     end
@@ -317,7 +380,7 @@ describe "Validations" do
         belongs_to :article
       end
       @columns = Review.content_columns.dup
-      Review.schema_validations :only => [:title]
+      Review.schema_validations only: [:title]
     end
 
     it "shouldn't validate associations not included in :only option" do
@@ -352,9 +415,9 @@ describe "Validations" do
   context "when used with enum" do
     it "does not validate numericality" do
       class Article < ActiveRecord::Base
-        enum :state => [:happy, :sad]
+        enum state: [:happy, :sad]
       end
-      expect(Article.new(valid_article_attributes.merge(:state => :happy))).to be_valid
+      expect(Article.new(valid_article_attributes.merge(state: :happy))).to be_valid
     end
   end if ActiveRecord::Base.respond_to? :enum
 
@@ -366,11 +429,11 @@ describe "Validations" do
     context 'without scope' do
       before do
         ActiveRecord::Schema.define do
-          create_table :books, :force => true do |t|
+          create_table :books, force: true do |t|
             t.string :title
           end
 
-          add_index :books, :title, :unique => true
+          add_index :books, :title, unique: true
         end
 
         with_auto_validations do
@@ -390,12 +453,12 @@ describe "Validations" do
     context 'within a scope' do
       before do
         ActiveRecord::Schema.define do
-          create_table :folders, :force => true do |t|
+          create_table :folders, force: true do |t|
             t.integer :parent_id
             t.string :name
           end
 
-          add_index :folders, [:parent_id, :name], :unique => true
+          add_index :folders, [:parent_id, :name], unique: true
         end
 
         with_auto_validations do
@@ -408,10 +471,10 @@ describe "Validations" do
       it "should validate the uniqueness in a case insensitive manner" do
         mixed_case_name = 'Schema Validations'
         parent_folder = Folder.create
-        Folder.create(:parent => parent_folder, :name => mixed_case_name)
+        Folder.create(parent: parent_folder, name: mixed_case_name)
 
-        expect(Folder.new(:parent => parent_folder, :name => mixed_case_name)).not_to be_valid
-        expect(Folder.new(:parent => parent_folder, :name => mixed_case_name.downcase)).not_to be_valid
+        expect(Folder.new(parent: parent_folder, name: mixed_case_name)).not_to be_valid
+        expect(Folder.new(parent: parent_folder, name: mixed_case_name.downcase)).not_to be_valid
       end
     end
   end
@@ -419,7 +482,7 @@ describe "Validations" do
   context 'with optimistic locking' do
     before do
       ActiveRecord::Schema.define do
-        create_table :optimistics, :force => true do |t|
+        create_table :optimistics, force: true do |t|
           t.integer :lock_version
         end
       end
@@ -448,11 +511,11 @@ describe "Validations" do
 
   def valid_article_attributes
     {
-      :title => 'SchemaPlus released!',
-      :content => "Database matters. Get full use of it but don't write unecessary code. Get SchemaPlus!",
-      :state => 3,
-      :average_mark => 9.78,
-      :active => true
+      title: 'SchemaPlus released!',
+      content: "Database matters. Get full use of it but don't write unecessary code. Get SchemaPlus!",
+      state: 3,
+      average_mark: 9.78,
+      active: true
     }
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: schema_validations
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.2.1
 platform: ruby
 authors:
 - Ronen Barzel
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-25 00:00:00.000000000 Z
+date: 2017-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: schema_plus_columns
@@ -188,6 +188,7 @@ files:
 - lib/schema_validations/active_record/type.rb
 - lib/schema_validations/active_record/validations.rb
 - lib/schema_validations/railtie.rb
+- lib/schema_validations/validators/not_nil_validator.rb
 - lib/schema_validations/version.rb
 - schema_dev.yml
 - schema_validations.gemspec