activerecord_mysql_strict 0.1.1 → 0.2

data/lib/active_record/mysql/strict/validations.rb

@@ -0,0 +1,40 @@
+module ActiveRecord
+  module MySQL
+    module Strict
+      module Validations
+        # Constants
+        MYSQL_STRICT_STRING_LIMIT = 255
+        MYSQL_STRICT_TEXT_LIMIT = 65535
+        MYSQL_STRICT_INTEGER_LIMIT = 2147483647
+
+        def self.define_mysql_strict_validations(klass, options = {})
+          except = options[:except] || []
+          model_columns = klass.columns.dup.reject { |c| except.include?(c.name.to_sym) }
+
+          if only = options[:only]
+            model_columns = model_columns.select { |c| only.include?(c.name.to_sym) }
+          end
+
+          model_columns.each do |field|
+            method = :"define_mysql_strict_#{field.type}_validation"
+            Validations.send(method, klass, field) if Validations.respond_to?(method)
+          end
+        end
+
+      protected
+
+        def self.define_mysql_strict_string_validation(klass, field)
+          klass.validates field.name, 'ActiveRecord::MySQL::Strict::StrictLength' => { in: 0..(field.limit || MYSQL_STRICT_STRING_LIMIT) }, allow_blank: true
+        end
+
+        def self.define_mysql_strict_text_validation(klass, field)
+          klass.validates field.name, 'ActiveRecord::MySQL::Strict::StrictLength' => { in: 0..(field.limit || MYSQL_STRICT_TEXT_LIMIT) }, allow_blank: true
+        end
+
+        def self.define_mysql_strict_integer_validation(klass, field)
+          klass.validates field.name, numericality: { greather_than_or_equal_to: -MYSQL_STRICT_INTEGER_LIMIT, less_than_or_equal_to: MYSQL_STRICT_INTEGER_LIMIT }, allow_blank: true
+        end
+      end
+    end
+  end
+end

data/lib/active_record/mysql/strict/version.rb

@@ -1,7 +1,7 @@
 module ActiveRecord
   module MySQL
     module Strict
-      VERSION = '0.1.1'
+      VERSION = '0.2'
     end
   end
 end

data/lib/activerecord_mysql_strict.rb

@@ -5,11 +5,10 @@ require 'active_model'
 require 'active_support'
 
 require 'active_record/mysql/strict/strict_length_validator'
-require 'active_record/mysql/strict/mixin'
+require 'active_record/mysql/strict/validations'
 
 class ActiveRecord::Base
   def self.validates_strict_columns(options = {})
-    @mysql_strict_options = options
-    include ActiveRecord::MySQL::Strict::Mixin
+    ActiveRecord::MySQL::Strict::Validations.define_mysql_strict_validations(self, options)
   end
 end

data/spec/activerecord_mysql_strict/{mixin_spec.rb → validations_spec.rb}

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-describe ActiveRecord::MySQL::Strict::Mixin do
-  describe :validates_strict_columns do
+describe ActiveRecord::MySQL::Strict::Validations do
+  describe :define_mysql_strict_validations do
     context 'for model without other validations' do
       let(:model) { strict_model 'User' }
 
@@ -129,7 +129,7 @@ describe ActiveRecord::MySQL::Strict::Mixin do
       end
     end
 
-    context 'for model with accessor that returns an invalid string' do
+    context 'for valid model with accessor that returns an invalid string' do
       let(:model) do
         strict_model 'User' do
           attr_reader :long_name
@@ -152,7 +152,35 @@ describe ActiveRecord::MySQL::Strict::Mixin do
       end
 
       subject { model.new(long_name: '*' * 10) }
+      its(:long_name) { should eql '*' * 400 }
       it { should be_valid }
     end
+
+    context 'for invalid model with accessor that returns a valid string' do
+      let(:model) do
+        strict_model 'User' do
+          attr_reader :short_name
+
+          # When we call `#short_name` it will return a valid string but
+          # we want the attribute to store the real, valid value because we
+          # want to actually make sure that the real attribute value does
+          # exceed the limit, not what the accessor returns.
+          define_method :short_name= do |value|
+            @short_name = '*' * 100
+            write_attribute(:short_name, value)
+          end
+        end
+      end
+
+      before do
+        run_migration do
+          create_table(:users, force: true) { |t| t.string :short_name }
+        end
+      end
+
+      subject { model.new(short_name: '*' * 400) }
+      its(:short_name) { should eql '*' * 100 }
+      it { should_not be_valid }
+    end
   end
 end

