schema_validations 2.0.1 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 06905897e2968a424dd329db0dd07bfdc32625aa
-  data.tar.gz: 351f0900d4f03138c76a3f19a4e83c4a02cf522d
+  metadata.gz: 8fe25cdf83ff0041992948fe1a400d40cd4e4ebc
+  data.tar.gz: 286fec9f821594ffe76bffdf1fd0b08c87320f18
 SHA512:
-  metadata.gz: 84c4bae6e9d3931f74a817c05c272a82be472c41a147a579c3ea5bd80b53b76f7287afe2f8a7eff909d1d59c667c3fd38fb147c3031ec8c74c1ab9f460dcfdd5
-  data.tar.gz: 3d39c05c232dd621b8ea04c80c018c108844cd5817725088b9ee300682863444ed7eb8b1c1fb7231116c62b6bbcaf32c487a537e14fec877c8bacec5b21ae0ab
+  metadata.gz: 7065a87c0ae2eec4d971423b6fa6d9f63c250e4e4c65f7fc3ee775d896408cc9e64fd704936b367d66206869fbc7874d4e326020171dbef15f365aa68d3bad86
+  data.tar.gz: 00c9fd2a04f6ba7f539595e717abbfb68db2c62fc59fa6a140266c069f09f57e31e1b167f1becef7d839cd1bc29bad66a4ae8977296c1c25525168e9acd0ef04

data/.gitignore

@@ -17,6 +17,7 @@ tmtags
 coverage
 rdoc
 pkg
+.byebug_history
 
 ## PROJECT::SPECIFIC
 .rvmrc

data/README.md

@@ -185,6 +185,10 @@ Earlier versions of SchemaValidations supported:
 
 ## Release Notes
 
+### 2.0.2
+
+* Use schema_monkey rather than Railties
+
 ### 2.0.1
 
 * Bug fix: Don't crash when optimistic locking is in use (#8)

data/gemfiles/activerecord-4.2/Gemfile.base

@@ -1,3 +1,3 @@
 eval File.read File.expand_path('../../Gemfile.base', __FILE__)
 
-gem "activerecord", "~> 4.2.0"
+gem "activerecord", "~> 4.2.6"

data/gemfiles/activerecord-4.2/Gemfile.mysql2

@@ -2,9 +2,9 @@ require "pathname"
 eval(Pathname.new(__FILE__).dirname.join("Gemfile.base").read, binding)
 
 platform :ruby do
-  gem "mysql2"
+  gem "mysql2", '>= 0.3.18', '< 0.5'
 end
 
 platform :jruby do
   gem 'activerecord-jdbcmysql-adapter'
-end
+end

data/lib/schema_validations/active_record/validations.rb

@@ -1,216 +1,216 @@
 module SchemaValidations
   module ActiveRecord
-    module Validations
+    module Base
 
-      def self.extended(base) # :nodoc:
-        base.class_eval do
-          define_method :load_schema_validations do
-            self.class.send :load_schema_validations
+      def load_schema_validations
+        self.class.send :load_schema_validations
+      end
+
+      module ClassMethods
+
+        def self.extended(base)
+          base.class_eval do
+            class_attribute :schema_validations_loaded
           end
-          class_attribute :schema_validations_loaded
         end
-        class << base
-          alias_method_chain :validators, :schema_validations
-          alias_method_chain :validators_on, :schema_validations
-        end if base.respond_to? :validators
-      end
 
-      def inherited(klass) # :nodoc:
-        super
-        before_validation :load_schema_validations unless schema_validations_loaded?
-      end
+        def inherited(subclass) # :nodoc:
+          super
+          before_validation :load_schema_validations unless schema_validations_loaded?
+        end
 
-      def validators_with_schema_validations
-        load_schema_validations unless schema_validations_loaded?
-        validators_without_schema_validations
-      end
+        def validators
+          load_schema_validations unless schema_validations_loaded?
+          super
+        end
 
-      def validators_on_with_schema_validations(*args)
-        load_schema_validations unless schema_validations_loaded?
-        validators_on_without_schema_validations(*args)
-      end
+        def validators_on(*args)
+          load_schema_validations unless schema_validations_loaded?
+          super
+        end
 
