generated_schema_validations 0.6.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ec2ac3a0961cac39ac98ad2b31f7c81d9858f50c0170c2f0ec49cf71df766806
-  data.tar.gz: 117604c47ecae3fabd1c7199ea92e6b076d78b2131313e7998176e4d4d7bcd0b
+  metadata.gz: d49e52636e38031fc0717496547eebc4d6f92c04512830dcc5095b2c75f5215a
+  data.tar.gz: a2f01799b411e938aa8a79d6259353460e6d1180c3c5a86d42cb790cbc457620
 SHA512:
-  metadata.gz: 716aa6fed3746fb60b25ec359eccfe282814ee86d3207e4bbac2001099a1f54bf61b552622e91c88046abb275b4b9c4495360e9e950c914fb55e7141625ef475
-  data.tar.gz: e4669b5032d78f2b3583cee3895c99c61cdb020459853bd281e9e9f6f82d6dc7395eb8a24a6de67850545a70403dc500ccfcdc691f5a5479d8d81d16f40756d6
+  metadata.gz: b0718456b5e41a09fefffef2818a57d3b247f59043804877cfe115681a53da70a2d7682a8a7b5808740c24728b85e51f4fac95fb2035c6dd2411525a34edaabb
+  data.tar.gz: b46f4a7c41e0e926ac4a20e9f494fe79dc231f97e87c52780996fb192cc015c585dfb7f14c67ce22eb080b7ee854fb3c9303db72e937a9e4b087c25b18e87217

data/README.md

@@ -2,6 +2,12 @@
 
 This Gem helps to transfer the defaults from the database schema to the rails validations. To do this, it uses the information in schema.rb and transfers it to a concern file. This file should be included in the version control.
 
+## Requirements
+
+* Ruby 3.2 or newer
+* Rails 7.2 to 8.1
+* `db/schema.rb` as schema format (`structure.sql` is not supported)
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -45,7 +51,7 @@ class User < ApplicationRecord
 
   enum :actived, no: 0, yes: 1
 
-  validate :email_address, email_format: true
+  validates :email_address, email_format: true
 
   schema_validations # to use auto generated validations
 
@@ -90,21 +96,37 @@ It is hardcoded, that this will only run on development environment.
 ```ruby
 t.text :stuff, null: false
 # results in
-validate :stuff, presence: true
+validates :stuff, presence: true
 
 t.string :stuff, limit: 10
 # results in
-validate :stuff, length: { maximum: 10 }
+validates :stuff, length: { maximum: 10, allow_nil: true }
 
 t.integer :stuff
 # results in
-validate :stuff, numericality: true
+validates :stuff, numericality: { only_integer: true, greater_than_or_equal_to: -2147483648, less_than: 2147483648, allow_nil: true }
 ```
 
 You can watch changes on `schema_validations.rb` to understand the generated validations.
 
 ## Changelog
 
+### 0.7.0
+
+* requires Ruby 3.2 and Rails 7.2 or newer
+* supports all PostgreSQL column types of Rails (e.g. `citext`, `money`, `bit`, `enum`, `hstore`, ranges and geometric types)
+* `enum` columns are validated to contain a value of the PostgreSQL enum type
+* `serial` and `bigserial` columns are not validated for presence, because the database sets them
+* unique constraints are validated like unique indexes
+* not null `json`, `jsonb`, `hstore` and array columns accept empty values (`{}` or `[]`)
+* the generated file contains only the validator classes used by the tables
+* `bigint` columns and `integer` columns with `limit` get a range validation
+* the generated file is the same on all Ruby versions (`Hash#inspect` changed with Ruby 3.4)
+* abstract classes do not need `schema_validations` anymore
+* ignore `virtual` columns, check and exclusion constraints
+* skip generating if the schema format is not ruby
+* adds tests
+
 ### 0.6.1
 
 * adds support for Rails 8.1 (integer range validations no longer use the private `ActiveRecord::Type::Integer#range`, which was removed in Rails 8.1)
@@ -190,6 +212,16 @@ require 'generated_schema_validations/capistrano_tasks'
 
 * Add column type `binary`
 
+## Development
+
+The specs run with SQLite. Set `DATABASE_URL` to run the PostgreSQL specs too:
+
+    $ DATABASE_URL=postgres://user:password@localhost/generated_schema_validations_test bundle exec rspec
+
+Other Rails versions are tested with the gemfiles in `gemfiles/`:
+
+    $ BUNDLE_GEMFILE=gemfiles/rails_7.2.gemfile bundle exec rspec
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/Lichtbit/generated_schema_validations.