data/spec/activerecord_mysql_strict_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe ActiveRecord::MySQL::Strict do
+  describe :validates_strict_columns do
+    before do
+      spawn_model 'User'
+      run_migration do
+        create_table(:users, force: true) { |t| t.string :name }
+      end
+    end
+
+    context 'without options' do
+      before do
+        expect(ActiveRecord::MySQL::Strict::Validations).to receive(:define_mysql_strict_validations).with(User, {})
+      end
+
+      it { User.validates_strict_columns }
+    end
+
+    context 'with options' do
+      before do
+        expect(ActiveRecord::MySQL::Strict::Validations).to receive(:define_mysql_strict_validations).with(User, { except: [:bar], only: [:foo] })
+      end
+
+      it { User.validates_strict_columns except: [:bar], only: [:foo] }
+    end
+  end
+end

data/spec/support/macros/model_macros.rb

@@ -1,7 +1,7 @@
 module ModelMacros
   # Create a new microscope model
   def strict_model(klass_name, options = {}, &block)
-    spawn_model klass_name, ActiveRecord::Base do
+    spawn_model klass_name do
       validates_strict_columns options
       instance_exec(&block) if block
     end
@@ -10,7 +10,7 @@ module ModelMacros
   protected
 
   # Create a new model class
-  def spawn_model(klass_name, parent_klass, &block)
+  def spawn_model(klass_name, parent_klass = ActiveRecord::Base, &block)
     Object.instance_eval { remove_const klass_name } if Object.const_defined?(klass_name)
     Object.const_set(klass_name, Class.new(parent_klass))
     Object.const_get(klass_name).class_eval(&block) if block_given?

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord_mysql_strict
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: '0.2'
   prerelease: 
 platform: ruby
 authors:
@@ -140,11 +140,12 @@ files:
 - activerecord_mysql_strict.gemspec
 - gemfiles/Gemfile.activerecord-3.2.x
 - gemfiles/Gemfile.activerecord-4.0
-- lib/active_record/mysql/strict/mixin.rb
 - lib/active_record/mysql/strict/strict_length_validator.rb
+- lib/active_record/mysql/strict/validations.rb
 - lib/active_record/mysql/strict/version.rb
 - lib/activerecord_mysql_strict.rb
-- spec/activerecord_mysql_strict/mixin_spec.rb
+- spec/activerecord_mysql_strict/validations_spec.rb
+- spec/activerecord_mysql_strict_spec.rb
 - spec/spec_helper.rb
 - spec/support/macros/database_macros.rb
 - spec/support/macros/model_macros.rb
@@ -163,7 +164,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -369873074256560002
+      hash: -2194545616864898002
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -172,7 +173,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -369873074256560002
+      hash: -2194545616864898002
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -181,7 +182,8 @@ specification_version: 3
 summary: ActiveRecord::MySQL::Strict adds validations to ActiveRecord models to make
   sure they do not trigger errors in MySQL strict mode.
 test_files:
-- spec/activerecord_mysql_strict/mixin_spec.rb
+- spec/activerecord_mysql_strict/validations_spec.rb
+- spec/activerecord_mysql_strict_spec.rb
 - spec/spec_helper.rb
 - spec/support/macros/database_macros.rb
 - spec/support/macros/model_macros.rb

data/lib/active_record/mysql/strict/mixin.rb

@@ -1,46 +0,0 @@
-module ActiveRecord
-  module MySQL
-    module Strict
-      # Constants
-      MYSQL_STRICT_STRING_LIMIT = 255
-      MYSQL_STRICT_TEXT_LIMIT = 65535
-      MYSQL_STRICT_INTEGER_LIMIT = 2147483647
-
-      module Mixin
-        extend ActiveSupport::Concern
-
-        included do
-          define_mysql_strict_validations
-        end
-
-        module ClassMethods
-          def define_mysql_strict_validations
-            except = @mysql_strict_options[:except] || []
-            model_columns = self.columns.dup.reject { |c| except.include?(c.name.to_sym) }
-
-            if only = @mysql_strict_options[:only]
-              model_columns = model_columns.select { |c| only.include?(c.name.to_sym) }
-            end
-
-            model_columns.each do |field|
-              method = :"define_mysql_strict_#{field.type}_validation"
-              send(method, field) if respond_to?(method)
-            end
-          end
-
-          def define_mysql_strict_string_validation(field)
-            validates field.name, 'ActiveRecord::MySQL::Strict::StrictLength' => { in: 0..(field.limit || MYSQL_STRICT_STRING_LIMIT) }, allow_blank: true
-          end
-
-          def define_mysql_strict_text_validation(field)
-            validates field.name, 'ActiveRecord::MySQL::Strict::StrictLength' => { in: 0..(field.limit || MYSQL_STRICT_TEXT_LIMIT) }, allow_blank: true
-          end
-
-          def define_mysql_strict_integer_validation(field)
-            validates field.name, numericality: { greather_than_or_equal_to: -MYSQL_STRICT_INTEGER_LIMIT, less_than_or_equal_to: MYSQL_STRICT_INTEGER_LIMIT }, allow_blank: true
-          end
-        end
-      end
-    end
-  end
-end