-      # Per-model override of Config options.  Use via, e.g.
-      #     class MyModel < ActiveRecord::Base
-      #         schema_validations :auto_create => false
-      #     end
-      #
-      # If <tt>:auto_create</tt> is not specified, it is implicitly
-      # specified as true.  This allows the "non-invasive" style of using
-      # SchemaValidations in which you set the global Config to
-      # <tt>auto_create = false</tt>, then in any model that you want auto
-      # validations you simply do:
-      #
-      #     class MyModel < ActiveRecord::Base
-      #         schema_validations
-      #     end
-      #
-      #  Of course other options can be passed, such as
-      #
-      #     class MyModel < ActiveRecord::Base
-      #         schema_validations :except_type => :validates_presence_of
-      #     end
-      #
-      #
-      def schema_validations(opts={})
-        @schema_validations_config = SchemaValidations.config.merge({:auto_create => true}.merge(opts))
-      end
+        # Per-model override of Config options.  Use via, e.g.
+        #     class MyModel < ActiveRecord::Base
+        #         schema_validations :auto_create => false
+        #     end
+        #
+        # If <tt>:auto_create</tt> is not specified, it is implicitly
+        # specified as true.  This allows the "non-invasive" style of using
+        # SchemaValidations in which you set the global Config to
+        # <tt>auto_create = false</tt>, then in any model that you want auto
+        # validations you simply do:
+        #
+        #     class MyModel < ActiveRecord::Base
+        #         schema_validations
+        #     end
+        #
+        #  Of course other options can be passed, such as
+        #
+        #     class MyModel < ActiveRecord::Base
+        #         schema_validations :except_type => :validates_presence_of
+        #     end
+        #
+        #
+        def schema_validations(opts={})
+          @schema_validations_config = SchemaValidations.config.merge({:auto_create => true}.merge(opts))
+        end
 
-      def schema_validations_config # :nodoc:
-        @schema_validations_config ||= SchemaValidations.config.dup
-      end
+        def schema_validations_config # :nodoc:
+          @schema_validations_config ||= SchemaValidations.config.dup
+        end
 
-      private
-      # Adds schema-based validations to model.
-      # Attributes as well as associations are validated.
-      # For instance if there is column
-      #
-      #     <code>email NOT NULL</code>
-      #
-      # defined at database-level it will be translated to
-      #
-      #     <code>validates_presence_of :email</code>
-      #
-      # If there is an association named <tt>user</tt>
-      # based on <tt>user_id NOT NULL</tt> it will be translated to
-      #
-      #     <code>validates_presence_of :user</code>
-      #
-      #  Note it uses the name of association (user) not the column name (user_id).
-      #  Only <tt>belongs_to</tt> associations are validated.
-      #
-      #  This accepts following options:
-      #  * :only - auto-validate only given attributes
-      #  * :except - auto-validate all but given attributes
-      #
-      def load_schema_validations #:nodoc:
-        # Don't bother if: it's already been loaded; the class is abstract; not a base class; or the table doesn't exist
-        return unless create_schema_validations?
-        load_column_validations
-        load_association_validations
-        self.schema_validations_loaded = true
-      end
+        private
+        # Adds schema-based validations to model.
+        # Attributes as well as associations are validated.
+        # For instance if there is column
+        #
+        #     <code>email NOT NULL</code>
+        #
+        # defined at database-level it will be translated to
+        #
+        #     <code>validates_presence_of :email</code>
+        #
+        # If there is an association named <tt>user</tt>
+        # based on <tt>user_id NOT NULL</tt> it will be translated to
+        #
+        #     <code>validates_presence_of :user</code>
+        #
+        #  Note it uses the name of association (user) not the column name (user_id).
+        #  Only <tt>belongs_to</tt> associations are validated.
+        #
+        #  This accepts following options:
+        #  * :only - auto-validate only given attributes
+        #  * :except - auto-validate all but given attributes
+        #
+        def load_schema_validations #:nodoc:
+          # Don't bother if: it's already been loaded; the class is abstract; not a base class; or the table doesn't exist
+          return unless create_schema_validations?
+          load_column_validations
+          load_association_validations
+          self.schema_validations_loaded = true
+        end
 
-      def load_column_validations #:nodoc:
-        content_columns.each do |column|
-          name = column.name.to_sym
+        def load_column_validations #:nodoc:
+          content_columns.each do |column|
+            name = column.name.to_sym
+
+            # Data-type validation
+            datatype = case
+                       when respond_to?(:defined_enums) && defined_enums.has_key?(column.name) then :enum
+                       when column.type == :integer then :integer
+                       when column.number? then :numeric
+                       when column.text? then :text
+                       when column.type == :boolean then :boolean
+                       end
+
+            case datatype
+            when :integer
+              load_integer_column_validations(name, column)
+            when :numeric
+              validate_logged :validates_numericality_of, name, :allow_nil => true
+            when :text
+              validate_logged :validates_length_of, name, :allow_nil => true, :maximum => column.limit if column.limit
+            end
+
+            # NOT NULL constraints
+            if column.required_on
+              if datatype == :boolean
+                validate_logged :validates_inclusion_of, name, :in => [true, false], :message => :blank
+              else
+                validate_logged :validates_presence_of, name
+              end
+            end
 
