themis 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f56efba984b1bd0789799d9dc814f19bbaa3fc17
+  data.tar.gz: 1849671bff67b2cf9a1fa3ed0e6a13721e08af5e
+SHA512:
+  metadata.gz: 085e50ffaada519d96163830581c7c8c4e586edf2a4e97223cb649d41105c1e87fdde42f177a6b7353f19393de5c20d9c286841b012344bb0ee91066f06c3112
+  data.tar.gz: dc74d323204022de865f3f607e554d18065126e368b67129b6ae46377d979476aa9a43ebe95b473c888248a7bcc9999d32b7cebadee444f44313568de592f68f

data/README.markdown

@@ -0,0 +1,213 @@
+# Themis
+
+[![Build Status](https://secure.travis-ci.org/TMXCredit/themis.png)](http://travis-ci.org/TMXCredit/themis)
+[![Dependency Status](https://gemnasium.com/TMXCredit/themis.png)](https://gemnasium.com/TMXCredit/themis)
+[![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/TMXCredit/themis)
+
+Modular and switchable validations for ActiveRecord models.
+
+## Usage
+
+### Define validation module
+
+```ruby
+module PersonValidation
+  extend Themis::Validation
+
+  validates_presence_of :first_name
+  validates_presence_of :last_name
+end
+```
+
+### Mix validation modules
+
+```ruby
+module UserValidation
+  extend Themis::Validation
+
+  # use all validators defined in PersonValidation
+  include PersonValidation
+
+  validates :email, :format => {:with /\A.*@.*\z/ }, :presence => true
+  validate_presence_of :spouse, :if => :married?
+end
+```
+
+### ActiveRecord model
+
+#### Including validation modules in models:
+
+You can include a validation module in a ActiveRecord model to apply to the model all validators
+defined in the module:
+
+```ruby
+class User < ActiveRecord::Base
+  include UserValidation
+end
+```
+
+It's equivalent to:
+
+```ruby
+class User < ActiveRecord::Base
+  validates_presence_of :first_name
+  validates_presence_of :last_name
+  validates :email, :format => {:with /\A.*@.*\z/ }, :presence => true
+  validate_presence_of :spouse, :if => :married?
+end
+```
+
+#### Using has\_validation and use\_validation methods
+
+You can define a number of validator sets for a model using the `.has_validation` method. So you can
+choose with the `#use_validation` method which validator set to use depending on the context.
+
+```ruby
+class User < ActiveRecord::Base
+  has_validation :soft, PersonValidation
+  has_validation :hard, UserValidation
+end
+
+user = User.new
+user.valid?                   # no validators are used
+user.use_validation(:soft)
+user.valid?                   # validate first_name and last_name
+user.use_validation(:hard)
+user.valid?                   # validate first_name, last_name, email and spouse(if user is married)
+
+user.use_no_validation
+user.valid?                   # no validators are used
+```
+
+#### has\_validation syntax
+
+##### With module:
+
+```ruby
+has_validation :soft, SoftValidation
+```
+
+##### With block:
+
+```ruby
+has_validation :hard do |model|
+  # you can include validation module within block as well
+  model.include SoftValidation
+  model.validate_presence_of :email
+end
+```
+
+##### With module and block:
+
+```ruby
+# It's equivalent to the example above
+has_validation :hard, SoftValidation do |model|
+  model.validate_presence_of :email
+end
+```
+
+##### Multiple validations with one block or module:
+
+```ruby
+# declare :soft and :hard validation
+has_validation :soft, :hard, SoftValidation
+
+# extended :hard validation
+has_validation :hard do |model|
+  model.validate_presence_of :email
+end
+```
+
+
+##### Option `:default`:
+
+```ruby
+class User < ActiveRecord::Base
+   has_validation :soft, PersonValidation, :default => true
+end
+
+user = User.new
+user.themis_validation  # => :soft
+```
+
+##### Option `:nested`:
+
+The `:nested` option causes the `use_validation` method to be called recursively on associations passed to it.
+It receives a symbol or array of symbols with association names.
+
+```ruby
+class User < ActiveRecord::Base
+  has_one :account
+  has_validation :soft, PersonValidation, :nested => :account
+end
+
+class Account < ActiveRecord::Base
+  has_validation :soft do |model|
+    model.validates_presence_of :nickname
+  end
+end
+
+user = User.first
+user.themis_validation            # => nil
+user.account.themis_validation    # => nil
+user.use_validation(:soft)
+user.themis_validation            # => :soft
+user.account.themis_validation    # => :soft
+```
+
+#### Using use\_nested\_validation\_on method
+
+If you don't want to repeat yourself with the `:nested` option:
+
+```ruby
+class User
+  has_validation :none, NoneValidation, :nested => [:accounts, :preferences, :info]
+  has_validation :soft, SoftValidation, :nested => [:accounts, :preferences, :info]
+  has_validation :hard, HardValidation, :nested => [:accounts, :preferences, :info]
+end
+```
+
+You can use `use_nested_validation_on` method:
+
+```ruby
+class User
+  use_nested_validation_on :accounts, :preferences, :info
+  has_validation :none, NoneValidation
+  has_validation :soft, SoftValidation
+  has_validation :hard, HardValidation
+end
+```
+
+Also `use_nested_validation_on` supports deep nesting:
+
+```ruby
+class User
+  use_nested_validation_on :preferences, :info => [:email, :history]
+end
+```
+
+# Running specs
+
+To run specs:
+
+```
+rake spec
+```
+
+To verify test coverage use SimpleCov with Ruby 1.9.3:
+
+```
+rvm use 1.9.3
+bundle install
+rake spec
+$BROWSER ./coverage/index.html
+```
+
+
+## Credits
+
+* [Potapov Sergey](https://github.com/greyblake)
+
+## Copyright
+
+Copyright (c) 2013 TMX Credit.

data/lib/themis/ar/association_extension.rb

@@ -0,0 +1,25 @@
+module Themis
+  module AR
+    # Extends ActiveRecord::Associations::Association
+    # Hooks load_target method with to process after_association_loaded callback.
+    module AssociationExtension
+      extend ActiveSupport::Concern
+
+      # Run original load_target method and process after_association_loaded
+      # callback.
+      def load_target_with_after_association_loaded(*args, &block)
+        result = load_target_without_after_association_loaded(*args, &block)
+
+        if callback = self.owner._after_association_loaded_callbacks[self.reflection.name]
+          callback.call(self)
+        end
+
+        result
+      end
+
+      included do
+        alias_method_chain :load_target, :after_association_loaded
+      end
+    end
+  end
+end

data/lib/themis/ar/base_extension.rb

@@ -0,0 +1,115 @@
+module Themis
+  module AR
+    # Extends ActiveRecord::Base to make it support has_validation and use_validation
+    # methods.
+    # It adds some class attributes to model:
+    # * themis_validation - name of validation, symbol or nil
+    # * themis_validation_sets - hash where key is symbol(validation name) and value is {ValidationSet}.
+    # * themis_default_validation - name of default validation.
+    # * themis_default_nested - default value for :nested option
+    module BaseExtension
+      extend ActiveSupport::Autoload
+
+      # :nodoc:
+      def self.included(base)
+        base.extend         ClassMethods
+        base.send :include, InstanceMethods
+        base.send :include, Callbacks
+
+        base.class_eval(<<-eoruby, __FILE__, __LINE__+1)
+          attr_reader :themis_validation
+
+          class_attribute :themis_validation_sets
+          class_attribute :themis_default_validation
+          class_attribute :themis_default_nested
+
+          delegate :has_themis_validation?, :to => "self.class"
+        eoruby
+      end
+
+      # :nodoc:
+      module ClassMethods
+        # @overload has_validation(name, options, &block)
+        #   Declare validation set using block
+        #   @example
+        #     has_validation :soft, :nested => :account, :default => true do |validation|
+        #       validation.validates_presence_of :some_date
+        #     end
+        #   @param [Symbol] name name of validation set
+        #   @param [Hash] options options: :default, :nested
+        #   @param [Proc] block proc which receives {ModelProxy} and defines validators
+        #   @option options [Boolean] :default make it validation be used by default
+        #   @option options [Symbol, Array<Symbol>] :nested association which should be affected when validation {#use_validation} is called
+        #
+        # @overload has_validation(name_1, name_2, options, &block)
+        #   Declare validation in 2 sets using a block:
+        #   @example
+        #     has_validation :soft, :hard :nested => :account, :default => true do |validation|
+        #       validation.validates_presence_of :some_date
+        #     end
+        #
+        # @overload has_validation(name, validation_module, options, &block)
+        #   Declare validation set on model using {Themis::Validation validation module} or(and) block.
+        #   @example
+        #     has_validation :soft, SoftValidation, :default => true
+        #   @param [Symbol] name name of validation set
+        #   @param [Module] validation_module module extended by {Themis::Validation}.
+        #   @param [Hash] options options: :default, :nested
+        #   @param [Proc] block proc which receives {ModelProxy} and defines validators
+        #   @option options [Boolean] :default make it validation be used by default
+        #   @option options [Symbol, Array<Symbol>] :nested association which should be affect when validation {#use_validation} is called
+        def has_validation(*args_and_options, &block)
+          options           = args_and_options.extract_options!
+          names, args       = args_and_options.partition { |obj| obj.class.in?([String, Symbol]) }
+          validation_module = args.first
+          Themis::AR::HasValidationMethod.new(self, names, validation_module, options, block).execute!
+        end
+
+        # Verify that model has {ValidationSet validation set} with passed name.
+        # @param [Symbol] name name of validation set
+        def has_themis_validation?(name)
+          themis_validation_sets.keys.include?(name.to_sym)
+        end
+
+        # Set the default value of the +:nested+ option for validations.
+        # @example
+        #   use_nested_validation_on :author
+        #
+        # @example
+        #   use_nested_validation_on :author, :comments
+        #
+        # @example
+        #   use_nested_validation_on :author => {:posts => :comments }
+        #
+        # @param [Array<Symbol>, Hash] args an association or associations which should be effected
+        def use_nested_validation_on(*args)
+          if themis_default_nested
+            warn "WARNING: default nested validation is already defined: " \
+                 "`#{themis_default_nested.inspect}` on #{self}"
+          end
+
+          args         = args.flatten
+          deep_nested  = args.extract_options!
+          associations = args + deep_nested.keys
+
+          UseNestedValidationOnMethod.new(self, associations, deep_nested).execute
+        end
+      end  # module ClassMethods
+
+      # :nodoc:
+      module InstanceMethods
+        # Switch validation.
+        # @param [Symbol] validation_name name of {ValidationSet validation set}
+        def use_validation(validation_name)
+          Themis::AR::UseValidationMethod.new(self, validation_name).execute!
+        end
+
+        # Do not use any of {ValidationSet validation sets}.
+        def use_no_validation
+          @themis_validation = nil
+        end
+      end  # module InstanceMethods
+
+    end  # module BaseExtension
+  end  # module AR
+end  # module Themis

data/lib/themis/ar/callbacks.rb

@@ -0,0 +1,40 @@
+module Themis
+  module AR
+    # Adds after_association_loaded callback to ActiveRecord::Base
+    module Callbacks
+      # :nodoc:
+      def self.included(base)
+        base.extend ClassMethods
+
+        base.class_eval(<<-eoruby, __FILE__, __LINE__+1)
+          class_attribute :_after_association_loaded_callbacks
+          self._after_association_loaded_callbacks = {}
+        eoruby
+      end
+
+      # :nodoc:
+      module ClassMethods
+        # Save callback in appropriate callback collection
+        #
+        # @example
+        #   class User < ActiveRecord::Base
+        #     has_many :accounts
+        #
+        #     # List accounts after loading
+        #     after_association_loaded(:accounts) do |association|
+        #       association.target.each do |account|
+        #         puts account.inspect
+        #       end
+        #     end
+        #   end
+        #
+        # @param [Symbol] association_name association name as a symbol
+        # @yield [ActiveRecord::Associations::Association] a block which receives association
+        def after_association_loaded(association_name, &block)
+          self._after_association_loaded_callbacks[association_name] = block
+        end
+      end
+
+    end
+  end
+end

data/lib/themis/ar/has_validation_method.rb

@@ -0,0 +1,108 @@
+module Themis
+  module AR
+    # Encapsulates implementation of
+    # {AR::BaseExtension::ClassMethods#has_validation has_validation} method.
+    class HasValidationMethod
+      # @param [ActiveRecord::Base] model_class
+      # @param [Symbol] names names of validation sets
+      # @param [Module, nil] validation_module
+      # @param [Hash, nil] options
+      # @param [Proc, nil] block
+      def initialize(model_class, names, validation_module, options, block)
+        @model_class = model_class
+        @names       = names
+        @module      = validation_module
+        @default     = options[:default] || false
+        @nested      = options[:nested]
+        @block       = block
+      end
+
+      # Execute the method.
+      def execute!
+        preinitialize_model_class!
+        validate!
+        register_validation_sets!
+        add_conditional_validators!
+        add_after_initialize_hook! if @default
+        add_before_validation_hook!
+      end
+
+
+      # Unless themis_validation_sets and themis_default_validation
+      # is set, then set them. This is necessary to do in every inheritor
+      # of ActiveRecord::Base to avoid overriding values for the entire
+      # ActiveRecord::Base hierarchy.
+      def preinitialize_model_class!
+        @model_class.themis_validation_sets    ||= {}
+        @model_class.themis_default_validation ||= nil
+      end
+      private :preinitialize_model_class!
+
+
+      # Add {ValidationSet validation sets} to themis_validation_sets collection.
+      def register_validation_sets!
+        @names.each do |name|
+          @model_class.themis_validation_sets[name] ||= ValidationSet.new(
+            :name    => name,
+            :module  => @module,
+            :default => @default,
+            :nested  => @nested,
+            :block   => @block
+          )
+        end
+      end
+      private :register_validation_sets!
+
+
+      # Add conditional validation to ActiveRecord model.
+      def add_conditional_validators!
+        # Define local variable to have ability to pass its value to lambda
+        validation_names = @names
+
+        condition   = lambda { |obj| obj.themis_validation.in?(validation_names) }
+        model_proxy = ModelProxy.new(@model_class, condition)
+
+        if @module
+          @module.validators.each do |validator|
+            model_proxy.send(validator.name, *validator.args)
+          end
+        end
+        @block.call(model_proxy) if @block
+      end
+      private :add_conditional_validators!
+
+
+      # Add after_initialize hook to set default validation.
+      def add_after_initialize_hook!
+        if @names.size > 1
+          raise "Can not set default to multiple validations"
+        end
+
+        # Define local variable to have ability to pass its value to proc
+        validation_name = @names.first
+        @model_class.themis_default_validation = validation_name
+        @model_class.after_initialize { use_validation(validation_name) }
+      end
+      private :add_after_initialize_hook!
+
+      # Add before_validation hook to make all nested models use same
+      # validation set.
+      def add_before_validation_hook!
+        @model_class.before_validation do
+          themis_validation ? use_validation(themis_validation) : use_no_validation
+        end
+      end
+      private :add_before_validation_hook!
+
+      # Run validation to be sure that minimum of necessary parameters were passed.
+      def validate!
+        if @default && @model_class.themis_default_validation
+          warn "WARNING: validation `#{@model_class.themis_default_validation}` " \
+               "is already used as default on #{@model_class}"
+        end
+      end
+      private :validate!
+
+    end  # class HasValidationMethod
+  end  # module AR
+end  # module Themis

data/lib/themis/ar/model_proxy.rb

@@ -0,0 +1,82 @@
+module Themis
+  module AR
+    # It wraps a model class to override validation parameters
+    # and add(update) :if option.
+    # Also it provides some DSL syntax to include validation modules.
+    #
+    # See where exactly it does its job:
+    #   class User
+    #     has_validation :soft do |validation|
+    #       validation.class  # => ModelProxy
+    #     end
+    #   end
+    class ModelProxy
+      # @param [ActiveRecord::Base] model_class
+      # @param [Proc] condition lambda which is passed as :if option for conditional validation
+      def initialize(model_class, condition)
+        @model_class = model_class
+        @condition   = condition
+      end
+
+      # Defines conditional validations from module.
+      # @param [Themis::Validation] validation_module any module extended by {Themis::Validation}
+      def include(validation_module)
+        validation_module.validators.each do |validator|
+          cargs = args_with_condition(validator.args)
+          @model_class.send(validator.name, *cargs)
+        end
+      end
+
+      # Defines conditional validation by adding(updating) :if option
+      # to original method call.
+      def method_missing(*args)
+        cargs = args_with_condition(args)
+        @model_class.send(*cargs)
+      end
+
+
+      # Build new arguments with modified :if option to make validation
+      # conditional.
+      # @param [Array] arguments validation method and its options
+      def args_with_condition(arguments)
+        # Ala deep duplication to not override original array.
+        args = arguments.map { |v| v.is_a?(Symbol) ? v : v.dup }
+
+        if args.last.is_a?(Hash)
+          old_opts = args.pop
+          args << build_opts(old_opts)
+        else
+          args << build_opts
+        end
+
+        args
+      end
+
+      # Build options for validator with :if option to make validation conditional
+      # so it would be used depending on `@themis_validation` value.
+      # If :if option already was passed then merge lambdas to create new one and
+      # use it as :if option.
+      # @param [Hash] old_opts old validator options
+      def build_opts(old_opts = nil)
+        # define local variable so its value can be addressed in lambda
+        condition = @condition
+        new_opts = old_opts || {}
+
+        if old_opts && old_opts.has_key?(:if)
+          old_if = old_opts[:if]
+          final_condition = lambda do
+            instance_eval(&old_if) &&
+            instance_eval(&condition)
+          end
+        else
+          final_condition = condition
+        end
+
+        new_opts[:if] = final_condition
+        new_opts
+      end
+      private :build_opts
+
+    end  # class ModelProxy
+  end  # module AR
+end  # module Themis

data/lib/themis/ar/use_nested_validation_on_method.rb

@@ -0,0 +1,55 @@
+module Themis
+  module AR
+    # Encapsulates {Themis::AR::BaseExtension#use_nested_validation_on} method
+    class UseNestedValidationOnMethod
+
+      # @param [ActiveRecord::Base] model base mdoel
+      # @param [Array<Symbol>] associations associations on base model
+      # @param [Hash] nested_associations deep nested associations
+      def initialize(model, associations, nested_associations)
+        @model = model
+        @associations = associations
+        @nested_associations = nested_associations
+      end
+
+      # Trigger calling use_nested_validation_on on associations and adds
+      # after_association_loaded hooks.
+      def execute
+        # Set themis_default_nested for current model
+        @model.themis_default_nested = @associations unless @associations.empty?
+
+        process_nested_validations
+        add_after_association_loaded_hooks
+      end
+
+      # Iterate over associations and recursively call #use_nested_validation_on
+      def process_nested_validations
+        @nested_associations.each do |association_name, nested|
+          reflection  = @model.reflect_on_association(association_name)
+          model_class = reflection.class_name.constantize
+          model_class.use_nested_validation_on(nested)
+        end
+      end
+
+      # Add after_association_loaded hooks to associations so when association
+      # is loaded it would have same validation as base model.
+      def add_after_association_loaded_hooks
+        @associations.each do |association_name|
+          @model.after_association_loaded(association_name) do |association|
+            validation = association.owner.themis_validation
+            target     = association.target
+
+            if validation
+              if target.respond_to?(:each)
+                target.each { |model| model.use_validation(validation) }
+              elsif target.is_a? ActiveRecord::Base
+                target.use_validation(validation) if validation
+              end
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/themis/ar/use_validation_method.rb

@@ -0,0 +1,69 @@
+module Themis
+  module AR
+    # It encapsulates # {AR::BaseExtension::InstanceMethods#use_validation use_validation}
+    # method.
+    # It makes a model and its nested associations use another validation.
+    class UseValidationMethod
+      # @param [ActiveRecord::Base] model instance of model
+      # @param [Symbol, String] new_name name of new validation set
+      def initialize(model, new_name)
+        @model    = model
+        @new_name = new_name.to_sym
+
+        unless @model.has_themis_validation?(@new_name)
+          raise ArgumentError.new("Unknown validation: `#{@new_name.inspect}` for #{model.class}")
+        end
+
+        @new_validation_set = @model.themis_validation_sets[@new_name]
+      end
+
+      # Affect model and its nested associations.
+      # Make them use the new validation set by assigning `@themis_validation`
+      # instance variable.
+      def execute!
+        # NOTE: It breaks encapsulation of ActiveRecord model.
+        # We do it because we don't wanna public "themis_validation=" method.
+        # -- sergey.potapov 2012-08-14
+        @model.instance_variable_set("@themis_validation", @new_name)
+
+        nested = @new_validation_set.nested || @model.class.themis_default_nested
+        if nested
+          association_names = Array.wrap(nested)
+          affect_associations(association_names)
+        end
+      end
+
+
+      # Make associations use new validation set.
+      # @param [Array<Symbol>] association_names names of associations
+      def affect_associations(association_names)
+        association_names.each { |name| affect_association(name) }
+      end
+      private :affect_associations
+
+      # Make an association use new validation set.
+      # Affect associations that are already loaded.
+      # @param [Symbol] association_name
+      def affect_association(association_name)
+        unless @model.reflections.has_key?(association_name)
+          raise("`#{association_name}` is not an association on #{@model.class}")
+        end
+
+        association = @model.association(association_name)
+        return if (!association.loaded? && !@model.new_record?)
+
+        target = association.target
+        case target
+        when Array, ActiveRecord::Associations::CollectionProxy
+          target.each {|obj| obj.send(:use_validation, @new_name) }
+        when ActiveRecord::Base
+          target.send(:use_validation, @new_name)
+        else
+          # do nothing
+        end
+      end
+      private :affect_association
+
+    end  # class UseValidationMethod
+  end  # module AR
+end  # module Themis

data/lib/themis/ar/validation_set.rb

@@ -0,0 +1,14 @@
+module Themis
+  module AR
+
+    # Used to store options about validation sets on every single ActiveRecord model class.
+    class ValidationSet < Struct.new(:name, :module, :default, :nested, :block)
+      # Redefine `new` to initialize structure with hash
+      def initialize(hash)
+        members = self.class.members.map!(&:to_sym)
+        super(*hash.values_at(*members))
+      end
+    end
+
+  end  # module AR
+end  # module Themis

data/lib/themis/ar.rb

@@ -0,0 +1,16 @@
+module Themis
+  # All stuff related to ActiveRecord.
+  # Mainly it provides {AR::BaseExtension} to extend ActiveRecord::Base.
+  module AR
+    extend ActiveSupport::Autoload
+
+    autoload :Callbacks
+    autoload :AssociationExtension
+    autoload :BaseExtension
+    autoload :ModelProxy
+    autoload :ValidationSet
+    autoload :HasValidationMethod
+    autoload :UseValidationMethod
+    autoload :UseNestedValidationOnMethod
+  end  # module AR
+end  # module Themis

data/lib/themis/engine.rb

@@ -0,0 +1,24 @@
+module Themis
+  # :nodoc
+  class Engine < Rails::Engine
+
+    initializer 'themis' do
+      ActiveSupport.on_load(:active_record) do
+
+        ::ActiveRecord::Associations::CollectionAssociation.class_eval do
+          include Themis::AR::AssociationExtension
+        end
+
+        ::ActiveRecord::Associations::Association.class_eval do
+          include Themis::AR::AssociationExtension
+        end
+
+        ::ActiveRecord::Base.class_eval do
+          include Themis::AR::BaseExtension
+        end
+
+      end  # on_load
+    end  # initializer
+
+  end  # Engine
+end  # Themis

data/lib/themis/validation/validator.rb

@@ -0,0 +1,18 @@
+module Themis
+  module Validation
+
+    # Simple structure to store information about methods called on
+    # {Themis::Validation validation module}. It saves name and arguments
+    # of validation method in order to apply it on model later.
+    class Validator
+      attr_reader :name, :args
+
+      # @param [Symbol, String] name validation method name, e.g. "validates_presence_of"
+      # @param [Array] args arguments of method
+      def initialize(name, args)
+        @name, @args = name, args
+      end
+    end
+
+  end  # Validation
+end  # Themis

data/lib/themis/validation.rb

@@ -0,0 +1,58 @@
+module Themis
+  # Extends other modules to make them be validation modules.
+  # Consider it as the "parent module" for all validation modules.
+  #
+  # @example define UserValidation
+  #
+  #   module UserValidation
+  #     extend Themis::Validation
+  #
+  #     validates :email   , :presence => true
+  #     validates :nickname, :presence => true
+  #   end
+  module Validation
+    extend ActiveSupport::Autoload
+
+    autoload :Validator
+
+    # Array {Validator validators} defined in module.
+    # @return [Array<Validator>] array of module's validators
+    def validators
+      @validators ||= []
+    end
+
+    # When included in another module: copy {Validator validators} to another module.
+    # When included in ActiveRecord model: define validators on model.
+    # @param [Module, ActiveRecord::Base] base another validation module or ActiveRecord model.
+    def included(base)
+      if base.instance_of?(Module) && base.respond_to?(:validators)
+        base.validators.concat(validators)
+      elsif base.ancestors.include? ::ActiveRecord::Base
+        apply_to_model!(base)
+      else
+        raise "Validation module `#{self.inspect}` can be included only in another validation module or in ActiveRecord model"
+      end
+    end
+
+    # Save all calls of validation methods as array of validators
+    def method_missing(method_name, *args)
+      if method_name.to_s =~ /\Avalidate/
+        self.validators << Themis::Validation::Validator.new(method_name, args)
+      else
+        super
+      end
+    end
+    private :method_missing
+
+    # Add validators to model
+    # @param [ActiveRecord::Base] model_class
+    def apply_to_model!(model_class)
+      validators.each do |validator|
+        method, args = validator.name, validator.args
+        model_class.send(method, *args)
+      end
+    end
+    private :apply_to_model!
+
+  end  # module Validation
+end  # module Themis

data/lib/themis/version.rb

@@ -0,0 +1,4 @@
+module Themis
+  # :nodoc:
+  VERSION = "0.1.0"
+end

data/lib/themis.rb

@@ -0,0 +1,9 @@
+require 'themis/engine'
+
+# Extends ActiveRecord to provide switchable validations.
+module Themis
+  extend ActiveSupport::Autoload
+
+  autoload :Validation
+  autoload :AR
+end

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: themis
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- TMX Credit
+- Potapov Sergey
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.11'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Flexible and modular validations for ActiveRecord models
+email:
+- rubygems@tmxcredit.com
+- blake131313@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.markdown
+files:
+- README.markdown
+- lib/themis.rb
+- lib/themis/ar.rb
+- lib/themis/ar/association_extension.rb
+- lib/themis/ar/base_extension.rb
+- lib/themis/ar/callbacks.rb
+- lib/themis/ar/has_validation_method.rb
+- lib/themis/ar/model_proxy.rb
+- lib/themis/ar/use_nested_validation_on_method.rb
+- lib/themis/ar/use_validation_method.rb
+- lib/themis/ar/validation_set.rb
+- lib/themis/engine.rb
+- lib/themis/validation.rb
+- lib/themis/validation/validator.rb
+- lib/themis/version.rb
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Flexible and modular validations for ActiveRecord models
+test_files: []