validates_by_schema 0.1.1 → 0.2.0

data/README.md

@@ -3,22 +3,34 @@
 
 Automatic validation based on your database schema column types and limits. Keep your code DRY by inferring column validations from table properties!
 
-## Usage
+## Install
 
 1. Add it to your Gemfile:
 ```ruby
-gem "validates_by_schema", :git => git://github.com/joshwlewis/validates_by_schema.git
+gem "validates_by_schema"
 ```
 
 2. Then `bundle`
 
-3. Add it to your ActiveRecord model:
+3. Call it from your ActiveRecord model:
 ```ruby
 class Widget < ActiveRecord::Base
-  validates_from_schema
+    validates_by_schema
 end
 ```
 
+## Usage
+
+You can also whitelist/blacklist columns with :only and :except options
+
+```ruby
+validates_by_schema only: [:body, :description]
+```
+
+```ruby
+validates_by_schema except: [:name, :title]
+```
+
 ## Example
 
 Say you had a table setup like this:
@@ -30,11 +42,11 @@ create_table "widgets", :force => true do |t|
 end
 ```
 
-Then these validations run when your model `validates_from_schema`:
+Then these validations run when your model `validates_by_schema`:
 ```ruby
-  validates :wheel_count, presence: true, numericality {allow_nil: false, less_than: 2147483647}
-  validates :thickness, numericality: {allow_nil: true, less_than: 0.999, greater_than: -0.999}
+  validates :wheel_count, presence: true, numericality {allow_nil: false, greater_than: -2147483647, less_than: 2147483647}
+  validates :thickness, numericality: {allow_nil: true, less_than_or_equal_to: 0.999, greater_than_or_equal_to: -0.999}
   validates :color, length: {allow_nil: true, maximum: 255}
 ```
 
-This should support any database supported by Rails. I have only tested MySQL up to this point.
+This is tested with postgres, mysql, and sqlite3. It will most likely work with any other database Rails supports.

data/lib/validates_by_schema.rb

@@ -1,10 +1,12 @@
 module ValidatesBySchema
+  autoload :ValidationOption, 'validates_by_schema/validation_option'
+
   extend ActiveSupport::Concern
 
   module ClassMethods
     def validates_by_schema options={}
       return unless table_exists?
-      # Don't auto validated primary keys or timestamps
+      # Don't auto validate primary keys or timestamps
       columns = self.columns.reject(&:primary)
       columns.reject!{|c| ['updated_at', 'created_at'].include? c.name}
 
@@ -18,36 +20,13 @@ module ValidatesBySchema
       end
 
       columns.each do |c|
-        case c.type
-        when :integer
-          val_hash = {presence: !c.null, numericality: { 
-            only_integer: true, allow_nil: c.null}}
-          if c.limit
-            max = (2 ** (8 * c.limit)) / 2
-            val_hash[:numericality][:less_than] = max
-            val_hash[:numericality][:greater_than] = -max
-          end
-          validates c.name, val_hash
-        when :decimal
-          maximum = 10.0**(c.precision-c.scale) - 10.0**(-c.scale)
-          validates c.name, presence: !c.null, numericality: { 
-            allow_nil: c.null, greater_than_or_equal_to: -maximum,
-            less_than_or_equal_to: maximum }
-        when :float
-          validates c.name, presence: !c.null,
-            numericality: { allow_nil: c.null }
-        when :string, :text
-          validates c.name, presence: !c.null, length: { maximum: c.limit.to_i, 
-            allow_nil: c.null}
-        when :boolean
-          validates c.name, inclusion: { in: [true, false], 
-            allow_nil: c.null }
-        when :date, :datetime, :time
-          validates c.name, presence: !c.null
-        end
+        vo = ValidationOption.new(c).to_hash
+        validates c.name, vo if vo.present?
       end
     end
   end
 end
 
-ActiveRecord::Base.send(:include, ValidatesBySchema)
+ActiveSupport.on_load :active_record do
+  include ValidatesBySchema
+end

data/lib/validates_by_schema/validation_option.rb

@@ -0,0 +1,76 @@
+class ValidatesBySchema::ValidationOption
+  # column here must be an ActiveRecord column
+  # i.e. MyARModel.columns.first
+  attr_accessor :column
+
+  def initialize(column)
+    @column = column
+  end
+
+  def presence?
+    presence && column.type != :boolean
+  end
+
+  def presence
+    !column.null
+  end
+
+  def numericality?
+    [:integer, :decimal, :float].include? column.type
+  end
+
+  def numericality
+    numericality = {}
+    if column.type == :integer
+      numericality[:only_integer] = true
+      if integer_max
+        numericality[:less_than] = integer_max
+        numericality[:greater_than] = -integer_max
+      end
+    elsif column.type == :decimal
+      numericality[:less_than_or_equal_to] = decimal_max
+      numericality[:greater_than_or_equal_to] = -decimal_max
+    end
+    numericality[:allow_nil] = column.null
+    numericality
+  end
+
+  def length?
+    [:string, :text].include?(column.type) && column.limit
+  end
+
+  def length
+    {:maximum => column.limit, :allow_nil => column.null }
+  end
+
+  def inclusion?
+    column.type == :boolean
+  end
+
+  def inclusion
+    {:in => [true, false], :allow_nil => column.null}
+  end
+
+  def integer_max
+    (2 ** (8 * column.limit)) / 2 if column.limit
+  end
+
+  def decimal_max
+    10.0**(column.precision-column.scale) - 10.0**(-column.scale)
+  end
+
+  def string_max
+    column.limit
+  end
+
+  def to_hash
+    [:presence, :numericality, :length, :inclusion].inject({}) do |h,k|
+      send(:"#{k}?") ? h.merge(k => send(k)) : h
+    end
+  end
+
+  def to_s
+    to_hash.inspect
+  end
+
+end

data/lib/validates_by_schema/version.rb

@@ -1,3 +1,3 @@
 module ValidatesBySchema
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: validates_by_schema
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-10 00:00:00.000000000 Z
+date: 2012-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -75,6 +75,38 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Keep your code DRY by inferring column validations from table properties!
   Automagically validate presence, length, numericality, and inclusion of ActiveRecord
   backed columns.
@@ -85,6 +117,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/tasks/validates_by_schema_tasks.rake
+- lib/validates_by_schema/validation_option.rb
 - lib/validates_by_schema/version.rb
 - lib/validates_by_schema.rb
 - MIT-LICENSE