-          # Data-type validation
-          datatype = case
-                     when respond_to?(:defined_enums) && defined_enums.has_key?(column.name) then :enum
-                     when column.type == :integer then :integer
-                     when column.number? then :numeric
-                     when column.text? then :text
-                     when column.type == :boolean then :boolean
-                     end
-
-          case datatype
-          when :integer
-            load_integer_column_validations(name, column)
-          when :numeric
-            validate_logged :validates_numericality_of, name, :allow_nil => true
-          when :text
-            validate_logged :validates_length_of, name, :allow_nil => true, :maximum => column.limit if column.limit
+            # UNIQUE constraints
+            add_uniqueness_validation(column) if column.unique?
           end
+        end
+
+        def load_integer_column_validations(name, column) # :nodoc:
+          options = { :allow_nil => true, :only_integer => true }
 
-          # NOT NULL constraints
-          if column.required_on
-            if datatype == :boolean
-              validate_logged :validates_inclusion_of, name, :in => [true, false], :message => :blank
+          if range = column.cast_type.try(:range)
+            options[:greater_than_or_equal_to] = range.begin
+            if range.exclude_end?
+              options[:less_than] = range.end
             else
-              validate_logged :validates_presence_of, name
+              options[:less_than_or_equal_to] = range.end
             end
           end
 
-          # UNIQUE constraints
-          add_uniqueness_validation(column) if column.unique?
+          validate_logged :validates_numericality_of, name, options
         end
-      end
 
-      def load_integer_column_validations(name, column) # :nodoc:
-        options = { :allow_nil => true, :only_integer => true }
+        def load_association_validations #:nodoc:
+          reflect_on_all_associations(:belongs_to).each do |association|
+            # :primary_key_name was deprecated (noisily) in rails 3.1
+            foreign_key_method = (association.respond_to? :foreign_key) ?  :foreign_key : :primary_key_name
+            column = columns_hash[association.send(foreign_key_method).to_s]
+            next unless column
+
+            # NOT NULL constraints
+            validate_logged :validates_presence_of, association.name if column.required_on
 
-        if range = column.cast_type.try(:range)
-          options[:greater_than_or_equal_to] = range.begin
-          if range.exclude_end?
-            options[:less_than] = range.end
-          else
-            options[:less_than_or_equal_to] = range.end
+            # UNIQUE constraints
+            add_uniqueness_validation(column) if column.unique?
           end
         end
 
-        validate_logged :validates_numericality_of, name, options
-      end
-
-      def load_association_validations #:nodoc:
-        reflect_on_all_associations(:belongs_to).each do |association|
-          # :primary_key_name was deprecated (noisily) in rails 3.1
-          foreign_key_method = (association.respond_to? :foreign_key) ?  :foreign_key : :primary_key_name
-          column = columns_hash[association.send(foreign_key_method).to_s]
-          next unless column
+        def add_uniqueness_validation(column) #:nodoc:
+          scope = column.unique_scope.map(&:to_sym)
+          name = column.name.to_sym
 
-          # NOT NULL constraints
-          validate_logged :validates_presence_of, association.name if column.required_on
+          options = {}
+          options[:scope] = scope if scope.any?
+          options[:allow_nil] = true
+          options[:case_sensitive] = false if has_case_insensitive_index?(column, scope)
+          options[:if] = (proc do |record|
+            if scope.all? { |scope_sym| record.public_send(:"#{scope_sym}?") }
+              record.public_send(:"#{column.name}_changed?")
+            else
+              false
+            end
+          end)
 
-          # UNIQUE constraints
-          add_uniqueness_validation(column) if column.unique?
+          validate_logged :validates_uniqueness_of, name, options
         end
-      end
 
-      def add_uniqueness_validation(column) #:nodoc:
-        scope = column.unique_scope.map(&:to_sym)
-        name = column.name.to_sym
-
-        options = {}
-        options[:scope] = scope if scope.any?
-        options[:allow_nil] = true
-        options[:case_sensitive] = false if has_case_insensitive_index?(column, scope)
-        options[:if] = (proc do |record|
-          if scope.all? { |scope_sym| record.public_send(:"#{scope_sym}?") }
-            record.public_send(:"#{column.name}_changed?")
-          else
-            false
-          end
-        end)
-
-        validate_logged :validates_uniqueness_of, name, options
-      end
+        def has_case_insensitive_index?(column, scope)
+          indexed_columns = (scope + [column.name]).map(&:to_sym).sort
+          index = column.indexes.select { |i| i.unique && i.columns.map(&:to_sym).sort == indexed_columns }.first
 
