usecasing_validations 0.5.0

data/lib/usecasing_validations/validations/format.rb

@@ -0,0 +1,116 @@
+module UseCaseValidations
+  module Validations
+
+    class FormatValidator < EachValidator # :nodoc:
+      def validate_each(record, attribute, value)
+        if options[:with]
+          regexp = option_call(record, :with)
+          record_error(record, attribute, :with, value) if value.to_s !~ regexp
+        elsif options[:without]
+          regexp = option_call(record, :without)
+          record_error(record, attribute, :without, value) if value.to_s =~ regexp
+        end
+      end
+
+      def check_validity!
+        unless options.include?(:with) ^ options.include?(:without)  # ^ == xor, or "exclusive or"
+          raise ArgumentError, "Either :with or :without must be supplied (but not both)"
+        end
+
+        check_options_validity(options, :with)
+        check_options_validity(options, :without)
+      end
+
+      private
+
+      def option_call(record, name)
+        option = options[name]
+        option.respond_to?(:call) ? option.call(record) : option
+      end
+
+      def record_error(record, attribute, name, value)
+        record.errors.add(attribute, :invalid, Helpers._except(options, name).merge!(value: value))
+      end
+
+      def regexp_using_multiline_anchors?(regexp)
+        regexp.source.start_with?("^") ||
+          (regexp.source.end_with?("$") && !regexp.source.end_with?("\\$"))
+      end
+
+      def check_options_validity(options, name)
+        option = options[name]
+        if option && !option.is_a?(Regexp) && !option.respond_to?(:call)
+          raise ArgumentError, "A regular expression or a proc or lambda must be supplied as :#{name}"
+        elsif option && option.is_a?(Regexp) &&
+              regexp_using_multiline_anchors?(option) && options[:multiline] != true
+          raise ArgumentError, "The provided regular expression is using multiline anchors (^ or $), " \
+          "which may present a security risk. Did you mean to use \\A and \\z, or forgot to add the " \
+          ":multiline => true option?"
+        end
+      end
+    end
+
+    module HelperMethods
+      # Validates whether the value of the specified attribute is of the correct
+      # form, going by the regular expression provided.You can require that the
+      # attribute matches the regular expression:
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates_format_of :email, with: /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\z/i, on: :create
+      #   end
+      #
+      # Alternatively, you can require that the specified attribute does _not_
+      # match the regular expression:
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates_format_of :email, without: /NOSPAM/
+      #   end
+      #
+      # You can also provide a proc or lambda which will determine the regular
+      # expression that will be used to validate the attribute.
+      #
+      #   class Person < ActiveRecord::Base
+      #     # Admin can have number as a first letter in their screen name
+      #     validates_format_of :screen_name,
+      #                         with: ->(person) { person.admin? ? /\A[a-z0-9][a-z0-9_\-]*\z/i : /\A[a-z][a-z0-9_\-]*\z/i }
+      #   end
+      #
+      # Note: use <tt>\A</tt> and <tt>\Z</tt> to match the start and end of the
+      # string, <tt>^</tt> and <tt>$</tt> match the start/end of a line.
+      #
+      # Due to frequent misuse of <tt>^</tt> and <tt>$</tt>, you need to pass
+      # the <tt>multiline: true</tt> option in case you use any of these two
+      # anchors in the provided regular expression. In most cases, you should be
+      # using <tt>\A</tt> and <tt>\z</tt>.
+      #
+      # You must pass either <tt>:with</tt> or <tt>:without</tt> as an option.
+      # In addition, both must be a regular expression or a proc or lambda, or
+      # else an exception will be raised.
+      #
+      # Configuration options:
+      # * <tt>:message</tt> - A custom error message (default is: "is invalid").
+      # * <tt>:allow_nil</tt> - If set to true, skips this validation if the
+      #   attribute is +nil+ (default is +false+).
+      # * <tt>:allow_blank</tt> - If set to true, skips this validation if the
+      #   attribute is blank (default is +false+).
+      # * <tt>:with</tt> - Regular expression that if the attribute matches will
+      #   result in a successful validation. This can be provided as a proc or
+      #   lambda returning regular expression which will be called at runtime.
+      # * <tt>:without</tt> - Regular expression that if the attribute does not
+      #   match will result in a successful validation. This can be provided as
+      #   a proc or lambda returning regular expression which will be called at
+      #   runtime.
+      # * <tt>:multiline</tt> - Set to true if your regular expression contains
+      #   anchors that match the beginning or end of lines as opposed to the
+      #   beginning or end of the string. These anchors are <tt>^</tt> and <tt>$</tt>.
+      #
+      # There is also a list of default options supported by every validator:
+      # +:if+, +:unless+, +:on+ and +:strict+.
+      # See <tt>ActiveModel::Validation#validates</tt> for more information
+      def validates_format_of(*attr_names)
+        validates_with FormatValidator, _merge_attributes(attr_names)
+      end
+    end
+
+  end
+end

