schema_validations 0.1.0.pre4

data/.gitignore

@@ -0,0 +1,25 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+.*.sw?
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC
+.rvmrc
+*.log
+*.sqlite3
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,25 @@
+Copyright (c) 2006 RedHill Consulting, Pty. Ltd.
+Copyright (c) 2011 Ronen Barzel & Michał Łomnicki
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+Except as contained in this notice, the name(s) of the above copyright
+holders shall not be used in advertising or otherwise to promote the sale,
+use or other dealings in this Software without prior written authorization.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,125 @@
+= SchemaValidations
+
+== Overview
+
+One of the great things about Rails (ActiveRecord, in particular) is that it
+inspects the database and automatically defines accessors for all your
+columns, keeping your model class definitions simple and DRY.  That's great
+for simple data columns, but where it falls down is when your table
+contains constraints.
+
+    create_table :users do |t|
+      t.string :email, :null => false, :limit => 30
+      t.boolean :confirmed, :null => false
+    end
+
+In that case :null => false, :limit => 30 and :boolean must be covered on the model level.
+
+    class User < ActiveRecord::Base
+      validates :email, :presence => true, :length => 30
+      validates :confirmed, :presence => true, :inclusion => { :in => [true, false] }
+    end
+
+...which isn't the most DRY approach.
+
+SchemaValidations aims to cover that and does boring work for you. It inspect
+the database and automatically creates validations basing on the schema. After
+installing it your model is as simple as it can be.
+
+    class User < ActiveRecord::Base
+    end
+
+Validations are there but they are created by schema_validations under the hood.
+
+== Installation
+
+Simply add schema_validations to your Gemfile.
+
+    gem "schema_validations"
+
+== What if I want something special?
+
+SchemaValidations is highly customizable. You can configure behavior
+globally via SchemaValidations.setup or per-model via
+SchemaValidations::ActiveRecord::schema_validations, such as:
+
+    class User < ActiveRecord::Base
+      schema_validations :except => :email
+      validates :email, :presence => true, :length => { :in => 5..30 }
+    end
+
+See SchemaValidations::Config for the available options.
+
+== Which validations are covered?
+
+Constraints:
+
+    |      Constraint     |                     Validation                           |
+    |---------------------|----------------------------------------------------------|
+    | :null => false      | validates ... :presence => true                          |
+    | :limit => 100       | validates ... :length => { :maximum => 100 }             |
+    | :unique => true     | validates ... :uniqueness => true                        |
+
+Data types:
+
+    |         Type       |                      Validation                           |
+    |--------------------|-----------------------------------------------------------|
+    | :boolean           | :validates ... :inclusion => { :in => [true, false] }     |
+    | :float             | :validates ... :numericality => true                      |
+    | :integer           | :validates ... :numericality => { :only_integer => true } |
+
+== Dependency
+
+SchemaValidations uses the {+schema_plus+}[http://rubygems.org/gems/schema_plus] gem for its schema
+queries.  That gem will by default auto-create foreign key constraints that
+you probably want -- but if you don't want them, you can disable them using
+{+schema_plus+}[http://rubygems.org/gems/schema_plus]'s config.
+
+== Compatibility
+
+SchemaValidations supports all combinations of:
+* rails 3.0 or 3.1
+* MRI ruby 1.8.7 or 1.9.2
+
+== How do I know what it did?
+If you're curious (or dubious) about what validations SchemaValidations defines, you can check the log file.  For every assocation that SchemaValidations defines, it generates an info entry such as
+
+    [schema_validations] Article.validates_length_of :title, :allow_nil=>true, :maximum=>50
+
+which shows the exact validation definition call.  
+
+SchemaValidations defines the validations lazily, only creating them when a
+record of the class is first accessed.  So you may need to search through
+the log file for "schema_validations" to find them all (and some may not be
+defined at all if they were never needed for the logged use case).
+
+== I don't use constraints
+TODO and blame you
+
+== History
+
+* SchemaValidations is derived from the "Red Hill On Rails" plugin schema_validations originally created by harukizaemon (https://github.com/harukizaemon)
+
+* SchemaValidations was created in 2011 by Michał Łomnicki and Ronen Barzel
+
+== Testing
+
+SchemaValidations is tested using rspec, sqlite3, and rvm, with some
+hackery to test against multiple versions of rails and ruby.  To run the
+full combo of tests, after you've forked & cloned:
+
+  $ cd schema_validations
+  $ ./runspecs --install  # do this once to install gem dependencies for all versions (slow)
+  $ ./runspecs # as many times as you like
+
+You can also pick a specific version of rails and ruby to use, such as:
+  $ rvm use 1.9.2
+  $ export SCHEMA_VALIDATIONS_RAILS_VERSION=3.1
+  $ bundle update --local rails
+  $ rake spec
+
+If you're running ruby 1.9.2, code coverage results will be in coverage/index.html -- it should be at 100% coverage.
+
+== License
+
+This gem is released under the MIT license.

data/Rakefile

@@ -0,0 +1,19 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.rspec_opts = '-Ispec'
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "schema_validations #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/init.rb

@@ -0,0 +1 @@
+require 'schema_validations' unless defined?(SchemaValidations)

data/lib/schema_validations.rb

@@ -0,0 +1,104 @@
+require 'valuable'
+
+require 'schema_plus'
+require 'schema_validations/version'
+require 'schema_validations/active_record/validations'
+require 'schema_validations/railtie' if defined?(Rails)
+
+module SchemaValidations
+
+  # The configuation options for SchemaValidations. Set them globally in
+  # <tt>config/initializers/schema_validations.rb</tt>, e.g.:
+  #
+  #    SchemaValidations.setup do |config|
+  #       config.auto_create = false
+  #    end
+  #
+  # or override them per-model, e.g.:
+  #
+  #     class MyModel < ActiveRecord::Base
+  #        schema_validations :only => [:name, :active]
+  #     end
+  #
+  class Config < Valuable
+    ##
+    # :attr_accessor: auto_create
+    #
+    # Whether to automatically create validations based on database constraints.
+    # Boolean, default is +true+.
+    has_value :auto_create, :klass => :boolean, :default => true
+
+    ##
+    # :attr_accessor: only
+    #
+    # List of field names to include in automatic validation.
+    # Value is a single name, and array of names, or +nil+.  Default is +nil+.
+    has_value :only, :default => nil
+
+    ##
+    # :attr_accessor: except
+    #
+    # List of field names to exclude from automatic validation.
+    # Value is a single name, an array of names, or +nil+.  Default is <tt>[:created_at, :updated_at, :created_on, :updated_on]</tt>.
+    has_value :except, :default => [:created_at, :updated_at, :created_on, :updated_on]
+
+    ##
+    # :attr_accessor: only_type
+    #
+    # List of validation types to exclude from automatic validation.
+    # Value is a single type, and array of types, or +nil+.  Default is +nil+.
+    # A type is specified as, e.g., +:validates_presence_of+ or simply +:presence+.
+    has_value :except_type, :default => nil
+
+    ##
+    # :attr_accessor: only_type
+    #
+    # List of validation types to include in automatic validation.
+    # Value is a single type, and array of types, or +nil+.  Default is +nil+.
+    # A type is specified as, e.g., +:validates_presence_of+ or simply +:presence+.
+    has_value :only_type, :default => nil
+
+    def dup #:nodoc:
+      self.class.new(Hash[attributes.collect{ |key, val| [key, Valuable === val ?  val.class.new(val.attributes) : val] }])
+    end
+
+    def update_attributes(opts)#:nodoc:
+      opts = opts.dup
+      opts.keys.each { |key| self.send(key).update_attributes(opts.delete(key)) if self.class.attributes.include? key and Hash === opts[key] }
+      super(opts)
+      self
+    end
+
+    def merge(opts)#:nodoc:
+      dup.update_attributes(opts)
+    end
+
+  end
+
+  # Returns the global configuration, i.e., the singleton instance of Config
+  def self.config
+    @config ||= Config.new
+  end
+
+  # Initialization block is passed a global Config instance that can be
+  # used to configure SchemaValidations behavior.  E.g., if you want to
+  # disable automation creation validations put the following in
+  # config/initializers/schema_validations.rb :
+  #
+  #    SchemaValidations.setup do |config|
+  #       config.auto_create = false
+  #    end
+  #
+  def self.setup # :yields: config
+    yield config
+  end
+
+  def self.insert #:nodoc:
+    return if @inserted
+    @inserted = true
+    ::ActiveRecord::Base.extend SchemaValidations::ActiveRecord::Validations
+  end
+
+end
+
+SchemaValidations.insert unless defined? Rails::Railtie

data/lib/schema_validations/active_record/validations.rb

@@ -0,0 +1,133 @@
+module SchemaValidations
+  module ActiveRecord
+    module Validations
+
+      # Per-model override of Config options.  Use via, e.g.
+      #     class MyModel < ActiveRecord::Base
+      #         schema_associations :auto_create => false
+      #     end
+      def schema_validations(opts)
+        @schema_validations_config = SchemaValidations.config.merge(opts)
+      end
+
+      def schema_validations_config # :nodoc:
+        @schema_validations_config ||= SchemaValidations.config.dup
+      end
+
+      def define_attribute_methods(*) #:nodoc:
+        super
+        load_schema_validations
+      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
+        @schema_validations_loaded = true
+      end
+
+      def load_column_validations #:nodoc:
+        content_columns.each do |column|
+          name = column.name.to_sym
+
+          # Data-type validation
+          if column.type == :integer
+            validate_logged :validates_numericality_of, name, :allow_nil => true, :only_integer => true
+          elsif column.number?
+            validate_logged :validates_numericality_of, name, :allow_nil => true
+          elsif column.text? && column.limit
+            validate_logged :validates_length_of, name, :allow_nil => true, :maximum => column.limit
+          end
+
+          # NOT NULL constraints
+          if column.required_on
+            if column.type == :boolean
+              validate_logged :validates_inclusion_of, name, :in => [true, false], :message => :blank
+            else
+              validate_logged :validates_presence_of, name
+            end
+          end
+
+          # UNIQUE constraints
+          add_uniqueness_validation(column) if column.unique?
+        end
+      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
+
+          # NOT NULL constraints
+          validate_logged :validates_presence_of, association.name if column.required_on
+
+          # UNIQUE constraints
+          add_uniqueness_validation(column) if column.unique?
+        end
+      end
+
+      def add_uniqueness_validation(column) #:nodoc:
+        scope = column.unique_scope.map(&:to_sym)
+        condition = :"#{column.name}_changed?"
+        name = column.name.to_sym
+        validate_logged :validates_uniqueness_of, name, :scope => scope, :allow_nil => true, :if => condition
+      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.info msg
+          send method, arg, opts
+        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
+        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.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 true
+      end
+
+    end
+
+  end
+end

data/lib/schema_validations/railtie.rb

@@ -0,0 +1,11 @@
+module SchemaValidations
+  class Railtie < Rails::Railtie #:nodoc:
+
+    initializer 'schema_validations.insert', :after => "schema_plus.insert" do
+      ActiveSupport.on_load(:active_record) do
+        SchemaValidations.insert
+      end
+    end
+
+  end
+end

data/lib/schema_validations/version.rb

@@ -0,0 +1,3 @@
+module SchemaValidations
+  VERSION = "0.1.0.pre4"
+end

data/runspecs

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+
+RUBY_VERSIONS = %W[1.8.7 1.9.2]
+RAILS_VERSIONS = %W[3.0 3.1]
+
+options = {}
+OptionParser.new do |opts|
+    opts.banner = "Usage: #{$0} [options]"
+
+    opts.on("--install", "Install gem dependencies") do |v|
+        options[:install] = v
+    end
+end.parse!
+
+cmds = if options [:install]
+           ['bundle update']
+       else
+           ['bundle update --local rails | grep rails', 'rake spec']
+       end
+
+n = 1
+total = RUBY_VERSIONS.size * RAILS_VERSIONS.size
+RUBY_VERSIONS.each do |ruby|
+    RAILS_VERSIONS.each do |rails|
+        puts "\n\n*** ruby version #{ruby} - rails version #{rails}  [#{n} of #{total}]\n\n"
+        n += 1
+        allcmds = []
+        allcmds << "rvm use #{ruby}"
+        allcmds << "export SCHEMA_VALIDATIONS_RAILS_VERSION=#{rails}"
+        allcmds += cmds
+        allcmds << 'exit'
+        system %Q{echo '#{allcmds.join(' \n ')}' | bash -i} or abort "aborting #{$0}"
+    end
+end

data/schema_validations.gemspec

@@ -0,0 +1,42 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "schema_validations/version"
+
+Gem::Specification.new do |s|
+  s.name        = "schema_validations"
+  s.version     = SchemaValidations::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Ronen Barzel", "Michał Łomnicki"]
+  s.email       = ["ronen@barzel.org", "michal.lomnicki@gmail.com"]
+  s.homepage    = "https://github.com/lomba/schema_validations"
+  s.summary     = "Automatically creates validations basing on the database schema."
+  s.description = "SchemaValidations extends ActiveRecord to automatically create validations by inspecting the database schema. This makes your models more DRY as you no longer need to duplicate NOT NULL, unique, numeric and varchar constraints on the model level."
+
+  s.rubyforge_project = "schema_validations"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency("schema_plus")
+      
+  case ENV['SCHEMA_VALIDATIONS_RAILS_VERSION']
+  when '3.0'
+      s.add_development_dependency("rails", "~> 3.0")
+      s.add_development_dependency("mysql2", "~> 0.2.6")
+  when '3.1'
+      s.add_development_dependency("rails", ">= 3.1.0.rc4")
+      s.add_development_dependency("mysql2")
+  else
+      s.add_development_dependency("mysql2")
+  end
+
+  s.add_development_dependency("rake", "~> 0.8.7")
+  s.add_development_dependency("rspec")
+  s.add_development_dependency("sqlite3")
+  s.add_development_dependency("simplecov")
+  s.add_development_dependency("simplecov-gem-adapter")
+  s.add_development_dependency("ruby-debug19") if RUBY_VERSION >= "1.9.2"
+end
+

data/spec/connection.rb

@@ -0,0 +1,13 @@
+require 'logger'
+
+ActiveRecord::Base.logger = Logger.new(File.open("sqlite3.log", "w"))
+
+ActiveRecord::Base.configurations = {
+  'schema_plus' => {
+    :adapter => 'sqlite3',
+    :database => File.expand_path('schema_plus.sqlite3', File.dirname(__FILE__)),
+  }
+
+}
+
+ActiveRecord::Base.establish_connection 'schema_plus'

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+if RUBY_VERSION > "1.9"
+  require 'simplecov'
+  require 'simplecov-gem-adapter'
+  SimpleCov.start "gem"
+end
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'rspec'
+require 'active_record'
+require 'schema_validations'
+require 'logger'
+require 'connection'
+
+Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each {|f| require f}
+
+def remove_all_models
+  ObjectSpace.each_object(Class) do |c|
+    next unless c.ancestors.include? ActiveRecord::Base
+    next if c == ActiveRecord::Base
+    next if c.name.blank?
+    ActiveSupport::Dependencies.remove_constant c.name
+  end
+end
+
+SimpleCov.command_name ActiveRecord::Base.connection.adapter_name if defined? SimpleCov

data/spec/support/active_model.rb

@@ -0,0 +1,13 @@
+# ported from rspec-rails
+# There is no reason to install whole gem as we
+# need only that tiny helper
+module ::ActiveModel::Validations
+
+  def error_on(attribute)
+    self.valid?
+    [self.errors[attribute]].flatten.compact
+  end
+
+  alias :errors_on :error_on
+
+end

data/spec/validations_spec.rb

@@ -0,0 +1,296 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Validations" do
+
+  before(:all) do
+    define_schema
+  end
+
+  after(:each) do
+    remove_all_models
+  end
+
+  context "auto-created" do
+    before(:each) do
+      with_auto_validations do
+        class Article < ActiveRecord::Base ; end
+
+        class Review < ActiveRecord::Base
+          belongs_to :article
+          belongs_to :news_article, :class_name => 'Article', :foreign_key => :article_id
+          schema_validations :except => :content
+        end
+      end
+    end
+
+    it "should be valid with valid attributes" do
+      Article.new(valid_attributes).should be_valid
+    end
+
+    it "should validate content presence" do
+      post = Article.new.should have(1).error_on(:content)
+    end
+
+    it "should check title length" do
+      Article.new(:title => 'a' * 100).should have(1).error_on(:title)
+    end
+
+    it "should validate state numericality" do
+      Article.new(:state => 'unknown').should have(1).error_on(:state)
+    end
+
+    it "should validate if state is integer" do
+      Article.new(:state => 1.23).should have(1).error_on(:state)
+    end
+
+    it "should validate average_mark numericality" do
+      Article.new(:average_mark => "high").should have(1).error_on(:average_mark)
+    end
+
+    it "should validate boolean fields" do
+      Article.new(:active => nil).should have(1).error_on(:active)
+    end
+
+    it "should validate title uniqueness" do
+      article1 = Article.create(valid_attributes)
+      article2 = Article.new(:title => valid_attributes[:title])
+      article2.should have(1).error_on(:title)
+      article1.destroy
+    end
+
+    it "should validate state uniqueness in scope of 'active' value" do
+      article1 = Article.create(valid_attributes)
+      article2 = Article.new(valid_attributes.merge(:title => 'SchemaPlus 2.0 released'))
+      article2.should_not be_valid
+      article2.toggle(:active)
+      article2.should be_valid
+      article1.destroy
+    end
+
+    it "should validate presence of belongs_to association" do
+      review = Review.new
+      review.should have(1).error_on(:article)
+    end
+
+    it "should validate uniqueness of belongs_to association" do
+      article = Article.create(valid_attributes)
+      article.should be_valid
+      review1 = Review.create(:article => article, :author => 'michal')
+      review1.should be_valid
+      review2 = Review.new(:article => article, :author => 'michal')
+      review2.should have_at_least(1).error_on(:article_id)
+    end
+
+    it "should validate associations with unmatched column and name" do
+      Review.new.should have(1).error_on(:news_article)
+    end
+
+    def valid_attributes
+      {
+        :title => 'SchemaPlus released!',
+        :content => "Database matters. Get full use of it but don't write unecessary code. Get SchemaPlus!",
+        :state => 3,
+        :average_mark => 9.78,
+        :active => true
+      }
+    end
+
+  end
+
+  context "auto-created but changed" do
+    before(:each) do
+      with_auto_validations do
+        class Article < ActiveRecord::Base ; end
+        class Review < ActiveRecord::Base
+          belongs_to :article
+          belongs_to :news_article, :class_name => 'Article', :foreign_key => :article_id
+        end
+      end
+      @too_big_content = 'a' * 1000
+    end
+
+    it "would normally have an error" do
+      @review = Review.new(:content => @too_big_content)
+      @review.should have(1).error_on(:content)
+      @review.should have(1).error_on(:author)
+    end
+
+    it "shouldn't validate fields passed to :except option" do
+      Review.schema_validations :except => :content
+      @review = Review.new(:content => @too_big_content)
+      @review.should have(:no).errors_on(:content)
+      @review.should have(1).error_on(:author)
+    end
+
+    it "shouldn't validate types passed to :except_type option using full validation" do
+      Review.schema_validations :except_type => :validates_length_of
+      @review = Review.new(:content => @too_big_content)
+      @review.should have(:no).errors_on(:content)
+      @review.should have(1).error_on(:author)
+    end
+
+    it "shouldn't validate types passed to :except_type option using shorthand" do
+      Review.schema_validations :except_type => :length
+      @review = Review.new(:content => @too_big_content)
+      @review.should have(:no).errors_on(:content)
+      @review.should have(1).error_on(:author)
+    end
+
+    it "should only validate type passed to :only_type option" do
+      Review.schema_validations :only_type => :length
+      @review = Review.new(:content => @too_big_content)
+      @review.should have(1).error_on(:content)
+      @review.should have(:no).errors_on(:author)
+    end
+
+
+    it "shouldn't create validations if locally disabled" do
+      Review.schema_validations :auto_create => false
+      @review = Review.new(:content => @too_big_content)
+      @review.should have(:no).errors_on(:content)
+      @review.should have(:no).error_on(:author)
+    end
+  end
+
+  context "auto-created disabled" do
+    around(:each) do |example|
+      with_auto_validations(false, &example)
+    end
+
+    before(:each) do
+      class Review < ActiveRecord::Base
+        belongs_to :article
+        belongs_to :news_article, :class_name => 'Article', :foreign_key => :article_id
+      end
+      @too_big_content = 'a' * 1000
+    end
+
+    it "should not create validation" do
+      Review.new(:content => @too_big_title).should have(:no).errors_on(:content)
+    end
+
+    it "should create validation if locally enabled" do
+      Review.schema_validations :auto_create => true
+      Review.new(:content => @too_big_content).should have(1).error_on(:content)
+    end
+
+  end
+
+  context "manually invoked" do
+    before(:each) do
+      class Article < ActiveRecord::Base ; end
+      Article.schema_validations :only => [:title, :state]
+
+      class Review < ActiveRecord::Base
+        belongs_to :dummy_association
+        schema_validations :except => :content
+      end
+    end
+
+    it "should validate fields passed to :only option" do
+      too_big_title = 'a' * 100
+      wrong_state = 'unknown'
+      article = Article.new(:title => too_big_title, :state => wrong_state)
+      article.should have(1).error_on(:title)
+      article.should have(1).error_on(:state)
+    end
+
+    it "shouldn't validate skipped fields" do
+      article = Article.new
+      article.should have(:no).errors_on(:content)
+      article.should have(:no).errors_on(:average_mark)
+    end
+
+    it "shouldn't validate association on unexisting column" do
+      Review.new.should have(:no).errors_on(:dummy_association)
+    end
+
+    it "shouldn't validate fields passed to :except option" do
+      Review.new.should have(:no).errors_on(:content)
+    end
+
+    it "should validate all fields but passed to :except option" do
+      Review.new.should have(1).error_on(:author)
+    end
+
+  end
+
+  context "manually invoked" do
+    before(:each) do
+      class Review < ActiveRecord::Base
+        belongs_to :article
+      end
+      @columns = Review.content_columns.dup
+      Review.schema_validations :only => [:title]
+    end
+
+    it "shouldn't validate associations not included in :only option" do
+      Review.new.should have(:no).errors_on(:article)
+    end
+
+    it "shouldn't change content columns of the model" do
+      @columns.should == Review.content_columns
+    end
+
+  end
+
+  context "when used with STI" do
+    around(:each) { |example| with_auto_validations(&example) }
+
+    it "should set validations on base class" do
+      class Review < ActiveRecord::Base ; end
+      class PremiumReview < Review ; end
+      PremiumReview.new
+      Review.new.should have(1).error_on(:author)
+    end
+
+    it "shouldn't create doubled validations" do
+      class Review < ActiveRecord::Base ; end
+      Review.new
+      class PremiumReview < Review ; end
+      PremiumReview.new.should have(1).error_on(:author)
+    end
+
+  end
+
+  protected
+  def with_auto_validations(value = true)
+    old_value = SchemaValidations.config.auto_create
+    begin
+      SchemaValidations.setup do |config|
+        config.auto_create = value
+      end
+      yield
+    ensure
+      SchemaValidations.config.auto_create = old_value
+    end
+  end
+
+  def define_schema
+    ActiveRecord::Migration.suppress_messages do
+      ActiveRecord::Schema.define do
+        connection.tables.each do |table| drop_table table end
+
+        create_table :articles, :force => true do |t|
+          t.string :title, :limit => 50
+          t.text  :content, :null => false
+          t.integer :state
+          t.float   :average_mark, :null => false
+          t.boolean :active, :null => false
+        end
+        add_index :articles, :title, :unique => true
+        add_index :articles, [:state, :active], :unique => true
+
+        create_table :reviews, :force => true do |t|
+          t.integer :article_id, :null => false
+          t.string :author, :null => false
+          t.string :content, :limit => 200
+          t.string :type
+        end
+        add_index :reviews, :article_id, :unique => true
+
+      end
+    end
+  end
+
+end

metadata

@@ -0,0 +1,168 @@
+--- !ruby/object:Gem::Specification 
+name: schema_validations
+version: !ruby/object:Gem::Version 
+  prerelease: true
+  segments: 
+  - 0
+  - 1
+  - 0
+  - pre4
+  version: 0.1.0.pre4
+platform: ruby
+authors: 
+- Ronen Barzel
+- "Micha\xC5\x82 \xC5\x81omnicki"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-25 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: schema_plus
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: mysql2
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 8
+        - 7
+        version: 0.8.7
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: sqlite3
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: simplecov
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: simplecov-gem-adapter
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id007
+description: SchemaValidations extends ActiveRecord to automatically create validations by inspecting the database schema. This makes your models more DRY as you no longer need to duplicate NOT NULL, unique, numeric and varchar constraints on the model level.
+email: 
+- ronen@barzel.org
+- michal.lomnicki@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- init.rb
+- lib/schema_validations.rb
+- lib/schema_validations/active_record/validations.rb
+- lib/schema_validations/railtie.rb
+- lib/schema_validations/version.rb
+- runspecs
+- schema_validations.gemspec
+- spec/connection.rb
+- spec/spec_helper.rb
+- spec/support/active_model.rb
+- spec/validations_spec.rb
+has_rdoc: true
+homepage: https://github.com/lomba/schema_validations
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
+requirements: []
+
+rubyforge_project: schema_validations
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Automatically creates validations basing on the database schema.
+test_files: []
+