-      def has_case_insensitive_index?(column, scope)
-        indexed_columns = (scope + [column.name]).map(&:to_sym).sort
-        index = column.indexes.select { |i| i.unique && i.columns.map(&:to_sym).sort == indexed_columns }.first
-
-        index && index.respond_to?(:case_sensitive?) && !index.case_sensitive?
-      end
+          index && index.respond_to?(:case_sensitive?) && !index.case_sensitive?
+        end
 
-      def create_schema_validations? #:nodoc:
-        schema_validations_config.auto_create? && !(schema_validations_loaded || abstract_class? || name.blank? || !table_exists?)
-      end
+        def create_schema_validations? #:nodoc:
+          schema_validations_config.auto_create? && !(schema_validations_loaded || abstract_class? || name.blank? || !table_exists?)
+        end
 
-      def validate_logged(method, arg, opts={}) #:nodoc:
-        if _filter_validation(method, arg)
-          msg = "[schema_validations] #{self.name}.#{method} #{arg.inspect}"
-          msg += ", #{opts.inspect[1...-1]}" if opts.any?
-          logger.debug msg
-          send method, arg, opts
+        def validate_logged(method, arg, opts={}) #:nodoc:
+          if _filter_validation(method, arg)
+            msg = "[schema_validations] #{self.name}.#{method} #{arg.inspect}"
+            msg += ", #{opts.inspect[1...-1]}" if opts.any?
+            logger.debug msg
+            send method, arg, opts
+          end
         end
-      end
 
-      def _filter_validation(macro, name) #:nodoc:
-        config = schema_validations_config
-        types = [macro]
-        if match = macro.to_s.match(/^validates_(.*)_of$/)
-          types << match[1].to_sym
+        def _filter_validation(macro, name) #:nodoc:
+          config = schema_validations_config
+          types = [macro]
+          if match = macro.to_s.match(/^validates_(.*)_of$/)
+            types << match[1].to_sym
+          end
+          return false if config.only           and not Array.wrap(config.only).include?(name)
+          return false if config.except         and     Array.wrap(config.except).include?(name)
+          return false if config.whitelist      and     Array.wrap(config.whitelist).include?(name)
+          return false if config.only_type      and not (Array.wrap(config.only_type) & types).any?
+          return false if config.except_type    and     (Array.wrap(config.except_type) & types).any?
+          return false if config.whitelist_type and     (Array.wrap(config.whitelist_type) & types).any?
+          return true
         end
-        return false if config.only           and not Array.wrap(config.only).include?(name)
-        return false if config.except         and     Array.wrap(config.except).include?(name)
-        return false if config.whitelist      and     Array.wrap(config.whitelist).include?(name)
-        return false if config.only_type      and not (Array.wrap(config.only_type) & types).any?
-        return false if config.except_type    and     (Array.wrap(config.except_type) & types).any?
-        return false if config.whitelist_type and     (Array.wrap(config.whitelist_type) & types).any?
-        return true
-      end
 
+      end
     end
 
   end

data/lib/schema_validations/version.rb

@@ -1,3 +1,3 @@
 module SchemaValidations
-  VERSION = "2.0.1"
+  VERSION = "2.0.2"
 end

data/lib/schema_validations.rb

@@ -4,7 +4,6 @@ require 'schema_plus_columns'
 require 'schema_validations/version'
 require 'schema_validations/active_record/validations'
 require 'schema_validations/active_record/type'
-require 'schema_validations/railtie' if defined?(Rails::Railtie)
 
 module SchemaValidations
 
@@ -109,13 +108,6 @@ module SchemaValidations
     yield config
   end
 
-  def self.insert #:nodoc:
-    return if @inserted
-    @inserted = true
-    ::ActiveRecord::Base.extend SchemaValidations::ActiveRecord::Validations
-    ::ActiveRecord::Type::Integer.prepend SchemaValidations::ActiveRecord::Type::Integer
-  end
-
 end
 
-SchemaValidations.insert unless defined? Rails::Railtie
+SchemaMonkey.register SchemaValidations

data/schema_validations.gemspec

@@ -24,7 +24,7 @@ Gem::Specification.new do |s|
   s.add_dependency("activerecord", "~> 4.2", ">= 4.2.1")
   s.add_dependency("valuable")
       
-  s.add_development_dependency("schema_dev", "~> 3.5")
+  s.add_development_dependency("schema_dev", "~> 3.6")
   s.add_development_dependency("rake")
   s.add_development_dependency("rdoc")
   s.add_development_dependency("rspec")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: schema_validations
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.0.2
 platform: ruby
 authors:
 - Ronen Barzel
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-19 00:00:00.000000000 Z
+date: 2016-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: schema_plus_columns
@@ -65,14 +65,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.5'
+        version: '3.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.5'
+        version: '3.6'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement