activerecord-databasevalidations 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c00506fa5c0018170d2c1b919b76f0a334cd1216
-  data.tar.gz: 6d8631cb529bbbeb52e53211f83dc27b9be94084
+  metadata.gz: 337cf9c69d98f33651b5a008c20f0d24648151ad
+  data.tar.gz: 3d604b4f812af63b98c0cc0de1820a0b61147eae
 SHA512:
-  metadata.gz: 8fddcc3dcfee81c8dd7c9d2c812de2567307e30176ffc52b503218b30a0779d8a5668bce442990335f9d60e1817b28eb2ddfba8a164adb7828019cc1afbcf919
-  data.tar.gz: 4a41f0963cc799e802518fc21a97b1583bc7978136e4ec28c49f6a7d5b1be642e6f4ea3e86cbfcdb9a6873bf04168b95111dfba4ce724ec1e5bf34c7fd6d5021
+  metadata.gz: 6700a0056bb6dd20e32b6c584b21509b1f2531bec7c7c26eb03d4eaff7f118ad2485b62657c97ac1409d80c0ad080a0389b0dc60344a17ff5e9614612d619d35
+  data.tar.gz: 09cc0d7b8c4dffd6f32700e2575e66d74c012f9215db3da75bfda9587f297c8578e5c3c9a38260bcf29123cc6b90726abe5c11c52213fc36a0432db5980ec37e

data/lib/active_model/validations/bytesize.rb

@@ -15,8 +15,8 @@ module ActiveModel
       end
 
       def validate_each(record, attribute, value)
-        string = value.to_s
-        string = string.encode(options[:encoding]) if requires_transcoding?(string)
+        string = ActiveRecord::DatabaseValidations::MySQL.value_for_column(value, options[:encoding])
+
         if string.bytesize > options[:maximum]
           errors_options = options.except(:too_many_bytes, :maximum)
           default_message = options[:too_many_bytes]
@@ -25,10 +25,6 @@ module ActiveModel
           record.errors.add(attribute, :too_many_bytes, errors_options)
         end
       end
-
-      def requires_transcoding?(value)
-        encoding.present? && encoding != value.encoding
-      end
     end
 
     module HelperMethods

data/lib/active_record/database_validations.rb

@@ -2,6 +2,7 @@ require 'active_record'
 require 'active_support/i18n'
 require 'active_record/database_validations/version'
 
+require 'active_record/database_validations/mysql'
 require 'active_record/validations/database_constraints'
 require 'active_record/validations/string_truncator'
 

data/lib/active_record/database_validations/mysql.rb