data/lib/generated_schema_validations/capistrano_tasks.rb

@@ -19,11 +19,13 @@ namespace :generated_schema_validations do
         with(
           rails_env: fetch(:rails_env),
           rails_groups: fetch(:rails_assets_groups),
-          disable_database_environment_check: 1
+          disable_database_environment_check: 1,
         ) do
           dump_output = capture(:rake, 'db:validation_dump_direct').strip
 
-          if dump_output != local_content
+          if dump_output == local_content
+            info '✔ Schema OK'
+          else
             warn '❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌'
             warn 'The online version of the automatically generated validations differs from the local version.'
             warn 'Please check immediately.'
@@ -41,7 +43,7 @@ namespace :generated_schema_validations do
                 diffs.each do |piece|
                   hunk = Diff::LCS::Hunk.new(
                     old_lines, new_lines, piece,
-                    3,  # context lines
+                    3, # context lines
                     file_length_difference
                   )
 
@@ -54,8 +56,6 @@ namespace :generated_schema_validations do
               end
             end
             warn '❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌❌'
-          else
-            info '✔ Schema OK'
           end
         end
       end

data/lib/generated_schema_validations/dump_checker.rb

@@ -1,23 +1,12 @@
 # frozen_string_literal: true
 
+require 'stringio'
+
 class GeneratedSchemaValidations::DumpChecker < GeneratedSchemaValidations::Dumper
   def self.read_schema_content
     stream = StringIO.new
-
-    if ActiveRecord::VERSION::STRING >= "7.2"
-      ActiveRecord::SchemaDumper.dump(
-        ActiveRecord::Base.connection_pool,
-        stream
-      )
-    else
-      ActiveRecord::SchemaDumper.dump(
-        ActiveRecord::Base.connection,
-        stream
-      )
-    end
-
-    stream.rewind
-    stream.read
+    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection_pool, stream)
+    stream.string
   end
 
   def write_schema_validations(template_ruby)

data/lib/generated_schema_validations/dumper.rb

@@ -1,11 +1,16 @@
 # frozen_string_literal: true
 
+require 'tempfile'
+
 class GeneratedSchemaValidations::Dumper
+  # Validators from validators/, added to the generated file only if a table uses them
+  VALIDATORS = %i[date_time_in_db_range date_in_db_range time_in_db_range not_null].freeze
+
   def self.generate
     file = Tempfile.new(['schema', '.rb'])
     begin
-      schema_content = read_schema_content.gsub(/ActiveRecord::Schema(\[[^\]]+\])?/, self.name)
-      raise 'The scheme is not well-formed.' if schema_content.include?('ActiveRecord')
+      schema_content = read_schema_content.gsub(/ActiveRecord::Schema(\[[^\]]+\])?/, name)
+      raise 'The schema is not well-formed.' if schema_content.include?('ActiveRecord')
 
       file.write(schema_content)
       file.close
@@ -20,20 +25,21 @@ class GeneratedSchemaValidations::Dumper
     File.read(Rails.root.join('db/schema.rb'))
   end
 
-  def self.define(info = {}, &block)
-    new.define(info, &block)
+  def self.define(info = {}, &)
+    new.define(info, &)
   end
 
-  def define(info, &block)
-    instance_eval(&block)
+  def define(info, &)
+    instance_eval(&)
 
     template_ruby = File.read(File.expand_path('template.rb', File.dirname(__FILE__)))
     template_ruby.gsub!('VERSION_INFO', info[:version].to_s)
     indention_spaces = template_ruby.match(/( +)TABLE_VALIDATIONS/)[1]
-    table_validations_ruby = @table_validations_ruby.lines.map do |line|
+    table_validations_ruby = @table_validations_ruby.to_s.lines.map do |line|
       line.strip.present? ? "#{indention_spaces}#{line}" : "\n"
-    end.join
+    end.join.delete_prefix("\n").chomp
     template_ruby.gsub!("#{indention_spaces}TABLE_VALIDATIONS", table_validations_ruby)
+    template_ruby.sub!("\n\n  VALIDATOR_CLASSES", validator_classes_ruby)
 
     write_schema_validations(template_ruby)
   end
@@ -44,12 +50,30 @@ class GeneratedSchemaValidations::Dumper
     File.write(Rails.root.join('app/models/concerns/schema_validations.rb'), template_ruby)
   end
 
-  def create_table(table_name, *, &block)
+  def create_table(table_name, *, &)
+    table = GeneratedSchemaValidations::Table.new(table_name, enum_types: @enum_types || {}, &)
+    @used_validators = (@used_validators || []) | table.validators
     @table_validations_ruby ||= ''
-    @table_validations_ruby += GeneratedSchemaValidations::Table.new(table_name, &block).to_s
+    @table_validations_ruby += table.to_s
+  end
+
+  def create_enum(name, values)
+    @enum_types ||= {}
+    @enum_types[name.to_s] = values
   end
 
   def do_nothing(*); end
   alias enable_extension do_nothing
+  alias create_schema do_nothing
   alias add_foreign_key do_nothing
+
+  private
+
+  def validator_classes_ruby
+    (VALIDATORS & @used_validators.to_a).map do |validator|
+      ruby = File.read(File.expand_path("validators/#{validator}_validator.rb", __dir__))
+      ruby = ruby.delete_prefix("# frozen_string_literal: true\n\n")
+      "\n\n#{ruby.lines.map { |line| line.strip.present? ? "  #{line}" : line }.join.chomp}"
+    end.join
+  end
 end

data/lib/generated_schema_validations/table.rb

@@ -1,29 +1,41 @@
 # frozen_string_literal: true
 
 class GeneratedSchemaValidations::Table
+  # Hash#inspect changed with Ruby 3.4. Use its new style on all versions to get the same file everywhere.
+  def self.inspect_value(value)
+    return value.inspect unless value.is_a?(Hash)
+
+    "{#{value.map { |key, v| "#{key}: #{inspect_value(v)}" }.join(', ')}}"
+  end
+
   Validation = Struct.new(:attribute, :validator, :options) do
     def to_s
-      "validates_with_filter #{attribute.to_sym.inspect}, #{{ validator => options }.inspect}"
+      "validates_with_filter #{attribute.to_sym.inspect}, " \
+        "#{GeneratedSchemaValidations::Table.inspect_value(validator => options)}"
     end
   end
 
   ValidationWithoutEnum = Struct.new(:attribute, :validator, :options) do
     def to_s
-      "validates_with_filter #{attribute.to_sym.inspect}, #{{ validator => options }.inspect} unless enums.include?(#{attribute.to_sym.inspect})"
+      "#{Validation.new(attribute, validator, options)} unless enums.include?(#{attribute.to_sym.inspect})"
     end
   end
 
+  # Valid values of these types can be blank, e.g. an empty hash or an empty bit string.
+  BLANK_VALUE_TYPES = %i[json jsonb hstore bit_varying ltree tsvector].freeze
+
   attr_reader :table_name
 
-  def initialize(table_name, &block)
+  def initialize(table_name, enum_types: {}, &)
     @table_name = table_name
+    @enum_types = enum_types
     @column_names = []
     @possible_belongs_to_not_null_columns = []
     @bad_indexes = []
     @unique_indexes = []
     @validations = []
 
-    instance_eval(&block)
+    instance_eval(&)
   end
 
   def to_s
@@ -45,6 +57,10 @@ class GeneratedSchemaValidations::Table
     "#{string}end\n"
   end
 
+  def validators
+    @validations.map(&:validator).uniq
+  end
+
   def validates(attribute, validator, options = {})
     @validations.push(Validation.new(attribute, validator, options))
   end
@@ -61,8 +77,8 @@ class GeneratedSchemaValidations::Table
     @possible_belongs_to_not_null_columns.push(name.to_sym) if datatype.in?(%i[bigint integer uuid])
     if datatype == :boolean
       validates name, :inclusion, in: [true, false], message: :blank
-    elsif datatype.in?(%i[json jsonb])
-      validates name, :exclusion, in: [nil], message: :blank
+    elsif datatype.in?(BLANK_VALUE_TYPES) || column_options[:array]
+      validates name, :not_null
     else
       validates name, :presence
     end
@@ -74,27 +90,48 @@ class GeneratedSchemaValidations::Table
 
   def bigint(name, column_options = {})
     null_validation(:bigint, name, column_options)
-
-    validates_without_enum name, :numericality, allow_nil: true
+    integer_range_validation(name, column_options, default_limit: 8)
   end
 
   def integer(name, column_options = {})
     null_validation(:integer, name, column_options)
+    integer_range_validation(name, column_options, default_limit: ::ActiveRecord::Type::Integer::DEFAULT_LIMIT)
+  end
+
+  def serial(name, column_options = {})
+    # The database sets the value on insert, so it is nil before.
+    null_validation(:serial, name, column_options.except(:null))
+    integer_range_validation(name, column_options, default_limit: 4)
+  end
+
+  def bigserial(name, column_options = {})
+    null_validation(:bigserial, name, column_options.except(:null))
+    integer_range_validation(name, column_options, default_limit: 8)
+  end
 
+  def oid(name, column_options = {})
+    null_validation(:oid, name, column_options)
     return if column_options[:array]
 
-    # Same bounds as ActiveModel::Type::Integer (min...max), computed here because
-    # Rails 8.1 removed the private #range method this used to call.
-    max_value = 1 << ((::ActiveRecord::Type::Integer::DEFAULT_LIMIT * 8) - 1)
-    options = { allow_nil: true, only_integer: true, greater_than_or_equal_to: -max_value, less_than: max_value }
+    validates name, :numericality, allow_nil: true, only_integer: true,
+                                   greater_than_or_equal_to: 0, less_than: 1 << 32
+  end
 
-    validates_without_enum name, :numericality, options
+  def money(name, column_options = {})
+    null_validation(:money, name, column_options)
+    return if column_options[:array]
+
+    # PostgreSQL stores money as 64 bit integer of the smallest currency unit
+    limit = (1 << 63) / (10**(column_options[:scale] || 2))
+    validates name, :numericality, allow_nil: true, greater_than_or_equal_to: -limit, less_than_or_equal_to: limit
   end
 
   def datetime(name, column_options = {})
     null_validation(:datetime, name, column_options)
     validates name, :date_time_in_db_range
   end
+  alias timestamp datetime
+  alias timestamptz datetime
 
   def date(name, column_options = {})
     null_validation(:date, name, column_options)
@@ -153,6 +190,42 @@ class GeneratedSchemaValidations::Table
 
     validates name, :length, allow_nil: true, maximum: column_options[:limit]
   end
+  alias citext text
+
+  def bit(name, column_options = {})
+    null_validation(:bit, name, column_options)
+    return if column_options[:array]
+
+    validates name, :format, allow_nil: true, with: /\A[01]*\z/
+    validates name, :length, allow_nil: true, is: column_options[:limit] || 1
+  end
+
+  def bit_varying(name, column_options = {})
+    null_validation(:bit_varying, name, column_options)
+    return if column_options[:array]
+
+    validates name, :format, allow_nil: true, with: /\A[01]*\z/
+    validates name, :length, allow_nil: true, maximum: column_options[:limit] if column_options[:limit]
+  end
+
+  def enum(name, column_options = {})
+    null_validation(:enum, name, column_options)
+    return if column_options[:array]
+
+    values = @enum_types[column_options[:enum_type].to_s]
+    validates_without_enum name, :inclusion, allow_nil: true, in: values if values
+  end
+
+  # Columns without own validations. The database checks the format, the not null constraint is validated.
+  %i[
+    daterange numrange tsrange tstzrange int4range int8range
+    hstore inet cidr macaddr ltree tsvector interval
+    point line lseg box path polygon circle
+  ].each do |datatype|
+    define_method(datatype) do |name, column_options = {}|
+      null_validation(datatype, name, column_options)
+    end
+  end
 
   def index(names, index_options = {})
     names = [names] unless names.is_a?(Array)
@@ -166,7 +239,29 @@ class GeneratedSchemaValidations::Table
     end
   end
 
+  def unique_constraint(names, _constraint_options = {})
+    index(names, unique: true)
+  end
+
   def geography(*)
     # do nothing
   end
+
+  def do_nothing(*); end
+  alias virtual do_nothing # generated columns can not be written
+  alias check_constraint do_nothing
+  alias exclusion_constraint do_nothing
+
+  private
+
+  def integer_range_validation(name, column_options, default_limit:)
+    return if column_options[:array]
+
+    # Same bounds as ActiveModel::Type::Integer (min...max), computed here because
+    # Rails 8.1 removed the private #range method this used to call.
+    max_value = 1 << (((column_options[:limit] || default_limit) * 8) - 1)
+    options = { allow_nil: true, only_integer: true, greater_than_or_equal_to: -max_value, less_than: max_value }
+
+    validates_without_enum name, :numericality, options
+  end
 end

data/lib/generated_schema_validations/tasks.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
 Rake::Task['db:schema:dump'].enhance do
+  # The validations are generated from db/schema.rb, so there is nothing to do with structure.sql.
+  next unless (ENV['SCHEMA_FORMAT'] || ActiveRecord.schema_format).to_s == 'ruby'
+
   require 'generated_schema_validations'
   require_relative 'dumper'
   require_relative 'table'

data/lib/generated_schema_validations/template.rb

@@ -26,9 +26,10 @@ module SchemaValidations
     if defined?(Rails::Railtie) && (Rails.env.development? || Rails.env.test?)
       TracePoint.trace(:end) do |t|
         if t.self.respond_to?(:schema_validations_called) &&
-            t.self < ApplicationRecord &&
-            !t.self.schema_validations_called &&
-            !SchemaValidations.relaxed?
+           t.self < ApplicationRecord &&
+           !t.self.abstract_class? &&
+           !t.self.schema_validations_called &&
+           !SchemaValidations.relaxed?
           raise "#{t.self}: schema_validations or skip_schema_validations missing"
         end
       end
@@ -73,7 +74,7 @@ module SchemaValidations
         names.each do |name|
           next if name.to_sym.in?(schema_validations_excluded_columns)
           next unless defined?(Rails::Railtie)
-          next unless (Rails.env.development? || Rails.env.test?)
+          next unless Rails.env.development? || Rails.env.test?
 
           raise "Unique index with where clause is outside the scope of this gem.\n\n" \
                 "You can exclude this column: `schema_validations exclude: [:#{name}]`"
@@ -117,39 +118,5 @@ module SchemaValidations
     end
   end
 
-  class DateTimeInDbRangeValidator < ActiveModel::EachValidator
-    def validate_each(record, attr_name, value)
-      return if value.nil?
-      return unless value.is_a?(DateTime) || value.is_a?(Time)
-      return if value.year.between?(-4711, 294_275) # see https://www.postgresql.org/docs/9.3/datatype-datetime.html
-
-      record.errors.add(attr_name, :invalid)
-    end
-  end
-
-  class DateInDbRangeValidator < ActiveModel::EachValidator
-    def validate_each(record, attr_name, value)
-      return if value.nil?
-      return unless value.is_a?(Date)
-      return if value.year.between?(-4711, 5_874_896) # see https://www.postgresql.org/docs/9.3/datatype-datetime.html
-
-      record.errors.add(attr_name, :invalid)
-    end
-  end
-
-  class TimeInDbRangeValidator < ActiveModel::EachValidator
-    def validate_each(record, attr_name, value)
-      return if value.nil?
-
-      unless value.is_a?(Time) || value.is_a?(ActiveSupport::TimeWithZone)
-        record.errors.add(attr_name, :invalid)
-        return
-      end
-
-      # PostgreSQL allows only times in one day
-      return if value.to_date == Date.new(2000, 1, 1)
-
-      record.errors.add(attr_name, :invalid)
-    end
-  end
+  VALIDATOR_CLASSES
 end

data/lib/generated_schema_validations/validators/date_in_db_range_validator.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class DateInDbRangeValidator < ActiveModel::EachValidator
+  def validate_each(record, attr_name, value)
+    return if value.nil?
+    return unless value.is_a?(Date)
+    return if value.year.between?(-4711, 5_874_896) # see https://www.postgresql.org/docs/9.3/datatype-datetime.html
+
+    record.errors.add(attr_name, :invalid)
+  end
+end

data/lib/generated_schema_validations/validators/date_time_in_db_range_validator.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class DateTimeInDbRangeValidator < ActiveModel::EachValidator
+  def validate_each(record, attr_name, value)
+    return if value.nil?
+    return unless value.is_a?(DateTime) || value.is_a?(Time)
+    return if value.year.between?(-4711, 294_275) # see https://www.postgresql.org/docs/9.3/datatype-datetime.html
+
+    record.errors.add(attr_name, :invalid)
+  end
+end

data/lib/generated_schema_validations/validators/not_null_validator.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Like presence, but accepts blank values like an empty hash or array
+class NotNullValidator < ActiveModel::EachValidator
+  def validate_each(record, attr_name, value)
+    record.errors.add(attr_name, :blank) if value.nil?
+  end
+end

