validates_lengths_from_database 0.8.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8969981a23f54edfe7d597ad648c841c7beb9e7e296bb1bd050ca30b50ae18e
-  data.tar.gz: 55e92318175af1685a1665d9cb30c456a62b93701ee6e9e358a85f5b4159908c
+  metadata.gz: 5cf4553c64ac4dd1b06fce9e8b6123f3bb426a7a83d0e8ee4949db2ae530aa76
+  data.tar.gz: b714ddd62d656a23029b181448e7d6881542c3da7b3b1988ff63e4153b7e43dc
 SHA512:
-  metadata.gz: b4584e27e3758ceabeecf85f56263b0579be4ea190ecfe730cfe3aca2fac0e17208ad52fdbaf3afdd4dcd6aa0afa239bc496146f2c55784c003af83205f081eb
-  data.tar.gz: 6bb72ca778ab3aaae981f03bbf9e8bf9e73dacca4b96dd6dd30252d2bcd8a7a2fe53f080f0dc0d37732fde0eca80827355fe83aba4af67d941c39c0386a173cf
+  metadata.gz: 381df3fa482b0f1d882ac8d81b35282db35a8d66cfe523c9f9f6a9ebbb6234d2319a1fa3264f06bc36e2c5fafc3e022dce53091350fff5bfa231e73d440da9e5
+  data.tar.gz: 896b9a14a0104a7723a7bc026d3fc5479ca8c0d5128a6107064ec08314bc08c60485c5bac8b2e334cb4dae10ac0fe3b96391732c877bb6e1cfae9535b8111f26

data/CHANGELOG.md

@@ -0,0 +1,50 @@
+# Changelog
+
+## v1.0.0 (2026-10-14)
+
+- Require Rails (ActiveRecord) 6.1+ and Ruby 2.7+. Apps on older versions can stay on 0.8.x.
+- Tested against Rails 6.1 through 8.1 on SQLite, PostgreSQL and MySQL.
+- The "too long (bytes)" error for TEXT columns can now be translated with the `too_long_bytes` key (#42) - thanks @Bhalani
+- Validate the lower bound of DECIMAL columns, so -1000 is rejected for DECIMAL(5,2)
+- No longer modify the options hash passed to `validates_lengths_from_database`
+- Accept string keys in the `:limit` hash
+
+## v0.8.0 (2019-10-30)
+
+- Enforce validation length on TEXT columns via bytes instead of characters (#25)
+- Drop support for ruby 1.9 (#26)
+
+## v0.7.0 (2017-10-09)
+
+- Drop hard reliance on rails (can use with just activerecord) - thanks @grosser
+- Drop requiring of rubygems (unnecessary) - thanks @grosser
+- Update dependencies to modern, build-able versions
+
+## v0.6.0 (2017-05-02)
+
+- Drop support for integer length validations (too many issues)
+
+## v0.5.2 (2017-04-28)
+
+- Fix handling with STI models - thanks @iNecas
+
+## v0.5.1 (2017-04-27)
+
+- Fix sharing options between models - thanks @iNecas
+
+## v0.5.0 (2016-01-28)
+
+- Drop support for rails 2
+- Implement lazy-evaluation of column information for better compatibility with early load orders - thanks @domcleal.
+
+## v0.4.0 (2015-01-03)
+
+- Drop support for ruby 1.8.7 and 1.9.2 - too many issues with backwards-compatibility
+
+## v0.3.0 (2015-01-03)
+
+- Explicit support for Rails 4.1 and 4.2
+- Up-to-date Appraisals and dependencies
+- Better support for postgres text columns via conditional length validation
+- Bug fix for postgres array column types
+

data/README.md

@@ -0,0 +1,127 @@
+# Validates Lengths from Database
+
+[![CI](https://github.com/eigenben/validates_lengths_from_database/actions/workflows/ci.yml/badge.svg)](https://github.com/eigenben/validates_lengths_from_database/actions/workflows/ci.yml)
+[![Gem Version](https://badge.fury.io/rb/validates_lengths_from_database.svg)](https://rubygems.org/gems/validates_lengths_from_database)
+
+Few people add length validations to fields in their database, and when saving such fields that have exhausted their length, an SQL error occurs.
+This gem introspects your table schema for maximum lengths on string and text fields and automatically adds length validations to the model.
+
+## Requirements
+
+* Ruby 2.7 or newer
+* ActiveRecord 6.1 or newer
+
+For older versions of Rails or Ruby, use the 0.8.x releases.
+
+## Installation
+
+Include the gem using bundler in your Gemfile:
+
+```ruby
+gem "validates_lengths_from_database"
+```
+
+## Usage
+
+In your model you can activate validations:
+
+```ruby
+class Post < ActiveRecord::Base
+  validates_lengths_from_database
+end
+```
+
+It also supports filter-style `:only` and `:except` options:
+
+```ruby
+class Post < ActiveRecord::Base
+  validates_lengths_from_database only: [:title, :contents]
+end
+
+class Post < ActiveRecord::Base
+  validates_lengths_from_database except: [:other_field]
+end
+```
+
+If you'd rather specify the limits explicitly instead of pulling them from the database, you can set it:
+
+```ruby
+class Post < ActiveRecord::Base
+  validates_lengths_from_database limit: 255
+end
+```
+
+Or to set the limit differently for string (`VARCHAR`) and `TEXT` columns:
+
+```ruby
+class Post < ActiveRecord::Base
+  validates_lengths_from_database limit: { string: 255, text: 4092 }
+end
+```
+
+You can use `validates_lengths_from_database` on an abstract parent (without a table), such as `ApplicationRecord` or `ActiveRecord::Base`:
+
+```ruby
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+  validates_lengths_from_database limit: 255
+end
+
+# This will use the validations with default options (from parent)
+class Post < ApplicationRecord
+end
+
+# This will use the validations, with overriding the default options (the limit will not be applied)
+class User < ApplicationRecord
+  validates_lengths_from_database only: [:name]
+end
+
+# This will use the validations, using the default options + adding some class specific customizations
+class Comment < ApplicationRecord
+  validate_lengths_from_database_options[:only] << :name
+end
+```
+
+## What gets validated
+
+* **String (`VARCHAR`) columns** are limited to the column's length in characters.
+* **`TEXT` columns** are limited to the column's length in bytes, since that is how MySQL measures them.
+* **`DECIMAL` columns** with a precision and scale must fit within them. For example, `DECIMAL(5,2)` accepts -999.99 through 999.99.
+
+Columns without a limit are skipped, so what this gem does depends on your database:
+
+* **MySQL**: `t.string` columns are `VARCHAR(255)` and `t.text` columns are `TEXT` (65,535 bytes) unless you say otherwise. This is where the gem helps most, turning `ActiveRecord::ValueTooLong` exceptions into validation errors.
+* **PostgreSQL**: Rails creates `t.string` columns with no length limit, and `TEXT` columns never have one, so only columns declared with an explicit `limit:` are validated.
+* **SQLite**: limits declared in migrations are validated, even though SQLite itself does not enforce them.
+
+## Translating the bytes error message
+
+`TEXT` columns that are too long get the `too_long_bytes` error, which defaults to "is too long (maximum is %{count} bytes)".
+Override it in your locale files like any other ActiveModel error message:
+
+```yaml
+en:
+  errors:
+    messages:
+      too_long_bytes:
+        one: "is too long (maximum is 1 byte)"
+        other: "is too long (maximum is %{count} bytes)"
+```
+
+## Running Tests
+
+The specs run against SQLite by default:
+
+```
+bundle install
+bundle exec rspec
+```
+
+Set `DB=postgresql` or `DB=mysql` to test against those databases instead. Both expect a database named `validates_lengths_from_database_test`, and connection settings can be changed with environment variables (see `spec/db/database.yml`).
+
+To test against a specific Rails version, use one of the gemfiles in `gemfiles/`:
+
+```
+BUNDLE_GEMFILE=gemfiles/rails_7.0.gemfile bundle install
+BUNDLE_GEMFILE=gemfiles/rails_7.0.gemfile bundle exec rspec
+```

data/config/locales/en.yml

@@ -0,0 +1,6 @@
+en:
+  errors:
+    messages:
+      too_long_bytes:
+        one: "is too long (maximum is 1 byte)"
+        other: "is too long (maximum is %{count} bytes)"

data/lib/validates_lengths_from_database/core.rb

@@ -1,8 +1,5 @@
 module ValidatesLengthsFromDatabase
-  def self.included(base)
-    base.send(:extend, ClassMethods)
-    base.send(:include, InstanceMethods)
-  end
+  extend ActiveSupport::Concern
 
   class BytesizeValidator < ActiveModel::Validations::LengthValidator
     def validate_each(record, attribute, value)
@@ -14,15 +11,16 @@ module ValidatesLengthsFromDatabase
 
   module ClassMethods
     def validates_lengths_from_database(options = {})
-      options.symbolize_keys!
+      # Copy everything we keep so later changes to the stored options
+      # (see README) never leak back into the caller's hash or arrays.
+      options = options.symbolize_keys
 
-      options[:only]    = Array[options[:only]]   if options[:only] && !options[:only].is_a?(Array)
-      options[:except]  = Array[options[:except]] if options[:except] && !options[:except].is_a?(Array)
-      options[:limit] ||= {}
+      options[:only]   = Array(options[:only]).dup   if options[:only]
+      options[:except] = Array(options[:except]).dup if options[:except]
+
+      limit = options[:limit] || {}
+      options[:limit] = limit.is_a?(Hash) ? limit.symbolize_keys : {:string => limit, :text => limit}
 
-      if options[:limit] and !options[:limit].is_a?(Hash)
-        options[:limit] = {:string => options[:limit], :text => options[:limit], :decimal => options[:limit], :integer => options[:limit], :float => options[:limit]}
-      end
       @validate_lengths_from_database_options = options
 
       validate :validate_lengths_from_database
@@ -44,80 +42,67 @@ module ValidatesLengthsFromDatabase
     end
   end
 
-  module InstanceMethods
-    def validate_lengths_from_database
-      options = self.class.validate_lengths_from_database_options
+  def validate_lengths_from_database
+    options = self.class.validate_lengths_from_database_options
 
-      if options[:only]
-        columns_to_validate = options[:only].map(&:to_s)
-      else
-        columns_to_validate = self.class.column_names.map(&:to_s)
-        columns_to_validate -= options[:except].map(&:to_s) if options[:except]
-      end
+    if options[:only]
+      columns_to_validate = options[:only].map(&:to_s)
+    else
+      columns_to_validate = self.class.column_names.map(&:to_s)
+      columns_to_validate -= options[:except].map(&:to_s) if options[:except]
+    end
+
+    columns_to_validate.each do |column|
+      column_schema = self.class.columns_hash[column]
 
-      columns_to_validate.each do |column|
-        column_schema = self.class.columns.find {|c| c.name == column }
-
-        next if column_schema.nil?
-        next if column_schema.respond_to?(:array) && column_schema.array
-        next unless [:string, :text, :decimal].include?(column_schema.type)
-
-        case column_schema.type
-        when :string
-          if column_limit = options[:limit][column_schema.type] || column_schema.limit
-            validate_length_by_characters(column, column_limit)
-          end
-        when :text
-          if column_limit = options[:limit][column_schema.type] || column_schema.limit
-            validate_length_by_bytesize(column, column_limit)
-          end
-        when :decimal
-          if column_schema.precision && column_schema.scale
-            validate_numericality_with_precision(column, column_schema)
-          end
+      next if column_schema.nil?
+      next if column_schema.respond_to?(:array) && column_schema.array
+      next unless [:string, :text, :decimal].include?(column_schema.type)
+
+      case column_schema.type
+      when :string
+        if column_limit = options[:limit][column_schema.type] || column_schema.limit
+          validate_length_by_characters(column, column_limit)
+        end
+      when :text
+        if column_limit = options[:limit][column_schema.type] || column_schema.limit
+          validate_length_by_bytesize(column, column_limit)
+        end
+      when :decimal
+        if column_schema.precision && column_schema.scale
+          validate_numericality_with_precision(column, column_schema)
         end
       end
     end
+  end
 
-    private
+  private
 
-    def validate_length_by_characters(column, column_limit)
-      ActiveModel::Validations::LengthValidator.new(
-        :allow_blank => true,
-        :attributes => [column],
-        :maximum => column_limit
-      ).validate(self)
-    end
-
-    def validate_length_by_bytesize(column, column_limit)
-      validator =
-        if ActiveModel::Validations::LengthValidator::RESERVED_OPTIONS.include?(:tokenizer)
-          ActiveModel::Validations::LengthValidator.new(
-            :allow_blank => true,
-            :attributes => [column],
-            :maximum => column_limit,
-            :tokenizer => ->(string) { string.bytes }
-          )
-        else
-          BytesizeValidator.new(
-            :allow_blank => true,
-            :attributes => [column],
-            :maximum => column_limit,
-            :too_long => "is too long (maximum is %{count} bytes)"
-          )
-        end
+  def validate_length_by_characters(column, column_limit)
+    ActiveModel::Validations::LengthValidator.new(
+      :allow_blank => true,
+      :attributes => [column],
+      :maximum => column_limit
+    ).validate(self)
+  end
 
-      validator.validate(self)
-    end
+  def validate_length_by_bytesize(column, column_limit)
+    BytesizeValidator.new(
+      :allow_blank => true,
+      :attributes => [column],
+      :maximum => column_limit,
+      :too_long => :too_long_bytes
+    ).validate(self)
+  end
 
-    def validate_numericality_with_precision(column, column_schema)
-      max_val = (10 ** column_schema.precision)/(10 ** column_schema.scale)
+  def validate_numericality_with_precision(column, column_schema)
+    max_val = (10 ** column_schema.precision)/(10 ** column_schema.scale)
 
-      ActiveModel::Validations::NumericalityValidator.new(
-        :allow_blank => true,
-        :attributes => [column],
-        :less_than => max_val
-      ).validate(self)
-    end
+    ActiveModel::Validations::NumericalityValidator.new(
+      :allow_blank => true,
+      :attributes => [column],
+      :less_than => max_val,
+      :greater_than => -max_val
+    ).validate(self)
   end
 end

data/lib/validates_lengths_from_database/railtie.rb

@@ -13,7 +13,7 @@ module ValidatesLengthsFromDatabase
 
   class Railtie
     def self.insert
-      ActiveRecord::Base.send(:include, ValidatesLengthsFromDatabase)
+      ActiveRecord::Base.include(ValidatesLengthsFromDatabase)
     end
   end
 end

data/lib/validates_lengths_from_database/version.rb

@@ -1,3 +1,3 @@
 module ValidatesLengthsFromDatabase
-  VERSION = "0.8.0"
+  VERSION = "1.0.0"
 end

data/lib/validates_lengths_from_database.rb

@@ -1,3 +1,7 @@
+require "active_support"
+require "active_support/i18n"
+
+I18n.load_path << File.expand_path("../config/locales/en.yml", __dir__)
 
 require "validates_lengths_from_database/core"
 require "validates_lengths_from_database/railtie"

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: validates_lengths_from_database
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Ben Hughes
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-30 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,169 +15,37 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4'
+        version: '6.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4'
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '4'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '4'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.0'
-- !ruby/object:Gem::Dependency
-  name: sqlite3
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.3.4
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.3.4
-- !ruby/object:Gem::Dependency
-  name: appraisal
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.0.2
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.0.2
-- !ruby/object:Gem::Dependency
-  name: pg
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.17.1
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.17.1
-- !ruby/object:Gem::Dependency
-  name: rdoc
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.12'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.12'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '11'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '11'
-- !ruby/object:Gem::Dependency
-  name: i18n
-  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'
-- !ruby/object:Gem::Dependency
-  name: iconv
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.0.4
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.0.4
+        version: '6.1'
 description: Introspects your database string field maximum lengths and automatically
   defines length validations.
-email: ben@railsgarden.com
+email: me@benhughes.name
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- Appraisals
-- CHANGELOG.rdoc
-- Gemfile
-- Gemfile.lock
+- CHANGELOG.md
 - LICENSE
-- README.rdoc
-- Rakefile
-- init.rb
+- README.md
+- config/locales/en.yml
 - lib/validates_lengths_from_database.rb
 - lib/validates_lengths_from_database/core.rb
 - lib/validates_lengths_from_database/railtie.rb
 - lib/validates_lengths_from_database/version.rb
-- rails/init.rb
-- spec/db/database.yml
-- spec/db/schema.rb
-- spec/db/test.sqlite3
-- spec/spec_helper.rb
-- spec/validates_lengths_from_database_spec.rb
-homepage: http://github.com/rubiety/validates_lengths_from_database
-licenses: []
-metadata: {}
-post_install_message: 
+homepage: https://github.com/eigenben/validates_lengths_from_database
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/eigenben/validates_lengths_from_database
+  changelog_uri: https://github.com/eigenben/validates_lengths_from_database/blob/master/CHANGELOG.md
+  bug_tracker_uri: https://github.com/eigenben/validates_lengths_from_database/issues
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -186,16 +53,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.4'
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.4
+      version: '0'
 requirements: []
-rubyforge_project: validates_lengths_from_database
-rubygems_version: 2.7.6
-signing_key: 
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Automatic maximum-length validations.
 test_files: []

data/Appraisals

@@ -1,11 +0,0 @@
-appraise "4.2" do
-  gem "rails", "~> 4.2"
-end
-
-appraise "5.1" do
-  gem "rails", "~> 5.1"
-end
-
-appraise "5.2" do
-  gem "rails", "~> 5.2"
-end

data/CHANGELOG.rdoc

@@ -1,39 +0,0 @@
-== v0.8.0 (2019-10-30)
-
-* Enforce validation length on TEXT columns via bytes instead of characters (#25)
-* Drop support for ruby 1.9 (#26)
-
-== v0.7.0 (2017-10-09)
-
-* Drop hard reliance on rails (can use with just activerecord) - thanks @grosser
-* Drop requiring of rubygems (unnecessary) - thanks @grosser
-* Update dependencies to modern, build-able versions
-
-== v0.6.0 (2017-05-02)
-
-* Drop support for integer length validations (too many issues)
-
-== v0.5.2 (2017-04-28)
-
-* Fix handling with STI models - thanks @iNecas
-
-== v0.5.1 (2017-04-27)
-
-* Fix sharing options between models - thanks @iNecas
-
-== v0.5.0 (2016-01-28)
-
-* Drop support for rails 2
-* Implement lazy-evaluation of column information for better compatibility with early load orders - thanks @domcleal.
-
-== v0.4.0 (2015-01-03)
-
-* Drop support for ruby 1.8.7 and 1.9.2 - too many issues with backwards-compatibility
-
-== v0.3.0 (2015-01-03)
-
-* Explicit support for Rails 4.1 and 4.2
-* Up-to-date Appraisals and dependencies
-* Better support for postgres text columns via conditional length validation
-* Bug fix for postgres array column types
-

data/Gemfile

@@ -1,4 +0,0 @@
-source "http://rubygems.org"
-
-# Specify your gem's dependencies in testgem.gemspec
-gemspec

data/Gemfile.lock

@@ -1,71 +0,0 @@
-PATH
-  remote: .
-  specs:
-    validates_lengths_from_database (0.7.0)
-      activerecord (>= 4)
-
-GEM
-  remote: http://rubygems.org/
-  specs:
-    activemodel (4.0.12)
-      activesupport (= 4.0.12)
-      builder (~> 3.1.0)
-    activerecord (4.0.12)
-      activemodel (= 4.0.12)
-      activerecord-deprecated_finders (~> 1.0.2)
-      activesupport (= 4.0.12)
-      arel (~> 4.0.0)
-    activerecord-deprecated_finders (1.0.4)
-    activesupport (4.0.12)
-      i18n (~> 0.6, >= 0.6.9)
-      minitest (~> 4.2)
-      multi_json (~> 1.3)
-      thread_safe (~> 0.1)
-      tzinfo (~> 0.3.37)
-    appraisal (1.0.2)
-      bundler
-      rake
-      thor (>= 0.14.0)
-    arel (4.0.2)
-    builder (3.1.4)
-    diff-lcs (1.1.2)
-    i18n (0.7.0)
-    iconv (1.0.4)
-    json (1.8.6)
-    minitest (4.7.5)
-    multi_json (1.10.1)
-    pg (0.17.1)
-    rake (0.9.2.2)
-    rdoc (3.12)
-      json (~> 1.4)
-    rspec (2.5.0)
-      rspec-core (~> 2.5.0)
-      rspec-expectations (~> 2.5.0)
-      rspec-mocks (~> 2.5.0)
-    rspec-core (2.5.1)
-    rspec-expectations (2.5.0)
-      diff-lcs (~> 1.1.2)
-    rspec-mocks (2.5.0)
-    sqlite3 (1.3.11)
-    thor (0.19.1)
-    thread_safe (0.3.4)
-    tzinfo (0.3.42)
-
-PLATFORMS
-  ruby
-  x86_64-darwin-18
-
-DEPENDENCIES
-  activesupport (>= 4)
-  appraisal (~> 1.0.2)
-  i18n
-  iconv (~> 1.0.4)
-  pg (~> 0.17.1)
-  rake (< 11)
-  rdoc (~> 3.12)
-  rspec (~> 2.0)
-  sqlite3 (~> 1.3.4)
-  validates_lengths_from_database!
-
-BUNDLED WITH
-   1.17.3

data/README.rdoc

@@ -1,83 +0,0 @@
-{<img src="https://secure.travis-ci.org/rubiety/validates_lengths_from_database.png?branch=master" alt="Build Status" />}[http://travis-ci.org/rubiety/validates_lengths_from_database]
-{<img src="https://gemnasium.com/rubiety/validates_lengths_from_database.png" alt="Dependency Status" />}[https://gemnasium.com/rubiety/validates_lengths_from_database]
-{<img src="https://codeclimate.com/github/rubiety/validates_lengths_from_database.png" />}[https://codeclimate.com/github/rubiety/validates_lengths_from_database]
-
-== Validates Lengths from Database
-
-Few people add length validations to fields in their database, and when saving such fields that have exhausted their length, an SQL error occurs.
-This gem introspects your table schema for maximum lengths on string and text fields and automatically adds length validations to the model.
-
-== Requirements
-
-Due to issues maintaining backwards compatibility, as of v0.8.0 validates_lengths_from_database requires ruby 2 or higher.
-If you are still using 1.9, please use the v0.7.0 release.
-
-== Installation
-
-Include the gem using bundler in your Gemfile:
-
-  gem "validates_lengths_from_database"
-
-== Usage
-
-In your model you can activate validations:
-
-  class Post < ActiveRecord::Base
-    validates_lengths_from_database
-  end
-
-It also supports filter-style :only and :except options:
-
-  class Post < ActiveRecord::Base
-    validates_lengths_from_database :only => [:title, :contents]
-  end
-
-  class Post < ActiveRecord::Base
-    validates_lengths_from_database :except => [:other_field]
-  end
-
-If you'd rather specify the limits explicitly instead of pulling them from the database, you can set it:
-
-  class Post < ActiveRecord::Base
-    validates_lengths_from_database :limit => 255
-  end
-
-Or to set the limit differently for string (VARCHAR) and (TEXT) columns:
-
-  class Post < ActiveRecord::Base
-    validates_lengths_from_database :limit => {:string => 255, :text => 4092}
-  end
-
-Since v0.5.2, it's possible to use the `validate_lengths_from_database`
-on an abstract parent (without a table), such as +ApplicationRecord+ or <tt>ActiveRecord::Base</tt>.
-
-  class ApplicationRecord < ActiveRecord::Base
-    self.abstract_class = true
-    validates_lengths_from_database :limit => 255
-  end
-
-  # This will use the validations with default options (from parent)
-  class Post < ApplicationRecord
-  end
-
-  # This will use the validations, with overriding the default options (the limit will not be applied)
-  class User < ApplicationRecord
-    validates_lengths_from_database :only => [:name]
-  end
-
-  # This will use the validations, using the default options + adding some class specific customizations
-  class Comment < ApplicationRecord
-    validate_lengths_from_database_options[:only] << :name
-  end
-
-== Running Tests
-
-This gem uses appraisal to test with different versions of the dependencies. See Appraisal first for which versions are tested.
-
-  # Just the gems locked in Gemfile.lock
-  $ rake test
-
-  # All of the Appraisals:
-  $ appraisal install
-  $ appraisal rake test
-

data/Rakefile

@@ -1,24 +0,0 @@
-require 'rubygems'
-require 'bundler/setup'
-
-require 'rake'
-require 'rspec/core/rake_task'
-
-Bundler::GemHelper.install_tasks
-
-desc 'Default: run unit tests.'
-task :default => [:clean, :test]
-
-desc "Run Specs"
-RSpec::Core::RakeTask.new(:spec) do |t|
-end
-
-task :test => :spec
-
-desc "Clean up files."
-task :clean do |t|
-  FileUtils.rm_rf "tmp"
-  Dir.glob("spec/db/*.sqlite3").each {|f| FileUtils.rm f }
-  Dir.glob("validates_lengths_from_database-*.gem").each {|f| FileUtils.rm f }
-end
-

data/init.rb

@@ -1,4 +0,0 @@
-require "validates_lengths_from_database"
-
-ValidatesLengthsFromDatabase::Railtie.insert
-

data/rails/init.rb

@@ -1,4 +0,0 @@
-require "validates_lengths_from_database"
-
-ValidatesLengthsFromDatabase::Railtie.insert
-

data/spec/db/database.yml

@@ -1,21 +0,0 @@
-sqlite:
-  adapter: sqlite
-  database: spec/db/test.sqlite
-
-sqlite3:
-  adapter: sqlite3
-  database: spec/db/test.sqlite3
-
-postgresql:
-  adapter: postgresql
-  username: postgres
-  password: postgres
-  database: has_draft_plugin_test
-  min_messages: ERROR
-
-mysql:
-  adapter: mysql
-  host: localhost
-  username: root
-  password:
-  database: has_draft_plugin_test

data/spec/db/schema.rb

@@ -1,38 +0,0 @@
-ActiveRecord::Schema.define(:version => 0) do
-  create_table :articles, :force => true do |t|
-    t.string :string_1, :limit => 5
-    t.string :string_2, :limit => 5
-
-    if postgresql?
-      # PostgreSQL doesn't support limits on text columns
-      t.text :text_1
-    else
-      t.text :text_1, :limit => 5
-    end
-
-    t.date :date_1
-  
-    t.integer :integer_1, :limit => 5
-    t.decimal :decimal_1, :precision => 5, :scale => 2
-    t.float :float_1, :limit => 5
-
-    if database_supports_arrays?
-      t.string :array_1, :array => true, :limit => 5
-    end
-  end
-
-  create_table :articles_high_limit, :force => true do |t|
-    t.string :string_1
-    t.string :string_2
-    t.text :text_1
-    t.date :date_1
-    t.integer :integer_1
-    t.decimal :decimal_1, :precision => 11, :scale => 2
-    t.float :float_1
-
-    if database_supports_arrays?
-      t.string :array_1, :array => true
-    end
-  end
-end
-

data/spec/spec_helper.rb

@@ -1,27 +0,0 @@
-require "rubygems"
-require "rspec"
-require "active_record"
-require "active_support"
-require "yaml"
-
-# Establish DB Connection
-config = YAML::load(IO.read(File.join(File.dirname(__FILE__), 'db', 'database.yml')))
-ActiveRecord::Base.configurations = {'test' => config[ENV['DB'] || 'sqlite3']}
-ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations['test'])
-
-def database_supports_arrays?
-  postgresql? && active_record_4?
-end
-
-def postgresql?
-  ActiveRecord::Base.connection.instance_values["config"][:adapter] == 'postgresql'
-end
-
-def active_record_4?
-  ActiveRecord::VERSION::MAJOR >= 4
-end
-
-# Load Test Schema into the Database
-load(File.dirname(__FILE__) + "/db/schema.rb")
-
-require File.dirname(__FILE__) + '/../init'

data/spec/validates_lengths_from_database_spec.rb

@@ -1,372 +0,0 @@
-require "spec_helper"
-
-describe ValidatesLengthsFromDatabase do
-
-  LONG_ATTRIBUTES = {
-    :string_1 => "123456789",
-    :string_2 => "123456789",
-    :text_1 => "123456789",
-    :date_1 => Date.today,
-    :integer_1 => 123456789,
-    :decimal_1 => 123456789.01,
-    :float_1 => 123456789.01
-  }
-
-  SHORT_ATTRIBUTES = {
-    :string_1 => "12",
-    :string_2 => "12",
-    :text_1 => "12",
-    :date_1 => Date.today,
-    :integer_1 => 123,
-    :decimal_1 => 12.34,
-    :float_1 => 12.34
-  }
-
-  before(:all) do
-    ActiveSupport::Deprecation.silenced = true
-  end
-
-  class ApplicationRecord < ActiveRecord::Base
-    self.abstract_class = true
-    validates_lengths_from_database :limit => 255
-  end
-
-  context "Model without associated table" do
-    specify "defining validates_lengths_from_database should not raise an error" do
-      lambda {
-        class InvalidTableArticle < ActiveRecord::Base
-          self.table_name = "articles_invalid"
-          validates_lengths_from_database
-        end
-      }.should_not raise_error
-    end
-  end
-
-  context "Model without a table yet" do
-    before do
-      class LazyTableArticle < ActiveRecord::Base
-        self.table_name = "articles_lazy"
-        validates_lengths_from_database
-      end
-    end
-
-    context "before the table is created" do
-      specify "should fail to create records" do
-        lambda { LazyTableArticle.new }.should raise_error
-      end
-    end
-
-    context "after the table is created" do
-      before do
-        ActiveRecord::Schema.define do
-          create_table :articles_lazy, :force => false do |t|
-            t.string :string_1, :limit => 5
-          end
-        end
-      end
-
-      after do
-        ActiveRecord::Schema.define do
-          drop_table :articles_lazy
-        end
-      end
-
-      context "an article with long attributes" do
-        before { @article = LazyTableArticle.new(LONG_ATTRIBUTES.slice(:string_1)); @article.valid? }
-
-        specify "should not be valid" do
-          @article.should_not be_valid
-        end
-      end
-
-      context "an article with short attributes" do
-        before { @article = LazyTableArticle.new(SHORT_ATTRIBUTES.slice(:string_1)); @article.valid? }
-
-        specify "should be valid" do
-          @article.should be_valid
-        end
-      end
-    end
-  end
-
-  context "Model without validates_lengths_from_database" do
-    before do
-      class ArticleValidateAll < ActiveRecord::Base
-        self.table_name = "articles"
-      end
-    end
-
-    context "an article with overloaded attributes" do
-      before { @article = ArticleValidateAll.new(LONG_ATTRIBUTES); @article.valid? }
-
-      it "should be valid" do
-        @article.should be_valid
-      end
-    end
-  end
-
-  context "Model with validates_lengths_from_database" do
-    before do
-      class ArticleValidateAll < ActiveRecord::Base
-        self.table_name = "articles"
-        validates_lengths_from_database
-      end
-
-      class ArticleValidateText < ActiveRecord::Base
-        self.table_name = "articles"
-        validates_lengths_from_database :only => [:string_1]
-      end
-    end
-
-    context "an article with overloaded attributes" do
-      before { @article = ArticleValidateAll.new(LONG_ATTRIBUTES); @article.valid? }
-
-      it "should not be valid" do
-        @article.should_not be_valid
-      end
-
-      it "should have errors on all string/text attributes" do
-        @article.errors["string_1"].join.should =~ /too long/
-        @article.errors["string_2"].join.should =~ /too long/
-        @article.errors["text_1"].join.should =~ /too long/  unless postgresql?  # PostgreSQL doesn't support limits on text columns
-        @article.errors["decimal_1"].join.should =~ /less than/
-      end
-    end
-
-    context "inheritance" do
-      before do
-        class ArticleValidateChild < ApplicationRecord
-          self.table_name = "articles"
-          validates_lengths_from_database :only => [:string_1]
-        end
-        class ArticleValidateChildOverwrite < ArticleValidateChild
-          validate_lengths_from_database_options[:only] << :string_2
-        end
-        class ArticleWithoutValidations < ApplicationRecord
-          self.table_name = "articles"
-          validates_lengths_from_database :only => []
-        end
-      end
-
-      it "should inherit the validation options from the parent" do
-        @article = ArticleValidateChild.new(LONG_ATTRIBUTES)
-        @article.valid?
-        @article.errors["string_1"].join.should =~ /too long/
-        @article.errors["string_2"].join.should_not =~ /too long/
-      end
-
-      it "should allow changing the validation options of child" do
-        @article = ArticleValidateChildOverwrite.new(LONG_ATTRIBUTES)
-        @article.valid?
-        @article.errors["string_1"].join.should =~ /too long/
-        @article.errors["string_2"].join.should =~ /too long/
-      end
-    end
-
-    context "an article with short attributes" do
-      before { @article = ArticleValidateAll.new(SHORT_ATTRIBUTES); @article.valid? }
-
-      it "should be valid" do
-        @article.should be_valid
-      end
-    end
-
-    if database_supports_arrays?
-      context "an article with with string array attribute" do
-        before { @article = ArticleValidateAll.new(:array_1 => %w(1 2 3 4 5 6 7 8 9 10)); @article.valid? }
-
-        it "should be valid" do
-          @article.should be_valid
-        end
-      end
-    end
-  end
-
-  context "Model with validates_lengths_from_database :limit => 5" do
-    before do
-      class ArticleValidateLimit < ActiveRecord::Base
-        self.table_name = "articles_high_limit"
-        validates_lengths_from_database :limit => 5
-      end
-    end
-
-    context "an article with overloaded attributes" do
-      before { @article = ArticleValidateLimit.new(LONG_ATTRIBUTES); @article.valid? }
-
-      it "should not be valid" do
-        @article.should_not be_valid
-      end
-
-      it "should have errors on all string/text attributes" do
-        @article.errors["string_1"].join.should =~ /too long/
-        @article.errors["string_2"].join.should =~ /too long/
-        @article.errors["text_1"].join.should =~ /too long/
-      end
-    end
-
-    context "an article with short attributes" do
-      before { @article = ArticleValidateLimit.new(SHORT_ATTRIBUTES); @article.valid? }
-
-
-      it "should be valid" do
-        @article.should be_valid
-      end
-    end
-  end
-
-  context "Model with validates_lengths_from_database :limit => {:string => 5, :text => 100}" do
-    before do
-      class ArticleValidateSpecificLimit < ActiveRecord::Base
-        self.table_name = "articles_high_limit"
-        validates_lengths_from_database :limit => {:string => 5, :text => 100}
-      end
-    end
-
-    context "an article with string_1 that is too many characters" do
-      before { @article = ArticleValidateSpecificLimit.new(LONG_ATTRIBUTES); @article.valid? }
-
-      it "should not be valid" do
-        @article.should_not be_valid
-      end
-
-      it "should have errors on all string/text attributes" do
-        @article.errors["string_1"].join.should =~ /too long/
-        @article.errors["string_2"].join.should =~ /too long/
-        @article.errors["text_1"].should_not be_present
-        @article.errors["decimal_1"].should_not be_present
-      end
-    end
-
-    context "an article with string_1 that is too many bytes, but few enough characters" do
-      before do
-        @article = ArticleValidateSpecificLimit.new(
-          LONG_ATTRIBUTES.merge(:string_1 => "😎😎😎😎", :string_2 => "👍👍👍👍")
-        )
-
-        @article.valid?
-      end
-
-      it "should be valid" do
-        @article.should be_valid
-      end
-    end
-
-    context "an article with text_1 that is too many characters" do
-      before do
-        @article = ArticleValidateSpecificLimit.new(LONG_ATTRIBUTES.merge(:text_1 => "a"*101))
-        @article.valid?
-      end
-
-      it "should not be valid" do
-        @article.should_not be_valid
-      end
-
-      it "should have errors on all string/text attributes" do
-        @article.errors["string_1"].join.should =~ /too long/
-        @article.errors["string_2"].join.should =~ /too long/
-        @article.errors["text_1"].join.should =~ /too long/
-        @article.errors["decimal_1"].should_not be_present
-      end
-    end
-
-    context "an article with text_1 that is too many bytes, but few enough characters" do
-      before do
-        @article = ArticleValidateSpecificLimit.new(LONG_ATTRIBUTES.merge(:text_1 => "👍"*99))
-        @article.valid?
-      end
-
-      it "should not be valid" do
-        @article.should_not be_valid
-      end
-
-      it "should have errors on all string/text attributes" do
-        @article.errors["string_1"].join.should =~ /too long/
-        @article.errors["string_2"].join.should =~ /too long/
-        @article.errors["text_1"].join.should =~ /too long/
-        @article.errors["decimal_1"].should_not be_present
-      end
-    end
-  end
-
-  context "Model with validates_lengths_from_database :only => [:text_1], :limit => {:text => 10}" do
-    before do
-      class ArticleValidateOnlyText < ActiveRecord::Base
-        self.table_name = "articles_high_limit"
-        validates_lengths_from_database :only => [:text_1], :limit => {:text => 10}
-      end
-    end
-
-    context "an article with a length equal to max, but a bytesize greater than" do
-      before { @article = ArticleValidateOnlyText.new(:text_1 => "😎"*10); @article.valid? }
-
-      it "should not be valid" do
-        @article.should_not be_valid
-      end
-    end
-  end
-
-  context "Model with validates_lengths_from_database :only => [:string_1, :text_1]" do
-    before do
-      class ArticleValidateOnly < ActiveRecord::Base
-        self.table_name = "articles"
-        validates_lengths_from_database :only => [:string_1, :text_1]
-      end
-    end
-
-    context "an article with long attributes" do
-      before { @article = ArticleValidateOnly.new(LONG_ATTRIBUTES); @article.valid? }
-
-      it "should not be valid" do
-        @article.should_not be_valid
-      end
-
-      it "should have errors on only string_1 and text_1" do
-        @article.errors["string_1"].join.should =~ /too long/
-        (@article.errors["string_2"] || []).should be_empty
-        @article.errors["text_1"].join.should =~ /too long/ unless postgresql?  # PostgreSQL doesn't support limits on text columns
-        (@article.errors["decimal_1"] || []).should be_empty
-      end
-    end
-
-    context "an article with short attributes" do
-      before { @article = ArticleValidateOnly.new(SHORT_ATTRIBUTES); @article.valid? }
-
-      it "should be valid" do
-        @article.should be_valid
-      end
-    end
-  end
-
-  context "Model with validates_lengths_from_database :except => [:string_1, :text_1]" do
-    before do
-      class ArticleValidateExcept < ActiveRecord::Base
-        self.table_name = "articles"
-        validates_lengths_from_database :except => [:string_1, :text_1]
-      end
-    end
-
-    context "an article with long attributes" do
-      before { @article = ArticleValidateExcept.new(LONG_ATTRIBUTES); @article.valid? }
-
-      it "should not be valid" do
-        @article.should_not be_valid
-      end
-
-      it "should have errors on columns other than string_1 and text_1 only" do
-        (@article.errors["string_1"] || []).should be_empty
-        (@article.errors["text_1"] || []).should be_empty
-        @article.errors["decimal_1"].join.should =~ /less than/
-        @article.errors["string_2"].join.should =~ /too long/
-      end
-    end
-
-    context "an article with short attributes" do
-      before { @article = ArticleValidateOnly.new(SHORT_ATTRIBUTES); @article.valid? }
-
-      it "should be valid" do
-        @article.should be_valid
-      end
-    end
-  end
-
-end