enforce_schema_rules 0.0.14

data/README

@@ -0,0 +1,89 @@
+Enforce Schema Rules
+=====================
+
+This plugin provides a way to validate your model against databse rules 
+you've already created in your schema, including column lengths for
+strings,  "not null" designations, unique index constraints, and
+ensuring integer input  for integer columns.
+
+The four methods currently supported are: 
+
+	enforce_column_limits
+	enforce_integer_columns
+	enforce_not_null
+	enforce_unique_indexes
+
+You can also just call <tt>enforce_schema_rules</tt> to enforce all the
+above.
+
+Accepts the relevant validates_length_of options (i.e. :on and :message)
+and these assume the usual defaults.
+
+In addition to the regular options, you can also have an
+<tt>:except</tt> list enumerating the column that you don't want to
+validate. 
+
+By default, magic columns (_at, _on, _id, id, position, etc) are
+skipped. If  you'd like to override that behavior, you can define your
+own  <tt>:exclusion_regexp</tt>
+
+Examples:
+
+  class Person < ActiveRecord::Base
+    enforce_schema_rules :except => :dhh
+  end
+
+  class Book < ActiveRecord::Base
+    enforce_column_limits :message => "exceeds the %d character limit", :on => :update
+    enforce_unique_indexes
+    enforce_not_null :exclusion_regexp => /$fk_/
+  end
+
+
+Download
+--------
+
+http://github.com/eric1234/enforce_schema_rules
+
+
+Code of old plugin is located at:
+
+http://enforce-schema-rules.googlecode.com/svn/trunk/enforce_schema_rules/
+
+There is also a Rubyforge project of the old plugin at:
+
+http://rubyforge.org/projects/enforce-schema/
+
+
+Bugs & feedback
+---------------
+Please send bug reports, patches and feedback to Eric Anderson <eric@saveyourcall.com>
+
+Todo
+----
+This updates main goal was to get it to work in Rails 3. Some cleanup
+was just a side-effect. If anybody is interested additional cleanup
+items include:
+
+  * Make sure we don't need better test coverage. The original plugin
+    had tests but I don't believe they worked completely. I fixed up
+    all existing tests to pass but there may be coverage we are missing.
+  * I made the smallest number of changes to get things working under
+    Rails 3. This plugin was written a while back. It might could be
+    refactored using some new goodness that comes with a more recent
+    ActiveRecord/Rails implementation.
+  * I most likely dropped support for Rails 2.x. The old plugin worked
+    fine for those (there are some warnings but they can be fixed
+    fairly easily and don't need to be fixed). I'm not sure if we want
+    one plugin that supports both versions but if there is demand for
+    it somebody could probably do it without too much effort.
+
+Credit
+------
+This is an update to the plugin written by Josh Starcher <josh.starcher@gmail.com>.
+Rails 3 compatibility has been added, it has been converted to a gem
+for easy project inclusion and various other cleanups have been implemented.
+In addition the original plugin gave the following credit notes:
+
+  This plugin is basically an extension of David Easley's enforce-limits
+  plugin. Michael Schuerig provided contributed a patch and a syle lesson.

data/lib/enforce_schema_rules.rb

@@ -0,0 +1,96 @@
+require 'active_record'
+
+module Jls
+  module Validations #:nodoc:
+    module EnforceSchemaRules #:nodoc:
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        # Call all enforcement methods
+        def enforce_schema_rules(options = {})
+          enforce_column_limits(options.dup)
+          enforce_integer_columns(options.dup)
+          enforce_not_null(options.dup)
+          enforce_unique_indexes(options.dup)
+        end
+        
+        # Enforce string column limits
+        def enforce_column_limits(options = {})
+          args = build_validation_args(options, :string, :too_long)
+          return if args.first.is_a?(Hash)
+          options = args.pop
+          validates_each(*args) do |record, attr, value|
+            limit = record.class.columns_hash[attr.to_s].limit
+            if limit
+              message = options[:message] % {:count => limit}
+              record.errors.add(attr, message) unless value.nil? || value.size <= limit
+            end
+          end
+        end
+        
+        # Enforce numericality of integer columns
+        def enforce_integer_columns(options = {})
+          # first get the non-integers
+          options[:allow_nil] = true
+          args = build_validation_args(options, :numeric, :not_a_number)
+          validates_numericality_of(*args) unless args.first.is_a? Hash
+          # now do the integers
+          options[:only_integer] = true
+          args = build_validation_args(options, :integer, :not_a_number)
+          validates_numericality_of(*args) unless args.first.is_a? Hash
+        end
+        
+        # Enfore "not null" columns settings
+        def enforce_not_null(options = {})
+          args = build_validation_args(options, :not_null, :blank)
+          return if args.first.is_a?(Hash)
+          validates_presence_of(*args)
+       end
+        
+        # Enfore unique indexes
+        def enforce_unique_indexes(options = {})
+          attrs = build_validation_args(options, false, :taken)
+          return if attrs.first.is_a?(Hash)
+          options = attrs.pop
+          connection.indexes(table_name).select { |index| index.unique && index.columns.size == 1 && attrs.include?(index.columns.first.to_sym) }.each do |index|
+            validates_uniqueness_of(index.columns.first, options)
+          end
+        end
+        
+        def build_validation_args(options, col_type, validation_option = :invalid)
+          options[validation_option] = I18n.translate('errors.messages')[validation_option]
+          options[:message] ||= options[validation_option]
+          exclusion_regexp = options[:exclusion_regexp] || /(_at|_on|_id)$|^(id|position|type)$/
+          # Determine which columns to validate and symbolize their names
+          condition = case col_type
+                      when :numeric
+                        lambda { |col| col.name !~ exclusion_regexp && col.number? && col.type != :integer }
+                      when :not_null
+                        # I have to exclude boolean types because of a "feature" of the way validates_presence_of 
+                        # handles boolean fields
+                        # See http://dev.rubyonrails.org/ticket/5090 and http://dev.rubyonrails.org/ticket/3334
+                        lambda { |col| (col.name !~ exclusion_regexp || col.name =~ /_id$/) && !col.null && col.type != :boolean }
+                      else
+                        lambda { |col| col.name !~ exclusion_regexp && col_type == col.type }
+                      end
+          cols_to_validate = col_type ? columns.find_all { |col| condition[col] } : columns
+          # exclude columns
+          if except = options[:except]
+            except = Array(except).collect { |attr| attr.to_s }
+            cols_to_validate = cols_to_validate.reject { |col| except.include?(col.name) }
+          end
+          attrs = cols_to_validate.collect { |col| col.name.to_sym }
+          attrs << options
+          attrs
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.class_eval do
+  include Jls::Validations::EnforceSchemaRules
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: enforce_schema_rules
+version: !ruby/object:Gem::Version 
+  hash: 3
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 14
+  version: 0.0.14
+platform: ruby
+authors: 
+- Josh Starcher
+- David Easley
+- Michael Schuerig
+- Eric Anderson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-28 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: "    A macro-style method that will automatically read the database\n    contraints (null requirements, string length, etc) and enforce those\n    at the model level to keep validation more DRY. Provides many\n    options to customize how automatic it is and what columns it affects.\n"
+email: 
+- josh.starcher@gmail.com
+- 
+- 
+- eric@saveyourcall.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- lib/enforce_schema_rules.rb
+- README
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: An ActiveRecord plugin to automatically enforce database contraints
+test_files: []
+