data/lib/generated_schema_validations/validators/time_in_db_range_validator.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class TimeInDbRangeValidator < ActiveModel::EachValidator
+  def validate_each(record, attr_name, value)
+    return if value.nil?
+
+    unless value.is_a?(Time) || value.is_a?(ActiveSupport::TimeWithZone)
+      record.errors.add(attr_name, :invalid)
+      return
+    end
+
+    # PostgreSQL allows only times in one day
+    return if value.to_date == Date.new(2000, 1, 1)
+
+    record.errors.add(attr_name, :invalid)
+  end
+end

metadata

@@ -1,31 +1,65 @@
 --- !ruby/object:Gem::Specification
 name: generated_schema_validations
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.7.0
 platform: ruby
 authors:
 - Georg Limbach
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-17 00:00:00.000000000 Z
-dependencies: []
+date: 2026-10-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
 description: After each migration it generates a file with some validations. Each
-  active record should include this file and can uns generated validations.
+  active record should include this file and can use the generated validations.
 email:
 - georg.limbach@lichtbit.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".rspec"
-- Gemfile
-- Gemfile.lock
 - LICENSE.txt
 - README.md
-- Rakefile
-- generated_schema_validations.gemspec
 - lib/generated_schema_validations.rb
 - lib/generated_schema_validations/capistrano_tasks.rb
 - lib/generated_schema_validations/dump_checker.rb
@@ -34,12 +68,17 @@ files:
 - lib/generated_schema_validations/table.rb
 - lib/generated_schema_validations/tasks.rb
 - lib/generated_schema_validations/template.rb
+- lib/generated_schema_validations/validators/date_in_db_range_validator.rb
+- lib/generated_schema_validations/validators/date_time_in_db_range_validator.rb
+- lib/generated_schema_validations/validators/not_null_validator.rb
+- lib/generated_schema_validations/validators/time_in_db_range_validator.rb
 homepage: https://github.com/Lichtbit/generated_schema_validations
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/Lichtbit/generated_schema_validations
   source_code_uri: https://github.com/Lichtbit/generated_schema_validations
+  changelog_uri: https://github.com/Lichtbit/generated_schema_validations#changelog
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -48,7 +87,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/.gitignore

@@ -1,12 +0,0 @@
-/.bundle/
-/.yardoc
-/_yardoc/
-/coverage/
-/doc/
-/pkg/
-/spec/reports/
-/tmp/
-
-# rspec failure tracking
-.rspec_status
-generated_schema_validations-*.gem

data/.rspec

@@ -1,3 +0,0 @@
---format documentation
---color
---require spec_helper

data/Gemfile

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in generated_schema_validations.gemspec
-gemspec
-
-gem 'rake', '~> 12.0'
-gem 'rspec', '~> 3.0'

data/Gemfile.lock

@@ -1,34 +0,0 @@
-PATH
-  remote: .
-  specs:
-    generated_schema_validations (0.2.0)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    diff-lcs (1.4.4)
-    rake (12.3.3)
-    rspec (3.10.0)
-      rspec-core (~> 3.10.0)
-      rspec-expectations (~> 3.10.0)
-      rspec-mocks (~> 3.10.0)
-    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-support (3.10.3)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  generated_schema_validations!
-  rake (~> 12.0)
-  rspec (~> 3.0)
-
-BUNDLED WITH
-   2.1.4

data/Rakefile

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-require 'bundler/gem_tasks'
-require 'rspec/core/rake_task'
-
-RSpec::Core::RakeTask.new(:spec)
-
-task default: :spec

data/generated_schema_validations.gemspec

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-Gem::Specification.new do |spec|
-  spec.name          = 'generated_schema_validations'
-  spec.version       = '0.6.1'
-  spec.authors       = ['Georg Limbach']
-  spec.email         = ['georg.limbach@lichtbit.com']
-
-  spec.summary       = 'Generate rails validations from schema.rb file'
-  spec.description   = 'After each migration it generates a file with some validations. Each active record should ' \
-                       'include this file and can uns generated validations.'
-  spec.homepage      = 'https://github.com/Lichtbit/generated_schema_validations'
-  spec.license       = 'MIT'
-  spec.required_ruby_version = Gem::Requirement.new('>= 2.3.0')
-
-  spec.metadata['homepage_uri'] = spec.homepage
-  spec.metadata['source_code_uri'] = 'https://github.com/Lichtbit/generated_schema_validations'
-
-  # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files = Dir.chdir(File.expand_path(__dir__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  end
-  spec.require_paths = ['lib']
-end