data/lib/usecasing_validations/validations/helper_methods.rb

@@ -0,0 +1,16 @@
+module UseCaseValidations
+  module Validations
+
+    module HelperMethods
+
+      def _merge_attributes(attr_names)
+        options = Helpers._symbolyze_keys(Helpers._extract_options!(attr_names))
+        attr_names.flatten!
+        options[:attributes] = attr_names
+        options
+      end
+
+    end
+
+  end
+end

data/lib/usecasing_validations/validations/length.rb

@@ -0,0 +1,126 @@
+module UseCaseValidations
+
+  # == Active \Model Length \Validator
+  module Validations
+    class LengthValidator < EachValidator # :nodoc:
+      MESSAGES  = { is: :wrong_length, minimum: :too_short, maximum: :too_long }.freeze
+      CHECKS    = { is: :==, minimum: :>=, maximum: :<= }.freeze
+
+      RESERVED_OPTIONS  = [:minimum, :maximum, :within, :is, :tokenizer, :too_short, :too_long]
+
+      def initialize(options)
+        if range = (options.delete(:in) || options.delete(:within))
+          raise ArgumentError, ":in and :within must be a Range" unless range.is_a?(Range)
+          options[:minimum], options[:maximum] = range.min, range.max
+        end
+
+        if options[:allow_blank] == false && options[:minimum].nil? && options[:is].nil?
+          options[:minimum] = 1
+        end
+
+        super
+      end
+
+      def check_validity!
+        keys = CHECKS.keys & options.keys
+
+        if keys.empty?
+          raise ArgumentError, 'Range unspecified. Specify the :in, :within, :maximum, :minimum, or :is option.'
+        end
+
+        keys.each do |key|
+          value = options[key]
+
+          unless (value.is_a?(Integer) && value >= 0) || value == Float::INFINITY
+            raise ArgumentError, ":#{key} must be a nonnegative Integer or Infinity"
+          end
+        end
+      end
+
+      def validate_each(record, attribute, value)
+        value = tokenize(value)
+        value_length = value.respond_to?(:length) ? value.length : value.to_s.length
+        errors_options = Helpers._except(options, *RESERVED_OPTIONS)
+
+        CHECKS.each do |key, validity_check|
+          next unless check_value = options[key]
+
+          if !value.nil? || skip_nil_check?(key)
+            next if value_length.send(validity_check, check_value)
+          end
+
+          errors_options[:count] = check_value
+
+          default_message = options[MESSAGES[key]]
+          errors_options[:message] ||= default_message if default_message
+
+          record.errors.add(attribute, MESSAGES[key], errors_options)
+        end
+      end
+
+      private
+
+      def tokenize(value)
+        if options[:tokenizer] && value.kind_of?(String)
+          options[:tokenizer].call(value)
+        end || value
+      end
+
+      def skip_nil_check?(key)
+        key == :maximum && options[:allow_nil].nil? && options[:allow_blank].nil?
+      end
+    end
+
+    module HelperMethods
+
+      # Validates that the specified attribute matches the length restrictions
+      # supplied. Only one option can be used at a time:
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates_length_of :first_name, maximum: 30
+      #     validates_length_of :last_name, maximum: 30, message: "less than 30 if you don't mind"
+      #     validates_length_of :fax, in: 7..32, allow_nil: true
+      #     validates_length_of :phone, in: 7..32, allow_blank: true
+      #     validates_length_of :user_name, within: 6..20, too_long: 'pick a shorter name', too_short: 'pick a longer name'
+      #     validates_length_of :zip_code, minimum: 5, too_short: 'please enter at least 5 characters'
+      #     validates_length_of :smurf_leader, is: 4, message: "papa is spelled with 4 characters... don't play me."
+      #     validates_length_of :essay, minimum: 100, too_short: 'Your essay must be at least 100 words.',
+      #                         tokenizer: ->(str) { str.scan(/\w+/) }
+      #   end
+      #
+      # Configuration options:
+      # * <tt>:minimum</tt> - The minimum size of the attribute.
+      # * <tt>:maximum</tt> - The maximum size of the attribute. Allows +nil+ by
+      #   default if not used with :minimum.
+      # * <tt>:is</tt> - The exact size of the attribute.
+      # * <tt>:within</tt> - A range specifying the minimum and maximum size of
+      #   the attribute.
+      # * <tt>:in</tt> - A synonym (or alias) for <tt>:within</tt>.
+      # * <tt>:allow_nil</tt> - Attribute may be +nil+; skip validation.
+      # * <tt>:allow_blank</tt> - Attribute may be blank; skip validation.
+      # * <tt>:too_long</tt> - The error message if the attribute goes over the
+      #   maximum (default is: "is too long (maximum is %{count} characters)").
+      # * <tt>:too_short</tt> - The error message if the attribute goes under the
+      #   minimum (default is: "is too short (min is %{count} characters)").
+      # * <tt>:wrong_length</tt> - The error message if using the <tt>:is</tt>
+      #   method and the attribute is the wrong size (default is: "is the wrong
+      #   length (should be %{count} characters)").
+      # * <tt>:message</tt> - The error message to use for a <tt>:minimum</tt>,
+      #   <tt>:maximum</tt>, or <tt>:is</tt> violation. An alias of the appropriate
+      #   <tt>too_long</tt>/<tt>too_short</tt>/<tt>wrong_length</tt> message.
+      # * <tt>:tokenizer</tt> - Specifies how to split up the attribute string.
+      #   (e.g. <tt>tokenizer: ->(str) { str.scan(/\w+/) }</tt> to count words
+      #   as in above example). Defaults to <tt>->(value) { value.split(//) }</tt>
+      #   which counts individual characters.
+      #
+      # There is also a list of default options supported by every validator:
+      # +:if+, +:unless+, +:on+ and +:strict+.
+      # See <tt>ActiveModel::Validation#validates</tt> for more information
+      def validates_length_of(*attr_names)
+        validates_with LengthValidator, _merge_attributes(attr_names)
+      end
+
+      alias_method :validates_size_of, :validates_length_of
+    end
+  end
+end