@@ -0,0 +1,74 @@
+module ActiveRecord
+  module DatabaseValidations
+    module MySQL
+      TYPE_LIMITS = {
+        char:       { type: :characters },
+        varchar:    { type: :characters },
+        varbinary:  { type: :bytes },
+
+        tinytext:   { type: :bytes, maximum: 2 **  8 - 1 },
+        text:       { type: :bytes, maximum: 2 ** 16 - 1 },
+        mediumtext: { type: :bytes, maximum: 2 ** 24 - 1 },
+        longtext:   { type: :bytes, maximum: 2 ** 32 - 1 },
+
+        tinyblob:   { type: :bytes, maximum: 2 **  8 - 1 },
+        blob:       { type: :bytes, maximum: 2 ** 16 - 1 },
+        mediumblob: { type: :bytes, maximum: 2 ** 24 - 1 },
+        longblob:   { type: :bytes, maximum: 2 ** 32 - 1 },
+      }
+
+      def self.column_size_limit(column)
+        @column_size_limit ||= {}
+        @column_size_limit[column] ||= begin
+          column_type = column.sql_type.sub(/\(.*\z/, '').gsub(/\s/, '_').to_sym
+          type_limit  = TYPE_LIMITS.fetch(column_type, {})
+
+          [
+            column.limit || type_limit[:maximum],
+            type_limit[:type],
+            determine_encoding(column),
+          ]
+        end
+      end
+
+      def self.column_range(column)
+        args = {}
+        unsigned = column.sql_type =~ / unsigned\z/
+        case column.type
+        when :decimal
+          args[:less_than] = maximum = 10 ** (column.precision - column.scale)
+          if unsigned
+            args[:greater_than_or_equal_to] = 0
+          else
+            args[:greater_than] = 0 - maximum
+          end
+
+        when :integer
+          args[:only_integer] = true
+          args[:less_than] = unsigned ? 1 << (column.limit * 8) : 1 << (column.limit * 8 - 1)
+          args[:greater_than_or_equal_to] = unsigned ? 0 : 0 - args[:less_than]
+        end
+
+        args
+      end
+
+      def self.determine_encoding(column)
+        return nil unless column.text?
+        case column.collation
+          when /\Autf8/; Encoding::UTF_8
+          else raise NotImplementedError, "Don't know how to determine the Ruby encoding for MySQL's #{column.collation} collation."
+        end
+      end
+
+      def self.requires_transcoding?(value, column_encoding = nil)
+        column_encoding.present? && column_encoding != value.encoding
+      end
+
+      def self.value_for_column(value, column_encoding = nil)
+        value = value.to_s unless value.is_a?(String)
+        value.encode!('utf-8') if requires_transcoding?(value, column_encoding)
+        return value
+      end
+    end
+  end
+end

data/lib/active_record/database_validations/varchar_191.rb

@@ -0,0 +1 @@
+ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter::NATIVE_DATABASE_TYPES[:string][:limit] = 191

data/lib/active_record/database_validations/varchar_255.rb

@@ -0,0 +1 @@
+ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter::NATIVE_DATABASE_TYPES[:string][:limit] = 255

data/lib/active_record/database_validations/version.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
   module DatabaseValidations
-    VERSION = "0.2.2"
+    VERSION = "0.2.3"
   end
 end

data/lib/active_record/validations/database_constraints.rb

@@ -5,26 +5,15 @@ require 'active_model/validations/basic_multilingual_plane'
 module ActiveRecord
   module Validations
     class DatabaseConstraintsValidator < ActiveModel::EachValidator
-      TYPE_LIMITS = {
-        char:       { validator: ActiveModel::Validations::LengthValidator },
-        varchar:    { validator: ActiveModel::Validations::LengthValidator },
-        varbinary:  { validator: ActiveModel::Validations::BytesizeValidator },
-
-        tinytext:   { validator: ActiveModel::Validations::BytesizeValidator, default_maximum: 2 **  8 - 1 },
-        text:       { validator: ActiveModel::Validations::BytesizeValidator, default_maximum: 2 ** 16 - 1 },
-        mediumtext: { validator: ActiveModel::Validations::BytesizeValidator, default_maximum: 2 ** 24 - 1 },
-        longtext:   { validator: ActiveModel::Validations::BytesizeValidator, default_maximum: 2 ** 32 - 1 },
-
-        tinyblob:   { validator: ActiveModel::Validations::BytesizeValidator, default_maximum: 2 **  8 - 1 },
-        blob:       { validator: ActiveModel::Validations::BytesizeValidator, default_maximum: 2 ** 16 - 1 },
-        mediumblob: { validator: ActiveModel::Validations::BytesizeValidator, default_maximum: 2 ** 24 - 1 },
-        longblob:   { validator: ActiveModel::Validations::BytesizeValidator, default_maximum: 2 ** 32 - 1 },
-      }
-
       attr_reader :constraints
 
       VALID_CONSTRAINTS = Set[:size, :basic_multilingual_plane, :not_null, :range]
 
+      SIZE_VALIDATORS_FOR_TYPE = {
+        characters: ActiveModel::Validations::LengthValidator,
+        bytes: ActiveModel::Validations::BytesizeValidator,
+      }
+
       def initialize(options = {})
         @constraints = Set.new(Array.wrap(options[:in]) + Array.wrap(options[:with]))
         @constraint_validators = {}
@@ -49,11 +38,8 @@ module ActiveRecord
         return unless constraints.include?(:size)
         return unless column.text? || column.binary?
 
-        column_type     = column.sql_type.sub(/\(.*\z/, '').gsub(/\s/, '_').to_sym
-        type_limit      = TYPE_LIMITS.fetch(column_type, {})
-        validator_class = type_limit[:validator]
-        maximum         = column.limit || type_limit[:default_maximum]
-        encoding        = column.text? ? determine_encoding(column) : nil
+        maximum, type, encoding = ActiveRecord::DatabaseValidations::MySQL.column_size_limit(column)
+        validator_class = SIZE_VALIDATORS_FOR_TYPE[type]
 
         if validator_class && maximum
           validator_class.new(attributes: [column.name.to_sym], class: klass, maximum: maximum, encoding: encoding)
@@ -64,23 +50,9 @@ module ActiveRecord
         return unless constraints.include?(:range)
         return unless column.number?
 
-        unsigned = column.sql_type =~ / unsigned\z/
-        case column.type
-        when :decimal
-          args = { attributes: [column.name.to_sym], class: klass, allow_nil: true }
-          args[:less_than] = maximum = 10 ** (column.precision - column.scale)
-          if unsigned
-            args[:greater_than_or_equal_to] = 0
-          else
-            args[:greater_than] = 0 - maximum
-          end
-          ActiveModel::Validations::NumericalityValidator.new(args)
-
-        when :integer
-          maximum = unsigned ? 1 << (column.limit * 8) : 1 << (column.limit * 8 - 1)
-          minimum = unsigned ? 0 : 0 - maximum
-          ActiveModel::Validations::NumericalityValidator.new(attributes: [column.name.to_sym], class: klass, greater_than_or_equal_to: minimum, less_than: maximum, allow_nil: true, only_integer: true)
-        end
+        args = { attributes: [column.name.to_sym], class: klass, allow_nil: true }
+        args.merge!(ActiveRecord::DatabaseValidations::MySQL.column_range(column))
+        ActiveModel::Validations::NumericalityValidator.new(args)
       end
 
       def basic_multilingual_plane_validator(klass, column)
@@ -107,15 +79,6 @@ module ActiveRecord
           validator.validate_each(record, attribute, value)
         end
       end
-
-      private
-
-      def determine_encoding(column)
-        case column.collation
-          when /\Autf8/; Encoding.find('utf-8')
-          else raise NotImplementedError, "Don't know how to determine the Ruby encoding for MySQL's #{column.collation} collation."
-        end
-      end
     end
   end
 end

data/lib/active_record/validations/string_truncator.rb

@@ -11,21 +11,14 @@ module ActiveRecord
             return if self[field].nil?
 
             column = self.class.columns_hash[field.to_s]
-            limit = StringTruncator.mysql_textual_column_limit(column)
+            maximum, type, encoding = ActiveRecord::DatabaseValidations::MySQL.column_size_limit(column)
+            value = ActiveRecord::DatabaseValidations::MySQL.value_for_column(self[field], encoding)
 
-            case column.type
-            when :string
-              value = self[field].to_s
-              if limit && value.length > limit
-                self[field] = value.slice(0, limit)
-              end
-
-            when :text
-              value = self[field].to_s
-              value.encode!('utf-8') if value.encoding != Encoding::UTF_8
-              if limit && value.bytesize > limit
-                self[field] = value.mb_chars.limit(limit).to_s
-              end
+            case type
+            when :characters
+              self[field] = value.slice(0, maximum) if maximum && value.length > maximum
+            when :bytes
+              self[field] = value.mb_chars.limit(maximum).to_s if maximum && value.bytesize > maximum
             end
 
             return # to make sure the callback chain doesn't halt
@@ -33,17 +26,6 @@ module ActiveRecord
           return method_name
         end
       end
-
-      def self.mysql_textual_column_limit(column)
-        @mysql_textual_column_limits ||= {}
-        @mysql_textual_column_limits[column] ||= begin
-          raise ArgumentError, "Only UTF-8 textual columns are supported." unless column.text? && column.collation =~ /\Autf8_/
-
-          column_type = column.sql_type.sub(/\(.*\z/, '').gsub(/\s/, '_').to_sym
-          type_limit  = ActiveRecord::Validations::DatabaseConstraintsValidator::TYPE_LIMITS.fetch(column_type, {})
-          column.limit || type_limit[:default_maximum]
-        end
-      end
     end
   end
 end

data/test/varchar_default_size_test.rb

@@ -0,0 +1,20 @@
+require 'test_helper'
+require 'active_record/database_validations/varchar_191'
+
+class Varchar < ActiveRecord::Base; end
+
+class VarcharDefaultSizeTest < Minitest::Test
+  def test_field_was_created_with_191_characters
+    ActiveRecord::Migration.suppress_messages do
+      ActiveRecord::Migration.create_table(:varchars, force: true, options: "CHARACTER SET utf8mb4") do |t|
+        t.string :string
+      end
+
+      # This will fail if the field is more than 767 bytes.
+      ActiveRecord::Migration.add_index(:varchars, :string, unique: true)
+    end
+
+    assert_match /\Autf8mb4_/, Varchar.columns_hash['string'].collation
+    assert_equal 191, Varchar.columns_hash['string'].limit
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-databasevalidations
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - Willem van Bergen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-27 00:00:00.000000000 Z
+date: 2014-12-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -116,6 +116,9 @@ files:
 - lib/active_model/validations/not_null.rb
 - lib/active_record/database_validations.rb
 - lib/active_record/database_validations/locale/en.yml
+- lib/active_record/database_validations/mysql.rb
+- lib/active_record/database_validations/varchar_191.rb
+- lib/active_record/database_validations/varchar_255.rb
 - lib/active_record/database_validations/version.rb
 - lib/active_record/validations/database_constraints.rb
 - lib/active_record/validations/string_truncator.rb
@@ -129,6 +132,7 @@ files:
 - test/not_null_validator_test.rb
 - test/string_truncator_test.rb
 - test/test_helper.rb
+- test/varchar_default_size_test.rb
 homepage: https://github.com/wvanbergen/activerecord-database_validations
 licenses:
 - MIT
@@ -162,3 +166,4 @@ test_files:
 - test/not_null_validator_test.rb
 - test/string_truncator_test.rb
 - test/test_helper.rb
+- test/varchar_default_size_test.rb