detox 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4178ff8b870484f57cd8c4677afac7b1968526da
+  data.tar.gz: 682e7b0e9665a4b1bed0571aa24153260ca0ac76
+SHA512:
+  metadata.gz: 6eed3e98b13ec01e85532664dd2b5319ecb112b54939d859b4da47ec26282cc01127d38a52cdfaaaf536eb18001bf70d7c2080a110c5813d8476a6e733237768
+  data.tar.gz: 8c449e6d0aa73fa2022aca80648fe43f5da3c05b3ac56fda822c1f21caa3d3b75a7150c5f616ce81b57ab998f186882f1618c22e9b7b1b1eee3902c2a842a6af

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+vendor/bundle
+coverage

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+gemfile:
+  - gemfiles/activemodel_3_2_x.gemfile
+  - gemfiles/activemodel_4_0_x.gemfile

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in detox.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 pinzolo
+
+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.
+
+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.md

@@ -0,0 +1,40 @@
+# Detox
+
+[![Build Status](https://secure.travis-ci.org/pinzolo/detox.png)](http://travis-ci.org/pinzolo/detox)
+[![Coverage Status](https://coveralls.io/repos/pinzolo/detox/badge.png)](https://coveralls.io/r/pinzolo/detox)
+[![Code Climate](https://codeclimate.com/github/pinzolo/detox.png)](https://codeclimate.com/github/pinzolo/detox)
+
+Detox is validator set that can apply to ActiveModel/ActiveRecord
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'detox'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install detox
+
+## Usage
+
+Look [spec/test_class](https://github.com/pinzolo/detox/tree/master/spec/test_class) for sample usage
+
+- Validators for attribute that has Array or Hash value
+  - **ordering**: validates continuous numbers
+  - **possession**: validates subset values
+  - **all_xxx**: validates that all value are valid, by basic validators (xxx is presence, format etc.)
+  - **any_xxx**: validates that has valid value, by basic validators (xxx is presence, format etc.)
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+
+task :default => [:spec]
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec) do |spec|
+    spec.pattern = 'spec/**/*_spec.rb'
+    spec.rspec_opts = ['--color']
+  end
+rescue LoadError => e
+end

data/detox.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'detox/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "detox"
+  spec.version       = Detox::VERSION
+  spec.authors       = ["pinzolo"]
+  spec.email         = ["pinzolo@gmail.com"]
+  spec.description   = %q{Detox is collection of validators for AciveModel and AcitveRecord.}
+  spec.summary       = spec.description
+  spec.homepage      = "https://github.com/pinzolo/detox"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "activemodel", ">=3.2.0"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "coveralls"
+end

data/gemfiles/activemodel_3_2_x.gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gem "activemodel", "~>3.2.0"
+
+gemspec :path => "../"

data/gemfiles/activemodel_4_0_x.gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gem "activemodel", "~>4.0.0"
+
+gemspec :path => "../"

data/lib/active_model/validations/absence.rb

@@ -0,0 +1,19 @@
+# coding: utf-8
+
+# via: activemodel/lib/active_model/validations/absence.rb (4.0-stable)
+#      https://github.com/rails/rails/blob/4-0-stable/activemodel/lib/active_model/validations/absence.rb
+module ActiveModel
+  module Validations
+    class AbsenceValidator < EachValidator
+      def validate_each(record, attr_name, value)
+        record.errors.add(attr_name, :present, options) if value.present?
+      end
+    end
+
+    module HelperMethods
+      def validates_absence_of(*attr_names)
+        validates_with AbsenceValidator, _merge_attributes(attr_names)
+      end
+    end
+  end
+end

data/lib/detox.rb

@@ -0,0 +1,11 @@
+# coding: utf-8
+require "active_model"
+require "active_support/i18n"
+require "detox/validations/ordering"
+require "detox/validations/possession"
+require "detox/validations/all"
+require "detox/validations/any"
+
+ActiveModel::Validations.__send__(:include, Detox::Validations)
+I18n.load_path << Dir[Pathname.new(File.dirname(__FILE__)).join("detox", "locales", "*.yml")]
+

data/lib/detox/array_validity.rb

@@ -0,0 +1,23 @@
+# coding: utf-8
+require "active_support/core_ext"
+
+module Detox
+  module ArrayValidity
+    RESERVED_OPTIONS = [:ignore_nil_value, :ignore_blank_value].freeze
+
+    def convert_to_validatee(data, options = {})
+      values = if data.nil?
+                 []
+               elsif data.is_a?(Array)
+                 data.dup
+               elsif data.is_a?(Hash)
+                 data.values
+               else
+                 [data]
+               end
+      values = values.compact if options[:ignore_nil_value]
+      values = values.reject(&:blank?) if options[:ignore_blank_value]
+      values
+    end
+  end
+end

data/lib/detox/locales/en.yml

@@ -0,0 +1,21 @@
+en:
+  errors:
+    messages:
+      invalid_as_order: "is not satisfied as order"
+      possession: "must possess target (target: %{target})"
+      all_presence: "can't contain blank value"
+      all_absence: "can't contain not blank value"
+      all_format: "contains invalid format value"
+      all_numericality: "contains not numeric value"
+      all_length: "contains invalid length value"
+      all_inclusion: "contains value that is not included in the list"
+      all_exclusion: "contains value that is included in the list"
+      all_acceptance: "must be all accepted"
+      any_presence: "must contain not blank value (required number is %{min_valid_count}-%{max_valid_count})"
+      any_absence: "must contain blank value (required number is %{min_valid_count}-%{max_valid_count})"
+      any_acceptance: "must be accepted (required number is %{min_valid_count}-%{max_valid_count})"
+      any_format: "must be valid format (required number is %{min_valid_count}-%{max_valid_count})"
+      any_length: "must be valid length (required number is %{min_valid_count}-%{max_valid_count})"
+      any_numericality: "must be numeric (required number is %{min_valid_count}-%{max_valid_count})"
+      any_inclusion: "must be included in the list (required number is %{min_valid_count}-%{max_valid_count})"
+      any_exclusion: "must be not included in the list (required number is %{min_valid_count}-%{max_valid_count})"

data/lib/detox/locales/ja.yml

@@ -0,0 +1,21 @@
+ja:
+  errors:
+    messages:
+      invalid_as_order: "は順序として成立していません"
+      possession: "には対象(%{target})が含まれている必要があります"
+      all_presence: "には空の値を含められません"
+      all_absence: "には空ではない値を含められません"
+      all_format: "には不正な形式の値が含まれています"
+      all_numericality: "は数値でない値を含んでいます"
+      all_length: "には長さが不正な値が含まれています"
+      all_inclusion: "にはリストに含まれていない値が含まれています"
+      all_exclusion: "にはリストに含まれている値が含まれています"
+      all_acceptance: "を全て承諾してください"
+      any_presence: "には空でない値が必要数(%{min_valid_count}～%{max_valid_count})含まれている必要があります"
+      any_absence: "には空の値が必要数(%{min_valid_count}～%{max_valid_count})含まれている必要があります"
+      any_acceptance: "は指定件数(%{min_valid_count}～%{max_valid_count})承諾してください"
+      any_format: "は必要数(%{min_valid_count}～%{max_valid_count})が正しい形式でなければなりません"
+      any_length: "は必要数(%{min_valid_count}～%{max_valid_count})が正しい長さでなければなりません"
+      any_numericality: "は必要数(%{min_valid_count}～%{max_valid_count})が数値でなければなりません"
+      any_inclusion: "は必要数(%{min_valid_count}～%{max_valid_count})がリストに含まれていなければなりません"
+      any_exclusion: "は必要数(%{min_valid_count}～%{max_valid_count})がリストに含まれていない値でなければなりません"

data/lib/detox/validations/all.rb

@@ -0,0 +1,41 @@
+# coding: utf-8
+require "active_support/core_ext"
+require "detox/array_validity"
+require "detox/validity_broker"
+
+unless defined?(ActiveModel::Validations::AbsenceValidator)
+  require "active_model/validations/absence"
+end
+
+ignore_constants =  [:ConfirmationValidator, :WithValidator]
+validators_source = ActiveModel::Validations.constants.each_with_object("") do |const, src|
+  next if ignore_constants.include?(const)
+  next if Detox::Validations.constants.include?("All#{const}".to_sym)
+
+  src << <<-EOS
+  class All#{const} < ActiveModel::EachValidator
+    include Detox::ArrayValidity
+
+    def validate_each(record, attribute, value)
+      values = convert_to_validatee(value, options.slice(*Detox::ArrayValidity::RESERVED_OPTIONS))
+      return if values.blank?
+
+      new_options = options.dup.except(*Detox::ArrayValidity::RESERVED_OPTIONS).merge(:attributes => [attribute])
+      validator = ActiveModel::Validations::#{const}.new(new_options)
+      broker = Detox::ValidityBroker.new
+      validity = values.all? do |v|
+        broker.validatee = v
+        validator.validate(broker)
+        broker.valid?
+      end
+      unless validity
+        message = options[:message] || :all_#{const.to_s.underscore.gsub(/_validator\z/, "")}
+        record.errors.add(attribute, message)
+      end
+    end
+  end
+EOS
+end
+
+Detox::Validations.module_eval(validators_source)
+

data/lib/detox/validations/any.rb

@@ -0,0 +1,57 @@
+# coding: utf-8
+require "active_support/core_ext"
+require "detox/array_validity"
+require "detox/validity_broker"
+
+ignore_constants =  [:ConfirmationValidator, :WithValidator]
+validators_source = ActiveModel::Validations.constants.each_with_object("") do |const, src|
+  next if ignore_constants.include?(const)
+  next if Detox::Validations.constants.include?("Any#{const}".to_sym)
+
+  src << <<-EOS
+  class Any#{const} < ActiveModel::EachValidator
+    include Detox::ArrayValidity
+
+    def check_validity!
+      min_valid_count, max_valid_count = options[:min_valid_count], options[:max_valid_count]
+      if (min_valid_count != nil && !min_valid_count.is_a?(Integer)) ||
+         (max_valid_count != nil && !max_valid_count.is_a?(Integer)) ||
+         (min_valid_count != nil && min_valid_count <= 0) ||
+         (max_valid_count != nil && max_valid_count <= 0)
+        raise ArgumentError, ":min_valid_count and :max_valid_count must be a positive integer ( greater than 0 ) or nil"
+      end
+      if min_valid_count != nil && max_valid_count != nil && min_valid_count > max_valid_count
+        raise ArgumentError, ":min_valid_count must be less than or equal to :max_valid_count"
+      end
+    end
+
+    def validate_each(record, attribute, value)
+      values = convert_to_validatee(value)
+      return if values.blank?
+
+      new_options = options.dup.merge(:attributes => [attribute])
+      validator = ActiveModel::Validations::#{const}.new(new_options)
+      broker = Detox::ValidityBroker.new
+      valid_count = values.count do |v|
+        broker.validatee = v
+        validator.validate(broker)
+        broker.valid?
+      end
+
+      unless count_valid?(valid_count)
+        message = options[:message] || :any_#{const.to_s.underscore.gsub(/_validator\z/, "")}
+        record.errors.add(attribute, message, { :min_valid_count => 1, :max_valid_count => "" }.merge(options))
+      end
+    end
+
+    private
+    def count_valid?(valid_count)
+      (options[:min_valid_count] || 1) <= valid_count &&
+        (options[:max_valid_count].nil? || valid_count <= options[:max_valid_count])
+    end
+  end
+EOS
+end
+
+Detox::Validations.module_eval(validators_source)
+

data/lib/detox/validations/ordering.rb

@@ -0,0 +1,34 @@
+# coding: utf-8
+require "active_support/core_ext"
+require "detox/array_validity"
+
+module Detox::Validations
+  class OrderingValidator < ActiveModel::EachValidator
+    include Detox::ArrayValidity
+
+    def validate_each(record, attribute, value)
+      values = convert_to_validatee(value, options.slice(*Detox::ArrayValidity::RESERVED_OPTIONS))
+      return if values.blank?
+
+      unless values_valid?(values)
+        message = options[:message] || :invalid_as_order
+        record.errors.add(attribute, message)
+      end
+    end
+
+    private
+    def values_valid?(values)
+      valid_numbers(values.length).map(&:to_s).sort == values.map(&:to_s).sort
+    end
+
+    def valid_numbers(length)
+      last_number = first_number + length
+      (first_number...last_number).to_a
+    end
+
+    def first_number
+      num = options[:start_with].to_i
+      num.zero? ? 1 : num
+    end
+  end
+end

data/lib/detox/validations/possession.rb

@@ -0,0 +1,30 @@
+# coding: utf-8
+require "detox/array_validity"
+
+module Detox::Validations
+  class PossessionValidator < ActiveModel::EachValidator
+    include Detox::ArrayValidity
+
+    ERROR_MESSAGE = ":target must be supplied".freeze
+
+    def validate_each(record, attribute, value)
+      values = convert_to_validatee(value, options.slice(*Detox::ArrayValidity::RESERVED_OPTIONS))
+      return if values.blank?
+
+      unless values_valid?(values)
+        message = options[:message] || :possession
+        record.errors.add(attribute, message, options.merge(:target => [options[:target]].flatten.join(", ")))
+      end
+    end
+
+    def check_validity!
+      raise ArgumentError, ERROR_MESSAGE if options[:target].blank?
+    end
+
+    private
+    def values_valid?(values)
+      [options[:target]].flatten.all? { |t| values.include?(t) }
+    end
+  end
+end
+

data/lib/detox/validity_broker.rb

@@ -0,0 +1,55 @@
+# coding: utf-8
+module Detox
+  class ValidityBroker
+    attr_reader :errors
+    attr_accessor :validatee
+
+    def initialize
+      @validity = true
+      @errors = Errors.new(self)
+    end
+
+    def valid?
+      value = @validity
+      validitize
+      value
+    end
+
+    def invalid?
+      value = @validity
+      validitize
+      !value
+    end
+
+    def validitize
+      @validity = true
+    end
+
+    def invaliditize
+      @validity = false
+    end
+
+    def read_attribute_for_validation(attribute)
+      validatee
+    end
+
+    class Errors
+      def initialize(broker)
+        @broker = broker
+      end
+
+      def add(*inane_args)
+        @broker.invaliditize
+      end
+
+      # for support PresenceValidator (version 3.2.x)
+      def add_on_blank(*inane_args)
+        add(*inane_args) if @broker.validatee.blank?
+      end
+
+      def clear
+        @broker.validitize
+      end
+    end
+  end
+end