data/lib/usecasing_validations/validations/presence.rb

@@ -0,0 +1,17 @@
+module UseCaseValidations
+  module Validations
+
+    class PresenceValidator < EachValidator # :nodoc:
+      def validate_each(record, attr_name, value)
+        record.errors.add(attr_name, :blank, options) if Helpers._blank?(value)
+      end
+    end
+
+    module HelperMethods
+      def validates_presence_of(*attr_names)
+        validates_with PresenceValidator, _merge_attributes(attr_names)
+      end
+    end
+  
+  end
+end

data/lib/usecasing_validations/validations/uniqueness.rb

@@ -0,0 +1,56 @@
+module UseCaseValidations
+  module Validations
+
+    class UniquenessValidator < EachValidator
+      def validate_each(record, attribute, value)
+
+        return nil unless scope_method(record)
+
+        records.each do |other_record|
+          next if record == other_record || Helpers._marked_for_destruction?(other_record) || !scope_method(other_record)
+
+          if similar_objects?(record, other_record, attribute)
+            record.errors.add(attribute, :taken, options)
+            break
+          end
+        end
+
+      end
+
+      protected ########################### PROTECTED #######################
+
+      def records
+        [*base.target].inject([]) do |scoped_list, object|
+          scoped_list << object if scope_method(object)
+          scoped_list
+        end
+      end
+
+      def similar_objects?(record, other_record, attribute)
+        if options.key?(:conditions)
+          if base.method(options[:conditions]).arity == 3
+            base.send(options[:conditions], record, other_record, attribute)
+          else
+            base.send(options[:conditions], record, other_record)
+          end
+        else
+          record.send(attribute) == other_record.send(attribute)
+        end
+      end
+
+      private ###################### PRIVATE ####################
+
+      def scope_method(object)
+        options.key?(:scope) ? base.send(options[:scope], object) : true
+      end
+
+    end
+
+    module HelperMethods
+      def validates_uniqueness_of(*attr_names)
+        validates_with UniquenessValidator, _merge_attributes(attr_names)
+      end
+    end
+  
+  end
+end

data/lib/usecasing_validations/validator.rb

@@ -0,0 +1,20 @@
+module UseCaseValidations
+  
+  class Validator
+
+    attr_reader :options
+    attr_accessor :base
+
+    def initialize(options = {})
+      @options  = Helpers._except(options, :class).freeze
+    end
+
+    # Override this method in subclasses with validation logic, adding errors
+    # to the records +errors+ array where necessary.
+    def validate(record)
+      raise NotImplementedError, "Subclasses must implement a validate(record) method."
+    end
+    
+  end
+
+end

data/lib/usecasing_validations/version.rb

@@ -0,0 +1,3 @@
+module UseCaseValidations
+  VERSION = "0.5.0"
+end

data/lib/usecasing_validations.rb

@@ -0,0 +1,122 @@
+require 'usecasing'
+
+require "usecasing_validations/target"
+require "usecasing_validations/helpers"
+require "usecasing_validations/errors"
+require "usecasing_validations/validator"
+require "usecasing_validations/each_validator"
+require "usecasing_validations/custom_validator"
+
+require "usecasing_validations/validations/helper_methods"
+require "usecasing_validations/validations/format"
+require "usecasing_validations/validations/length"
+require "usecasing_validations/validations/presence"
+require "usecasing_validations/validations/uniqueness"
+
+
+module UseCase
+  autoload :Validator, 'usecasing/validator'
+  autoload :DependsAll, 'usecasing/depends_all'
+end
+
+
+module UseCaseValidations
+
+  def self.included(base)
+    base.extend(Validations::HelperMethods)
+    base.class_eval { include Target }
+    base.extend(ClassMethods)
+  end
+
+  protected #################### PROTECTED ######################
+
+  def run_validations!(object_to_validate)
+    self.class.validators.each do |validator|
+      next unless option_if_succeeds(validator, object_to_validate)
+
+      validator.base = self
+      validator.validate(object_to_validate)
+    end
+  end
+
+  def valid?(object_to_validate)
+    extend_errors_if_necessary object_to_validate
+
+    object_to_validate.errors.clear if self.class.clear_errors?
+
+    run_validations! object_to_validate
+
+    object_to_validate.errors.empty?
+  end
+  
+  private ######################## PRIVATE #######################
+
+  def extend_errors_if_necessary(object_to_validate)
+    return true if object_to_validate.respond_to?(:errors)
+
+    object_to_validate.instance_eval do
+      def errors; @errors ||= Errors.new(self); end
+    end
+  end
+
+  def option_if_succeeds(validator, object_to_validate)
+    if validator.options.key?(:if)
+      Helpers._call_proc_or_method(self, validator.options[:if], object_to_validate)
+    else
+      true
+    end
+  end
+
+  module ClassMethods
+
+    def clear_errors!
+      @clear_errors = true
+    end
+
+    def clear_errors?
+      defined?(@clear_errors) ? @clear_errors : false
+    end
+
+    def _validators
+      @_validators ||= Hash.new { |h,k| h[k] = [] }
+    end
+
+    def _validators=(value)
+      @_validators = value
+    end
+
+    def validate(*args, &block)
+      _validators[nil] << CustomValidator.new(args, &block)
+    end
+
+    def validates_with(*args, &block)
+      options = Helpers._extract_options!(args)
+      options[:class] = self
+      
+      args.each do |klass|
+        validator = klass.new(options, &block)
+
+        if validator.respond_to?(:attributes) && !validator.attributes.empty?
+          validator.attributes.each do |attribute|
+            _validators[attribute.to_sym] << validator
+          end
+        else
+          _validators[nil] << validator
+        end
+      end
+    end
+
+    def validators
+      _validators.values.flatten.uniq
+    end
+
+    # Copy validators on inheritance.
+    def inherited(base)
+      dup = _validators.dup
+      base._validators = dup.each { |k, v| dup[k] = v.dup }
+      super
+    end
+
+  end #/ClassMethods
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+require 'usecasing_validations'
+
+require 'pry'
+
+Dir.chdir("spec/") do
+  Dir["support/models/*.rb"].each { |file| require file }
+  Dir["support/usecases/*.rb"].each { |file| require file }
+end
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  config.mock_framework = :mocha
+
+  config.order = 'random'
+end

data/spec/support/models/ruby_post.rb

@@ -0,0 +1,9 @@
+class RubyPost
+
+  attr_accessor :title, :body, :phone_number
+
+  def initialize(attributes = {})
+    (attributes || {}).each { |name, value| send("#{name}=", value) }
+  end
+
+end

data/spec/support/models/ruby_post_with_comments.rb

@@ -0,0 +1,28 @@
+class RubyPostWithComments
+
+  class RubyComment
+
+    attr_accessor :title, :email, :post_id
+
+    def initialize(attributes = {})
+      (attributes || {}).each { |name, value| send("#{name}=", value) }
+    end
+
+  end
+
+
+  attr_reader :comments
+
+  def initialize(comments = {})
+    @comments = comments.map { |comment| RubyComment.new(comment) }
+    @comments = [] if @comments.nil?
+  end
+
+  def first_two_comments
+    [
+      comments[0],
+      comments[1]
+    ]
+  end
+
+end

data/spec/support/usecases/validate_comments.rb

@@ -0,0 +1,34 @@
+class ValidateComments < UseCase::Validator
+
+  target :comments, in: :post
+
+  validates_presence_of :title, message: "can't be blank!"
+  
+  validates_format_of :email, with: /\A[\w+\-.]+@[a-z\d\-.]+\.[a-z]+\z/i, message: "invalid format!"
+
+  validates_length_of :title, minimum: 6, allow_nil: true
+
+  validate :custom_validation1, :custom_validation2
+
+
+  protected ######################### PROTECTED ############################
+
+  def custom_validation1(comment)
+    if ['force_error1', 'force_error2'].include?(comment.title)
+      comment.errors.add(:title, 'custom_validation1')
+      return false
+    end
+
+    true
+  end
+
+  def custom_validation2(comment)
+    if comment.email == "force_error@gmail.com"
+      comment.errors.add(:email, 'custom_validation2')
+      return false
+    end
+
+    true
+  end
+
+end

data/spec/support/usecases/validate_comments_custom_target.rb

@@ -0,0 +1,14 @@
+class ValidateCommentsCustomTarget < UseCase::Validator
+
+  def target
+    [
+      context.post.comments[0],
+      context.post.comments[1]
+    ]
+  end
+
+  validates_presence_of :title
+  
+  validates_format_of :email, with: /\A[\w+\-.]+@[a-z\d\-.]+\.[a-z]+\z/i
+
+end

data/spec/support/usecases/validate_depends_all.rb

@@ -0,0 +1,24 @@
+module Group
+  
+  class ValidatePostTitle < UseCase::Validator
+
+    target :post
+
+    validates_presence_of :title
+
+  end
+
+  class ValidatePostBody < UseCase::Validator
+
+    target :post
+
+    validates_presence_of :body
+
+  end
+
+  class ValidateDependsAll < UseCase::DependsAll
+
+    depends ValidatePostTitle, ValidatePostBody
+
+  end
+end

data/spec/support/usecases/validate_post.rb

@@ -0,0 +1,18 @@
+class ValidatePost < UseCase::Validator
+
+  target :post
+
+  validates_presence_of :title, :body, message: "can't be blank!"
+
+  validates_presence_of :phone_number, if: ->(post) { context.validate_phone_number }
+  
+  validates_format_of :phone_number, with: /\A[0-9 ]*\z/, message: "invalid format!", if: :validate_phone_number
+
+  
+  protected ###################### PROTECTED ####################
+
+  def validate_phone_number(post)
+    context.validate_phone_number
+  end
+
+end

data/spec/support/usecases/validate_post_clear_errors.rb

@@ -0,0 +1,9 @@
+class ValidatePostClearErrors < UseCase::Validator
+  
+  clear_errors!
+
+  target :post
+
+  validates_presence_of :title, :body
+
+end