validates_by_schema 0.2.2 → 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a44382b4c751d51c6056b9eae1daed6f8eedfe8040383fe38ce717beafc2c84d
+  data.tar.gz: 553ffe11b1a3c83f6c2f1126954d691553465492f7f3820f6530b14a48675971
+SHA512:
+  metadata.gz: b404ea525a570681cc76d936755f6f6fbc89a310e8409d0480161a2a9aad11e1c803445c30b0cf03ce951d02ae63f614715e48c3a9bfde80455e5cec4b293c71
+  data.tar.gz: a7b24d0fe512674063b0c055f155b5cd608661fcf284634399354c6d63a3acfbf7fba6e9de335ea5e55e25765cedc8bda60505879aa7d9a09f96a3e828ebadba

data/README.md

@@ -1,8 +1,9 @@
 # Validates By Schema (validates_by_schema)
-[![Build Status](https://secure.travis-ci.org/joshwlewis/validates_by_schema.png)](http://travis-ci.org/joshwlewis/validates_by_schema) 
-[![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/joshwlewis/validates_by_schema)
-[![Dependency Status](https://gemnasium.com/joshwlewis/validates_by_schema.png)](https://gemnasium.com/joshwlewis/validates_by_schema)
-[![Gem Version](https://badge.fury.io/rb/validates_by_schema.png)](http://badge.fury.io/rb/validates_by_schema)
+
+[![Gem Version](http://img.shields.io/gem/v/validates_by_schema.svg?style=flat)](https://rubygems.org/gems/validates_by_schema)
+[![Build Status](http://img.shields.io/github/workflow/status/joshwlewis/validates_by_schema/Build?style=flat)](https://github.com/joshwlewis/validates_by_schema/actions/workflows/build.yml)
+[![Coverage Status](http://img.shields.io/coveralls/joshwlewis/validates_by_schema.svg?style=flat)](https://coveralls.io/r/joshwlewis/validates_by_schema)
+[![Code Climate](http://img.shields.io/codeclimate/maintainability/joshwlewis/validates_by_schema.svg?style=flat)](https://codeclimate.com/github/joshwlewis/validates_by_schema)
 
 Automatic validation based on your database schema column types and limits. Keep your code DRY by inferring column validations from table properties!
 
@@ -11,21 +12,35 @@ Automatic validation based on your database schema column types and limits. Keep
 Say you had a table setup like this:
 
 ```ruby
-create_table "widgets", :force => true do |t|
-  t.integer  "quantity", :limit => 2
-  t.decimal  "thickness", :precision => 4, :scale => 4
-  t.string   "color", :null => false
+create_table "widgets", force: true do |t|
+  t.integer "quantity", limit: 2, null: false
+  t.decimal "thickness", precision: 4, scale: 4
+  t.string  "color", null: false
+  t.boolean "flagged", null: false, default: false
+  t.integer "other_id", null: false
+  t.index ["other_id", "color"], unique: true
 end
 ```
 
 Then these validations are inferred when you add `validates_by_schema` to your model:
 
 ```ruby
-validates :quantity, numericality: { allow_nil: true,
-  greater_than: -32768, less_than: 32768}
-validates :thickness, numericality: {allow_nil: true, 
-  less_than_or_equal_to: 0.999, greater_than_or_equal_to: -0.999}
-validates :color, presence: true, length: {allow_nil: false, maximum: 255}
+validates :quantity, presence: true,
+                     numericality: { allow_nil: true,
+                                     only_integer: true,
+                                     greater_than: -32768,
+                                     less_than: 32768}
+validates :thickness, numericality: { allow_nil: true,
+                                      less_than_or_equal_to: 0.999,
+                                      greater_than_or_equal_to: -0.999 }
+validates :color, presence: true, length: { allow_nil: true, maximum: 255 }
+validates :flagged, inclusion: { in: [true, false], allow_nil: false }
+validates :other, presence: true
+validates :other_id,
+          uniqueness: {
+            scope: :color,
+            if: -> { |model| model.other_id_changed? || model.color_changed? }
+          }
 ```
 
 ## Installation
@@ -58,8 +73,24 @@ validates_by_schema only: [:body, :description]
 validates_by_schema except: [:name, :title]
 ```
 
+The primary key and timestamp columns are not validated.
+
+If you want to opt out of automatic uniqueness validations globally, add the following line to an initializer:
+
+```ruby
+ValidatesBySchema.validate_uniqueness = false
+```
+
 ## Notes
 
 Column properties are inferred by your database adapter (like pg, mysql2, sqlite3), and does not depend on migration files or schema.rb. As such, you could use this on projects where the database where Rails is not in control of the database configuration.
 
-This has been tested with mysql, postgresql, and sqlite3. It should work with any other database that has reliable adapter.
+This has been tested with mysql, postgresql, and sqlite3. It should work with any other database that has reliable adapter.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/joshwlewis/validates_by_schema.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -20,19 +20,35 @@ RDoc::Task.new(:rdoc) do |rdoc|
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
-
-
-
 Bundler::GemHelper.install_tasks
 
-require 'rake/testtask'
+require 'rspec/core/rake_task'
 
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib'
-  t.libs << 'test'
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = false
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = Dir.glob('spec/**/*_spec.rb')
+  t.rspec_opts = ['--backtrace']
 end
 
-
-task :default => :test
+task default: :spec
+
+namespace :db do
+  task :drop do
+    puts 'dropping'
+    case ENV['DB']
+    when 'postgresql'
+      exec "psql -c 'drop database if exists validates_by_schema_test;' -U postgres -h localhost"
+    when 'mysql'
+      exec "mysql -e 'drop database if exists validates_by_schema_test;' -u root -h 127.0.0.1"
+    end
+  end
+
+  task :create do
+    puts 'creating'
+    case ENV['DB']
+    when 'postgresql'
+      exec "psql -c 'create database validates_by_schema_test;' -U postgres -h localhost"
+    when 'mysql'
+      exec "mysql -e 'create database validates_by_schema_test;' -u root -h 127.0.0.1"
+    end
+  end
+end

data/lib/validates_by_schema/validation_option.rb

@@ -1,12 +1,40 @@
 class ValidatesBySchema::ValidationOption
   # column here must be an ActiveRecord column
   # i.e. MyARModel.columns.first
-  attr_accessor :column
+  attr_accessor :klass, :column
 
-  def initialize(column)
+  def initialize(klass, column)
+    @klass = klass
     @column = column
   end
 
+  def define!
+    if association
+      # Only presence and uniqueness are handled for associations.
+      # presence on the association name, uniqueness on the column name.
+      define_belongs_to_presence_validation
+    else
+      define_validations(to_hash)
+    end
+    define_uniqueness_validations if ValidatesBySchema.validate_uniqueness
+  end
+
+  private
+
+  def define_belongs_to_presence_validation
+    klass.validates association.name, presence: true if !ActiveRecord::Base.belongs_to_required_by_default && presence
+  end
+
+  def define_uniqueness_validations
+    uniqueness.each do |options|
+      define_validations(uniqueness: options)
+    end
+  end
+
+  def define_validations(options)
+    klass.validates column.name, options if options.present?
+  end
+
   def presence?
     presence && column.type != :boolean
   end
@@ -15,8 +43,12 @@ class ValidatesBySchema::ValidationOption
     !column.null
   end
 
+  def enum?
+    klass.respond_to?(:defined_enums) && klass.defined_enums.has_key?(column.name)
+  end
+
   def numericality?
-    [:integer, :decimal, :float].include? column.type
+    [:integer, :decimal, :float].include?(column.type) && !enum?
   end
 
   def numericality
@@ -27,20 +59,48 @@ class ValidatesBySchema::ValidationOption
         numericality[:less_than] = integer_max
         numericality[:greater_than] = -integer_max
       end
-    elsif column.type == :decimal
+    elsif column.type == :decimal && decimal_max
       numericality[:less_than_or_equal_to] = decimal_max
       numericality[:greater_than_or_equal_to] = -decimal_max
     end
-    numericality[:allow_nil] = column.null
+    numericality[:allow_nil] = true
     numericality
   end
 
+  def uniqueness
+    unique_indexes.map do |index|
+      {
+        scope: index.columns.reject { |col| col == column.name },
+        conditions: -> { where(index.where) },
+        allow_nil: column.null,
+        case_sensitive: case_sensitive?,
+        if: ->(model) { index.columns.any? { |c| model.send("#{c}_changed?") } }
+      }
+    end
+  end
+
+  def unique_indexes
+    klass
+      .connection
+      .indexes(klass.table_name)
+      .select { |index| index.unique && index.columns.first == column.name }
+  end
+
+  def case_sensitive?
+    !klass.connection.respond_to?(:collation) ||
+      !klass.connection.collation.end_with?('_ci')
+  end
+
+  def array?
+    column.respond_to?(:array) && column.array
+  end
+
   def length?
-    [:string, :text].include?(column.type) && column.limit
+    [:string, :text].include?(column.type) && column.limit && !array?
   end
 
   def length
-    {:maximum => column.limit, :allow_nil => column.null }
+    { maximum: column.limit, allow_nil: true }
   end
 
   def inclusion?
@@ -48,23 +108,25 @@ class ValidatesBySchema::ValidationOption
   end
 
   def inclusion
-    {:in => [true, false], :allow_nil => column.null}
+    { in: [true, false], allow_nil: column.null }
   end
 
   def integer_max
-    (2 ** (8 * column.limit)) / 2 if column.limit
+    (2**(8 * column.limit)) / 2 if column.limit
   end
 
   def decimal_max
-    10.0**(column.precision-column.scale) - 10.0**(-column.scale)
+    10.0**(column.precision - column.scale) - 10.0**(-column.scale) if column.precision && column.scale
   end
 
-  def string_max
-    column.limit
+  def association
+    @association ||= klass.reflect_on_all_associations(:belongs_to).find do |a|
+      a.foreign_key.to_s == column.name
+    end
   end
 
   def to_hash
-    [:presence, :numericality, :length, :inclusion].inject({}) do |h,k|
+    [:presence, :numericality, :length, :inclusion].inject({}) do |h, k|
       send(:"#{k}?") ? h.merge(k => send(k)) : h
     end
   end
@@ -73,4 +135,4 @@ class ValidatesBySchema::ValidationOption
     to_hash.inspect
   end
 
-end
+end

data/lib/validates_by_schema/version.rb

@@ -1,3 +1,3 @@
 module ValidatesBySchema
-  VERSION = "0.2.2"
+  VERSION = '0.5.0'
 end

data/lib/validates_by_schema.rb

@@ -1,30 +1,62 @@
+require 'active_support/concern'
+require 'active_support/lazy_load_hooks'
+
 module ValidatesBySchema
   autoload :ValidationOption, 'validates_by_schema/validation_option'
 
   extend ActiveSupport::Concern
 
+  mattr_accessor :validate_uniqueness
+  self.validate_uniqueness = true
+
   module ClassMethods
-    def validates_by_schema options={}
-      return unless table_exists?
-      columns = schema_validateable_columns
 
-      # Allow user to specify :only or :except options
-      [:only => :select!, :except => :reject!].each do |k,v|
-        columns.send(v){|c| options[k].include? c.name} if options[k]
+    def validates_by_schema(options = {})
+      @validates_by_schema_options = options
+      define_schema_validations if schema_loaded?
+    end
+
+    def load_schema!
+      super
+      # define schema validations lazy to avoid accessing the database
+      # at class load time.
+      define_schema_validations
+    end
+
+    private
+
+    def define_schema_validations
+      return unless @validates_by_schema_options
+
+      customized_schema_validatable_columns.each do |c|
+        ValidationOption.new(self, c).define!
       end
 
-      columns.each do |c|
-        vo = ValidationOption.new(c).to_hash
-        validates c.name, vo if vo.present?
+      @validates_by_schema_options = nil
+    end
+
+    def customized_schema_validatable_columns
+      # Allow user to specify :only or :except options
+      schema_validatable_columns.tap do |columns|
+        { only: :select!, except: :reject! }.each do |k, v|
+          if @validates_by_schema_options[k]
+            attrs = Array(@validates_by_schema_options[k]).collect(&:to_s)
+            columns.send(v) { |c| attrs.include?(c.name) }
+          end
+        end
       end
     end
 
-    def schema_validateable_columns
-      # Don't auto validate primary keys or timestamps
-      columns.reject do |c| 
-        c.primary || %w(updated_at created_at).include?(c.name)
+    def schema_validatable_columns
+      columns.reject do |c|
+        ignored_columns_for_validates_by_schema.include?(c.name)
       end
     end
+
+    def ignored_columns_for_validates_by_schema
+      [primary_key.to_s, 'created_at', 'updated_at', 'deleted_at']
+    end
+
   end
 end
 

data/spec/ci/rails50.gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+gemspec path: '../..'
+
+gem 'simplecov', require: false
+gem 'simplecov-lcov', require: false
+
+gem 'activerecord', '~> 5.0.0'
+
+gem 'sqlite3', '~> 1.3.7'

data/spec/ci/rails50.gemfile.lock

@@ -0,0 +1,118 @@
+PATH
+  remote: ../..
+  specs:
+    validates_by_schema (0.4.0)
+      activerecord (>= 5.0.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actionpack (5.0.7.2)
+      actionview (= 5.0.7.2)
+      activesupport (= 5.0.7.2)
+      rack (~> 2.0)
+      rack-test (~> 0.6.3)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.0.2)
+    actionview (5.0.7.2)
+      activesupport (= 5.0.7.2)
+      builder (~> 3.1)
+      erubis (~> 2.7.0)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.0.3)
+    activemodel (5.0.7.2)
+      activesupport (= 5.0.7.2)
+    activerecord (5.0.7.2)
+      activemodel (= 5.0.7.2)
+      activesupport (= 5.0.7.2)
+      arel (~> 7.0)
+    activesupport (5.0.7.2)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    arel (7.1.4)
+    builder (3.2.4)
+    concurrent-ruby (1.1.9)
+    crass (1.0.6)
+    diff-lcs (1.4.4)
+    docile (1.4.0)
+    erubis (2.7.0)
+    i18n (1.8.11)
+      concurrent-ruby (~> 1.0)
+    loofah (2.12.0)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.5.9)
+    method_source (1.0.0)
+    mini_portile2 (2.6.1)
+    minitest (5.14.4)
+    mysql2 (0.5.3)
+    nokogiri (1.12.5)
+      mini_portile2 (~> 2.6.1)
+      racc (~> 1.4)
+    pg (1.2.3)
+    racc (1.6.0)
+    rack (2.2.3)
+    rack-test (0.6.3)
+      rack (>= 1.0)
+    rails-dom-testing (2.0.3)
+      activesupport (>= 4.2.0)
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.4.2)
+      loofah (~> 2.3)
+    railties (5.0.7.2)
+      actionpack (= 5.0.7.2)
+      activesupport (= 5.0.7.2)
+      method_source
+      rake (>= 0.8.7)
+      thor (>= 0.18.1, < 2.0)
+    rake (13.0.6)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-rails (4.1.2)
+      actionpack (>= 4.2)
+      activesupport (>= 4.2)
+      railties (>= 4.2)
+      rspec-core (~> 3.10)
+      rspec-expectations (~> 3.10)
+      rspec-mocks (~> 3.10)
+      rspec-support (~> 3.10)
+    rspec-support (3.10.3)
+    shoulda-matchers (4.5.1)
+      activesupport (>= 4.2.0)
+    simplecov (0.21.2)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+      simplecov_json_formatter (~> 0.1)
+    simplecov-html (0.12.3)
+    simplecov-lcov (0.8.0)
+    simplecov_json_formatter (0.1.3)
+    sqlite3 (1.3.13)
+    thor (1.1.0)
+    thread_safe (0.3.6)
+    tzinfo (1.2.9)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (~> 5.0.0)
+  mysql2
+  pg
+  rake
+  rspec-rails
+  shoulda-matchers
+  simplecov
+  simplecov-lcov
+  sqlite3 (~> 1.3.7)
+  validates_by_schema!
+
+BUNDLED WITH
+   2.1.4

data/spec/ci/rails52.gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gemspec path: '../..'
+
+gem 'simplecov', require: false
+gem 'simplecov-lcov', require: false
+
+gem 'activerecord', '~> 5.2.0'

data/spec/ci/rails60.gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gemspec path: '../..'
+
+gem 'simplecov', require: false
+gem 'simplecov-lcov', require: false
+
+gem 'activerecord', '~> 6.0.0'

data/spec/config/database.yml

@@ -0,0 +1,31 @@
+sqlite: &sqlite
+  adapter: sqlite3
+  database: spec/db/<%= ENV["RAILS_ENV"] %>.sqlite3
+
+mysql: &mysql
+  adapter: mysql2
+  username: root
+  password:
+  database: validates_by_schema_<%= ENV["RAILS_ENV"] %>
+
+postgresql: &postgresql
+  adapter: postgresql
+  username: postgres
+  password: postgres
+  database: validates_by_schema_<%= ENV["RAILS_ENV"] %>
+  min_messages: ERROR
+
+defaults: &defaults
+  pool: 5
+  timeout: 5000
+  host: '127.0.0.1'
+  <<: *<%= ENV['DB'] || "sqlite" %>
+
+development:
+  <<: *defaults
+
+test:
+  <<: *defaults
+
+production:
+  <<: *defaults

data/spec/config/schema.rb

@@ -0,0 +1,44 @@
+# encoding: UTF-8
+# This file is auto-generated from the current state of the database. Instead
+# of editing this file, please use the migrations feature of Active Record to
+# incrementally modify your database, and then regenerate this schema definition.
+#
+# Note that this schema.rb definition is the authoritative source for your
+# database schema. If you need to create the application database on another
+# system, you should be using db:schema:load, not running all the migrations
+# from scratch. The latter is a flawed and unsustainable approach (the more migrations
+# you'll amass, the slower it'll run and the greater likelihood for issues).
+#
+# It's strongly recommended to check this file into your version control system.
+
+ActiveRecord::Schema.define(version: 20_121_210_034_140) do
+  create_table 'widgets', force: true do |t|
+    t.string 'name',          limit: 50
+    t.string 'model',                                                null: false
+    t.text 'description'
+    t.integer 'wheels',                                              null: false
+    t.integer 'doors',         limit: 2
+    t.decimal 'price',                       precision: 6, scale: 2
+    t.decimal 'cost',                        precision: 4, scale: 2, null: false
+    t.decimal 'completion'
+    t.float 'rating'
+    t.float 'score',                                                 null: false
+    t.datetime 'published_at'
+    t.date 'invented_on'
+    t.time 'startup_time'
+    t.time 'shutdown_time',                                          null: false
+    t.boolean 'enabled'
+    t.binary 'data'
+    t.integer 'parent_id',                                           null: false
+    t.integer 'other_id'
+    t.integer 'kind',                                                null: false
+    t.string 'list', array: true, limit: 3
+
+    t.index 'parent_id'
+    t.index ['name', 'wheels'], unique: true
+    t.index 'other_id', unique: true
+    t.index ['doors'], unique: true, where: 'enabled = true'
+    t.index ['model', 'price'], unique: true
+    t.index ['model', 'cost'], unique: true
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,75 @@
+ENV['RAILS_ENV'] ||= 'test'
+
+require 'yaml'
+require 'active_record'
+require 'shoulda-matchers'
+require 'simplecov'
+
+SimpleCov.start do
+  if ENV['CI']
+    require 'simplecov-lcov'
+
+    SimpleCov::Formatter::LcovFormatter.config do |c|
+      c.report_with_single_file = true
+      c.single_report_path = 'coverage/lcov.info'
+    end
+
+    formatter SimpleCov::Formatter::LcovFormatter
+  end
+end
+
+# Load up our code
+require 'validates_by_schema'
+
+# Setup the database
+conf = YAML.load(ERB.new(File.read(File.join(File.dirname(__FILE__), 'config', 'database.yml'))).result)
+ActiveRecord::Base.establish_connection(conf['test'])
+
+ActiveRecord::Base.belongs_to_required_by_default = false
+
+load(File.join(File.dirname(__FILE__), 'config', 'schema.rb'))
+
+# Add support test models to the load path.
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), 'support', 'models'))
+
+# Require all support files
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+  config.around do |example|
+    ActiveRecord::Base.transaction do
+      example.run
+      raise ActiveRecord::Rollback
+    end
+  end
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+
+  config.include(Shoulda::Matchers::ActiveModel)
+  config.include(Shoulda::Matchers::ActiveRecord)
+end
+
+Shoulda::Matchers.configure do |config|
+  config.integrate do |with|
+    with.test_framework :rspec
+    with.library :active_record
+    with.library :active_model
+  end
+end
+
+module Shoulda
+  module Matchers
+    module ActiveModel
+      class ValidatePresenceOfMatcher < ValidationMatcher
+        # monkey patch to use `include?` instead of `in?`
+        def collection_association?
+          association? && %i[has_many has_and_belongs_to_many].include?(association_reflection.macro)
+        end
+      end
+    end
+  end
+end

data/spec/support/models/contraption.rb

@@ -0,0 +1,7 @@
+require 'widget'
+
+class Contraption < Widget
+  enum kind: %w(one other)
+
+  validates_by_schema
+end

data/spec/support/models/gadget.rb

@@ -0,0 +1,5 @@
+require 'widget'
+
+class Gadget < Widget
+  validates_by_schema except: :wheels
+end

data/spec/support/models/gizmo.rb

@@ -0,0 +1,7 @@
+require 'widget'
+
+class Gizmo < Widget
+  load_schema # who knows, probably loaded by somebody else before validates_by_schema
+
+  validates_by_schema only: [:name, :wheels, :cost]
+end

data/spec/support/models/sub_contraption.rb

@@ -0,0 +1,4 @@
+require 'contraption'
+
+class SubContraption < Contraption
+end

data/spec/support/models/widget.rb

@@ -0,0 +1,6 @@
+class Widget < ActiveRecord::Base
+
+  belongs_to :parent, class_name: 'Widget'
+  belongs_to :other, class_name: 'Widget', optional: true
+
+end

data/spec/validations_spec.rb

@@ -0,0 +1,340 @@
+require 'spec_helper'
+
+describe 'validates by schema' do
+  let(:attributes) do
+    {
+      name: 'Secret',
+      model: 'secret-42',
+      description: 'Life, the Universe, Everything',
+      wheels: 4,
+      doors: 2,
+      price: 4242.42,
+      cost: 42.42,
+      completion: 0.424,
+      rating: 42.4242,
+      score: 4242.42,
+      published_at: Time.now.to_datetime,
+      invented_on: Time.now.to_date,
+      startup_time: 1.hour.ago,
+      shutdown_time: 4.hours.from_now,
+      enabled: true,
+      data: 'the question'.unpack('b*').to_s,
+      parent: Widget.new,
+      kind: 'one',
+      list: ['abc']
+    }
+  end
+
+  context 'plain' do
+    subject { Contraption.new attributes }
+
+    context 'validates columns of type' do
+      context :string do
+        it { should_not validate_presence_of(:name) }
+        it { should validate_length_of(:name).is_at_most(50) }
+        it { should validate_presence_of(:model) }
+        if ENV['DB'] == 'mysql'
+          it { should validate_length_of(:model).is_at_most(255) }
+        end
+      end
+
+      context :text do
+        it { should_not validate_presence_of(:description) }
+        it { should_not validate_length_of(:description).is_at_most(10_000_000) }
+      end
+
+      context :primary_key do
+        it { should_not validate_presence_of(:id) }
+      end
+
+      context :integer do
+        it { should validate_presence_of(:wheels) }
+        it { should validate_numericality_of(:wheels).only_integer }
+        it { should allow_value(242_424).for(:wheels) }
+        it { should allow_value(-242_424).for(:wheels) }
+        if ENV['DB'] != 'mysql'
+          it { should allow_value(2_147_483_647).for(:wheels) }
+          it { should allow_value(-2_147_483_647).for(:wheels) }
+          if ENV['DB'] != 'postgresql' && ActiveRecord.version.to_s >= '5.1'
+            it { should allow_value(10**100).for(:wheels) }
+            it { should allow_value(-10**100).for(:wheels) }
+          end
+        end
+
+        it { should_not validate_presence_of(:doors) }
+        it { should validate_numericality_of(:doors).only_integer }
+        it { should allow_value(32767).for(:doors) }
+        it { should allow_value(-32767).for(:doors) }
+        it { should_not allow_value(32768).for(:doors) }
+        it { should_not allow_value(-32768).for(:doors) }
+      end
+
+      context :decimal do
+        it { should_not validate_presence_of(:price) }
+        it { should validate_numericality_of(:price) }
+        it { should allow_value(-9_999.99).for(:price) }
+        it { should allow_value(9_999.99).for(:price) }
+        it { should_not allow_value(10_000).for(:price) }
+        it { should_not allow_value(-10_000).for(:price) }
+
+        it { should validate_presence_of(:cost) }
+        it { should validate_numericality_of(:cost) }
+        it { should allow_value(99.99).for(:cost) }
+        it { should allow_value(-99.99).for(:cost) }
+        it { should_not allow_value(100).for(:cost) }
+        it { should_not allow_value(-100).for(:cost) }
+      end
+
+      context :float do
+        it { should_not validate_presence_of(:rating) }
+        it { should validate_numericality_of(:rating) }
+        it { should allow_value(242_424.242424).for(:rating) }
+        it { should allow_value(-5).for(:rating) }
+
+        it { should validate_presence_of(:score) }
+        it { should validate_numericality_of(:score) }
+        it { should allow_value(242_424.242424).for(:score) }
+        it { should allow_value(-5).for(:score) }
+      end
+
+      context :datetime do
+        it { should_not validate_presence_of(:published_at) }
+      end
+
+      context :date do
+        it { should_not validate_presence_of(:invented_on) }
+      end
+
+      context :time do
+        it { should_not validate_presence_of(:startup_time) }
+        it { should validate_presence_of(:shutdown_time) }
+      end
+
+      context :belongs_to do
+        if !ActiveRecord::Base.belongs_to_required_by_default
+          # belongs_to_required_by_default produces message 'must exist' instead of 'can't be blank'
+          it { should validate_presence_of(:parent) }
+        end
+
+        it { should allow_value(Widget.new).for(:parent) }
+        it { should_not allow_value(nil).for(:parent) }
+      end
+
+      context :enum do
+        it { should validate_presence_of(:kind) }
+        it { should allow_value('other').for(:kind) }
+      end
+
+      if ENV['DB'] == 'postgresql'
+        context :array do
+          it { should allow_value(['abc', 'def', 'ghi', 'jkl']).for(:list) }
+          # this value will be rejected by the db, but the validation would require a custom
+          # validator.
+          it { should allow_value(['abcdef']).for(:list) }
+        end
+      end
+    end
+
+    context 'validates uniqueness' do
+      let(:valid_attributes) do
+        attrs = attributes.dup
+
+        attrs[:list] = nil
+        attrs[:parent_id] = 23
+        attrs[:other_id] = 42
+        attrs[:wheels] = 3
+        attrs[:name] = 'Geheimnis'
+        attrs[:model] = 'secret-23'
+        attrs[:cost] = 9.99
+        attrs[:price] = 20.01
+
+        attrs
+      end
+      let(:existing_widget) { Widget.new(valid_attributes) }
+      before do
+        subject.list = nil
+        existing_widget.save!
+      end
+
+      context :simple_non_unique_index do
+        context 'has assumptions' do
+          it { expect(existing_widget.parent_id).to eq 23 }
+        end
+
+        it { should_not validate_uniqueness_of(:parent_id) }
+        it { should allow_value(23).for(:parent_id) }
+      end
+
+      context :simple_unique_index do
+        context 'has assumptions' do
+          it { expect(existing_widget.other_id).to eq 42 }
+        end
+
+        it { should validate_uniqueness_of(:other_id) }
+        it { should_not allow_value(42).for(:other_id) }
+        it { should allow_value(43).for(:other_id) }
+      end
+
+      context :multi_column_unique_index do
+        before { existing_widget.update!(wheels: 4) }
+
+        context 'has assumptions' do
+          it { expect(existing_widget.name).to eq 'Geheimnis' }
+          it { expect(existing_widget.wheels).to eq 4 }
+          it { expect(subject.wheels).to eq 4 }
+        end
+
+        it { should validate_uniqueness_of(:name).scoped_to(:wheels).ignoring_case_sensitivity }
+        it { should_not allow_value('Geheimnis').for(:name) }
+        it do
+          subject.wheels = 3
+          should allow_value('Geheimnis').for(:name)
+        end
+      end
+
+      context :multiple_multi_column_unique_index do
+        before { existing_widget.update!(cost: 10.0, price: 20.0) }
+
+        context 'has assumptions' do
+          it { expect(existing_widget.model).to eq 'secret-23' }
+          it { expect(existing_widget.cost).to eq 10.0 }
+          it { expect(existing_widget.price).to eq 20.0 }
+          it { expect(subject.cost).to eq 42.42 }
+          it { expect(subject.price).to eq 4242.42 }
+        end
+
+        it { should allow_value('secret-23').for(:model) }
+        it do
+          subject.cost = 10.0
+          should_not allow_value('secret-23').for(:model)
+        end
+        it do
+          subject.cost = 10.0
+          subject.price = 20.0
+          should_not allow_value('secret-23').for(:model)
+        end
+      end
+
+      if ENV['DB'] == 'postgresql'
+        context :partial_unique_index do
+          context 'has assumptions' do
+            it { expect(existing_widget.doors).to eq 2 }
+            it { expect(existing_widget).to be_enabled }
+            it { should be_enabled }
+          end
+
+          it { should validate_uniqueness_of(:doors) }
+          it { should_not allow_value(2).for(:doors) }
+          it do
+            existing_widget.update(enabled: false)
+            should allow_value(2).for(:doors)
+          end
+        end
+      end
+    end
+  end
+
+  context 'with except' do
+    subject { Gadget.new attributes }
+
+    context 'does not validate passed columns' do
+      context :string do
+        it { should_not validate_presence_of(:name) }
+        it { should validate_length_of(:name).is_at_most(50) }
+      end
+
+      context :integer do
+        it { should_not validate_presence_of(:wheels) }
+        it { should_not validate_numericality_of(:wheels) }
+        it { should allow_value(242_424).for(:wheels) }
+        it { should allow_value(-42_424).for(:wheels) }
+        if ENV['DB'] == 'postgresql' && ActiveRecord.version.to_s >= '5.1'
+          # Indexed int colums produce ActiveModel::RangeError in Rails 5
+          it { should allow_value(10**100).for(:wheels) }
+          it { should allow_value(-10**100).for(:wheels) }
+        end
+      end
+
+      context :decimal do
+        it { should_not validate_presence_of(:price) }
+        it { should validate_numericality_of(:price) }
+      end
+    end
+  end
+
+  context 'with only' do
+    subject { Gizmo.new attributes }
+
+    context 'validate just passed columns' do
+      context :string do
+        it { should_not validate_presence_of(:name) }
+        it { should validate_length_of(:name).is_at_most(50) }
+      end
+
+      context :integer do
+        it { should validate_presence_of(:wheels) }
+        it { should validate_numericality_of(:wheels).only_integer }
+        it { should allow_value(242_424).for(:wheels) }
+        it { should allow_value(-42_424).for(:wheels) }
+        if ENV['DB'] != 'mysql'
+          it { should allow_value(2_147_483_647).for(:wheels) }
+          it { should allow_value(-2_147_483_647).for(:wheels) }
+          if ENV['DB'] != 'postgresql' && ActiveRecord.version.to_s >= '5.1'
+            it { should allow_value(10**100).for(:wheels) }
+            it { should allow_value(-10**100).for(:wheels) }
+          end
+        end
+      end
+
+      context :decimal do
+        it { should_not validate_presence_of(:price) }
+        it { should_not validate_numericality_of(:price) }
+        it { should allow_value('1000000').for(:price) }
+      end
+    end
+  end
+
+  context 'subclass' do
+    subject { SubContraption.new attributes }
+
+    context 'performs validations as well' do
+      context :string do
+        it { should_not validate_presence_of(:name) }
+        it { should validate_length_of(:name).is_at_most(50) }
+        it { should validate_presence_of(:model) }
+      end
+    end
+  end
+
+  context 'multiple threads' do
+    subject { Contraption.new attributes }
+
+    it 'defines validations only once' do
+      subject.list = nil
+      subject.model = nil
+      5.times do
+        Thread.new do
+          Contraption.new.valid?
+        end
+      end
+
+      expect(subject).not_to be_valid
+      expect(subject.errors.full_messages).to eq(["Model can't be blank"])
+    end
+  end
+
+  context 'reset_column_information' do
+    subject { Contraption.new attributes }
+
+    it 'does not duplicate validations' do
+      subject.list = nil
+      expect(subject).to be_valid
+
+      Contraption.reset_column_information
+
+      subject.model = nil
+      expect(subject).not_to be_valid
+      expect(subject.errors.full_messages).to eq(["Model can't be blank"])
+    end
+  end
+end

metadata

@@ -1,151 +1,182 @@
 --- !ruby/object:Gem::Specification
 name: validates_by_schema
 version: !ruby/object:Gem::Version
-  version: 0.2.2
-  prerelease: 
+  version: 0.5.0
 platform: ruby
 authors:
 - Josh Lewis
+- Pascal Zumkehr
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-08 00:00:00.000000000 Z
+date: 2021-11-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rails
+  name: activerecord
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 3.1.0
+        version: 5.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 3.1.0
+        version: 5.0.0
 - !ruby/object:Gem::Dependency
-  name: rspec-rails
+  name: mysql2
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: shoulda-matchers
+  name: pg
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: sqlite3
+  name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: pg
+  name: rspec-rails
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: mysql2
+  name: shoulda-matchers
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Keep your code DRY by inferring column validations from table properties!
-  Automagically validate presence, length, numericality, and inclusion of ActiveRecord
-  backed columns.
+  Automagically validate presence, length, numericality, inclusion and uniqueness
+  of ActiveRecord backed columns.
 email:
 - josh.w.lewis@gmail.com
+- pascal@codez.ch
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/tasks/validates_by_schema_tasks.rake
-- lib/validates_by_schema/validation_option.rb
-- lib/validates_by_schema/version.rb
-- lib/validates_by_schema.rb
 - MIT-LICENSE
-- Rakefile
 - README.md
-homepage: http://github.com/joshwlewis/validates_by_schema
-licenses: []
+- Rakefile
+- lib/validates_by_schema.rb
+- lib/validates_by_schema/validation_option.rb
+- lib/validates_by_schema/version.rb
+- spec/ci/rails50.gemfile
+- spec/ci/rails50.gemfile.lock
+- spec/ci/rails52.gemfile
+- spec/ci/rails60.gemfile
+- spec/config/database.yml
+- spec/config/schema.rb
+- spec/db/test.sqlite3
+- spec/spec_helper.rb
+- spec/support/models/contraption.rb
+- spec/support/models/gadget.rb
+- spec/support/models/gizmo.rb
+- spec/support/models/sub_contraption.rb
+- spec/support/models/widget.rb
+- spec/validations_spec.rb
+homepage: https://github.com/joshwlewis/validates_by_schema
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/joshwlewis/validates_by_schema
+  source_code_uri: https://github.com/joshwlewis/validates_by_schema
+  changelog_uri: https://github.com/joshwlewis/validates_by_schema/blob/master/CHANGELOG.md
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 3.1.4
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Automatic validation based on your database schema column types and limits.
-test_files: []
-has_rdoc: 
+test_files:
+- spec/spec_helper.rb
+- spec/db/test.sqlite3
+- spec/validations_spec.rb
+- spec/support/models/widget.rb
+- spec/support/models/contraption.rb
+- spec/support/models/sub_contraption.rb
+- spec/support/models/gadget.rb
+- spec/support/models/gizmo.rb
+- spec/config/schema.rb
+- spec/config/database.yml
+- spec/ci/rails52.gemfile
+- spec/ci/rails50.gemfile
+- spec/ci/rails60.gemfile
+- spec/ci/rails50.gemfile.lock

data/lib/tasks/validates_by_schema_tasks.rake

@@ -1,4 +0,0 @@
-# desc "Explaining what the task does"
-# task :validates_by_schema do
-#   # Task goes here
-# end