detox 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4178ff8b870484f57cd8c4677afac7b1968526da
-  data.tar.gz: 682e7b0e9665a4b1bed0571aa24153260ca0ac76
+  metadata.gz: e3539084844db07a30aed07576d36bc3856a3676
+  data.tar.gz: 2718b759268e66ca0937e2af388a5c6f3e99a7d4
 SHA512:
-  metadata.gz: 6eed3e98b13ec01e85532664dd2b5319ecb112b54939d859b4da47ec26282cc01127d38a52cdfaaaf536eb18001bf70d7c2080a110c5813d8476a6e733237768
-  data.tar.gz: 8c449e6d0aa73fa2022aca80648fe43f5da3c05b3ac56fda822c1f21caa3d3b75a7150c5f616ce81b57ab998f186882f1618c22e9b7b1b1eee3902c2a842a6af
+  metadata.gz: 77da47126cd49d77e0a9abe5feefe4b1c47276ef4630f120ec3819be8360579b5c86b237d19374636aa6af10368693fd9b2aacc6f7a5f4f725e4ff93851b0523
+  data.tar.gz: 1db5eab41c1c3934dce9832d9a7d22588622099b6122f28966c35ba4fb864d432970e00b6d7dc1a26189be2639314077c693dcfc6d2ef4538ac0d63b64472e2f

data/README.md

@@ -27,6 +27,7 @@ Look [spec/test_class](https://github.com/pinzolo/detox/tree/master/spec/test_cl
 - Validators for attribute that has Array or Hash value
   - **ordering**: validates continuous numbers
   - **possession**: validates subset values
+  - **values_uniqueness**: validates unique 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.)
 
@@ -38,3 +39,9 @@ Look [spec/test_class](https://github.com/pinzolo/detox/tree/master/spec/test_cl
 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
+
+
+## Changelog
+- v1.0.0 (2013-11-07 JST):  First release
+- v1.0.1 (2013-11-13 JST):  Add ValuesUniquenessValidator
+

data/lib/detox.rb

@@ -3,6 +3,7 @@ require "active_model"
 require "active_support/i18n"
 require "detox/validations/ordering"
 require "detox/validations/possession"
+require "detox/validations/values_uniqueness"
 require "detox/validations/all"
 require "detox/validations/any"
 

data/lib/detox/locales/en.yml

@@ -3,6 +3,7 @@ en:
     messages:
       invalid_as_order: "is not satisfied as order"
       possession: "must possess target (target: %{target})"
+      values_not_unique: "contains duplicate value"
       all_presence: "can't contain blank value"
       all_absence: "can't contain not blank value"
       all_format: "contains invalid format value"

data/lib/detox/locales/ja.yml

@@ -3,6 +3,7 @@ ja:
     messages:
       invalid_as_order: "は順序として成立していません"
       possession: "には対象(%{target})が含まれている必要があります"
+      values_not_unique: "は重複する値を含んでいます"
       all_presence: "には空の値を含められません"
       all_absence: "には空ではない値を含められません"
       all_format: "には不正な形式の値が含まれています"

data/lib/detox/validations/values_uniqueness.rb

@@ -0,0 +1,25 @@
+# coding: utf-8
+require "active_support/core_ext"
+require "detox/array_validity"
+
+module Detox::Validations
+  class ValuesUniquenessValidator < 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] || :values_not_unique
+        record.errors.add(attribute, message)
+      end
+    end
+
+    private
+    def values_valid?(values)
+      values.uniq.length == values.length
+    end
+  end
+end
+

data/lib/detox/version.rb

@@ -1,4 +1,4 @@
 # coding: utf-8
 module Detox
-  VERSION = "1.0.0"
+  VERSION = "1.0.1"
 end

data/spec/detox/validations/values_uniqueness_spec.rb

@@ -0,0 +1,460 @@
+# coding: utf-8
+require "spec_helper"
+require "active_support/i18n"
+require "test_class/values_uniqueness_test"
+
+describe Detox::Validations::ValuesUniquenessValidator do
+  describe "validation result" do
+    context "when given no option" do# {{{
+      let(:test) { ValuesUniquenessTestWithoutOption.new }
+
+      context "when apply to nil" do
+        it "is valid" do
+          test.seq = nil
+          expect(test.valid?).to eq true
+        end
+      end
+
+      context "when apply to Array" do# {{{
+        context "when apply to [] (empty)" do
+          it "is valid" do
+            test.seq = []
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['1', '2', '3'] (no duplicate value, nil, empty and blank)" do
+          it "is valid" do
+            test.seq = ["1", "2", "3"]
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['1', '3', '1'] (contains duplicate value)" do
+          it "is invalid" do
+            test.seq = ["1", "3", "1"]
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['1', '2', nil, '3'] (no duplicate value but contains nil)" do
+          it "is valid" do
+            test.seq = ['1', '2', nil, '3']
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['1', '2', nil, '3', nil] (contains 2 nil)" do
+          it "is invalid" do
+            test.seq = ['1', '2', nil, '3', nil]
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['1', '2', '', '3'] (no duplicate value but contains empty)" do
+          it "is valid" do
+            test.seq = ['1', '2', "", '3']
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['1', '2', '', '3', ''] (contains 2 empty)" do
+          it "is invalid" do
+            test.seq = ['1', '2', "", '3', ""]
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['1', '2', '   ', '3'] (no duplicate value but contains blank)" do
+          it "is valid" do
+            test.seq = ['1', '2', "   ", '3']
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['1', '2', '   ', '3', '   '] (contains 2 blank)" do
+          it "is invalid" do
+            test.seq = ['1', '2', "   ", '3', "   "]
+            expect(test.valid?).to eq false
+          end
+        end
+      end# }}}
+
+      context "when apply to Hash" do# {{{
+        context "when apply to {} (empty)" do
+          it "is valid" do
+            test.seq = []
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '2', :b => '3', :c => '1' } (no duplicate value, nil, empty and blank)" do
+          it "is valid" do
+            test.seq = { :a => '2', :b => '3', :c => '1' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '1', :b => '2', :c => '1' } (contains duplicate value)" do
+          it "is invalid" do
+            test.seq = { :a => '1', :b => '2', :c => '1' }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => '1', :b => '2', :c => nil, :d => '3' } (no duplicate value but contains nil)" do
+          it "is valid" do
+            test.seq = { :a => '1', :b => '2', :c => nil, :d => '3' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '1', :b => '2', :c => nil, :d => '3', :e => nil } (contains 2 nil)" do
+          it "is invalid" do
+            test.seq = { :a => '1', :b => '2', :c => nil, :d => '3', :e => nil }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => '1', :b => '2', :c => '', :d => '3' } (no duplicate value but contains empty)" do
+          it "is valid" do
+            test.seq = { :a => '1', :b => '2', :c => '', :d => '3' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '1', :b => '2', :c => '', :d => '3', :e => '' } (contains 2 empty)" do
+          it "is invalid" do
+            test.seq = { :a => '1', :b => '2', :c => '', :d => '3', :e => '' }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => '1', :b => '2', :c => '   ', :d => '3' } (no duplicate value but contains blank)" do
+          it "is valid" do
+            test.seq = { :a => '1', :b => '2', :c => '   ', :d => '3' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '1', :b => '2', :c => '   ', :d => '3', :e => '   ' } (contains 2 blank)" do
+          it "is invalid" do
+            test.seq = { :a => '1', :b => '2', :c => '   ', :d => '3', :e => '   ' }
+            expect(test.valid?).to eq false
+          end
+        end
+      end# }}}
+    end# }}}
+
+    context "when given ignore_nil_value option" do# {{{
+      let(:test) { ValuesUniquenessTestWithIgnoreNilValueOption.new }
+
+      context "when apply to nil" do
+        it "is valid" do
+          test.seq = nil
+          expect(test.valid?).to eq true
+        end
+      end
+
+      context "when apply to Array" do# {{{
+        context "when apply to [] (empty)" do
+          it "is valid" do
+            test.seq = []
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['1', '2', '3'] (no duplicate value, nil, empty and blank)" do
+          it "is valid" do
+            test.seq = ["1", "2", "3"]
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['1', '3', '1'] (contains duplicate value)" do
+          it "is invalid" do
+            test.seq = ["1", "3", "1"]
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['1', '2', nil, '3'] (no duplicate value but contains nil)" do
+          it "is valid" do
+            test.seq = ['1', '2', nil, '3']
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['1', '2', nil, '3', nil] (contains 2 nil)" do
+          it "is valid" do
+            test.seq = ['1', '2', nil, '3', nil]
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['1', '2', '', '3'] (no duplicate value but contains empty)" do
+          it "is valid" do
+            test.seq = ['1', '2', "", '3']
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['1', '2', '', '3', ''] (contains 2 empty)" do
+          it "is invalid" do
+            test.seq = ['1', '2', "", '3', ""]
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['1', '2', '   ', '3'] (no duplicate value but contains blank)" do
+          it "is valid" do
+            test.seq = ['1', '2', "   ", '3']
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['1', '2', '   ', '3', '   '] (contains 2 blank)" do
+          it "is invalid" do
+            test.seq = ['1', '2', "   ", '3', "   "]
+            expect(test.valid?).to eq false
+          end
+        end
+      end# }}}
+
+      context "when apply to Hash" do# {{{
+        context "when apply to {} (empty)" do
+          it "is valid" do
+            test.seq = []
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '2', :b => '3', :c => '1' } (no duplicate value, nil, empty and blank)" do
+          it "is valid" do
+            test.seq = { :a => '2', :b => '3', :c => '1' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '1', :b => '2', :c => '1' } (contains duplicate value)" do
+          it "is invalid" do
+            test.seq = { :a => '1', :b => '2', :c => '1' }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => '1', :b => '2', :c => nil, :d => '3' } (no duplicate value but contains nil)" do
+          it "is valid" do
+            test.seq = { :a => '1', :b => '2', :c => nil, :d => '3' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '1', :b => '2', :c => nil, :d => '3', :e => nil } (contains 2 nil)" do
+          it "is valid" do
+            test.seq = { :a => '1', :b => '2', :c => nil, :d => '3', :e => nil }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '1', :b => '2', :c => '', :d => '3' } (no duplicate value but contains empty)" do
+          it "is valid" do
+            test.seq = { :a => '1', :b => '2', :c => '', :d => '3' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '1', :b => '2', :c => '', :d => '3', :e => '' } (contains 2 empty)" do
+          it "is invalid" do
+            test.seq = { :a => '1', :b => '2', :c => '', :d => '3', :e => '' }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => '1', :b => '2', :c => '   ', :d => '3' } (no duplicate value but contains blank)" do
+          it "is valid" do
+            test.seq = { :a => '1', :b => '2', :c => '   ', :d => '3' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '1', :b => '2', :c => '   ', :d => '3', :e => '   ' } (contains 2 blank)" do
+          it "is invalid" do
+            test.seq = { :a => '1', :b => '2', :c => '   ', :d => '3', :e => '   ' }
+            expect(test.valid?).to eq false
+          end
+        end
+      end# }}}
+    end# }}}
+
+    context "when given ignore_blank_value option" do# {{{
+      let(:test) { ValuesUniquenessTestWithIgnoreBlankValueOption.new }
+
+      context "when apply to nil" do
+        it "is valid" do
+          test.seq = nil
+          expect(test.valid?).to eq true
+        end
+      end
+
+      context "when apply to Array" do# {{{
+        context "when apply to [] (empty)" do
+          it "is valid" do
+            test.seq = []
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['1', '2', '3'] (no duplicate value, nil, empty and blank)" do
+          it "is valid" do
+            test.seq = ["1", "2", "3"]
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['1', '3', '1'] (contains duplicate value)" do
+          it "is invalid" do
+            test.seq = ["1", "3", "1"]
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['1', '2', nil, '3'] (no duplicate value but contains nil)" do
+          it "is valid" do
+            test.seq = ['1', '2', nil, '3']
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['1', '2', nil, '3', nil] (contains 2 nil)" do
+          it "is valid" do
+            test.seq = ['1', '2', nil, '3', nil]
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['1', '2', '', '3'] (no duplicate value but contains empty)" do
+          it "is valid" do
+            test.seq = ['1', '2', "", '3']
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['1', '2', '', '3', ''] (contains 2 empty)" do
+          it "is valid" do
+            test.seq = ['1', '2', "", '3', ""]
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['1', '2', '   ', '3'] (no duplicate value but contains blank)" do
+          it "is valid" do
+            test.seq = ['1', '2', "   ", '3']
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['1', '2', '   ', '3', '   '] (contains 2 blank)" do
+          it "is valid" do
+            test.seq = ['1', '2', "   ", '3', "   "]
+            expect(test.valid?).to eq true
+          end
+        end
+      end# }}}
+
+      context "when apply to Hash" do# {{{
+        context "when apply to {} (empty)" do
+          it "is valid" do
+            test.seq = []
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '2', :b => '3', :c => '1' } (no duplicate value, nil, empty and blank)" do
+          it "is valid" do
+            test.seq = { :a => '2', :b => '3', :c => '1' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '1', :b => '2', :c => '1' } (contains duplicate value)" do
+          it "is invalid" do
+            test.seq = { :a => '1', :b => '2', :c => '1' }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => '1', :b => '2', :c => nil, :d => '3' } (no duplicate value but contains nil)" do
+          it "is valid" do
+            test.seq = { :a => '1', :b => '2', :c => nil, :d => '3' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '1', :b => '2', :c => nil, :d => '3', :e => nil } (contains 2 nil)" do
+          it "is valid" do
+            test.seq = { :a => '1', :b => '2', :c => nil, :d => '3', :e => nil }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '1', :b => '2', :c => '', :d => '3' } (no duplicate value but contains empty)" do
+          it "is valid" do
+            test.seq = { :a => '1', :b => '2', :c => '', :d => '3' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '1', :b => '2', :c => '', :d => '3', :e => '' } (contains 2 empty)" do
+          it "is valid" do
+            test.seq = { :a => '1', :b => '2', :c => '', :d => '3', :e => '' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '1', :b => '2', :c => '   ', :d => '3' } (no duplicate value but contains blank)" do
+          it "is valid" do
+            test.seq = { :a => '1', :b => '2', :c => '   ', :d => '3' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '1', :b => '2', :c => '   ', :d => '3', :e => '   ' } (contains 2 blank)" do
+          it "is valid" do
+            test.seq = { :a => '1', :b => '2', :c => '   ', :d => '3', :e => '   ' }
+            expect(test.valid?).to eq true
+          end
+        end
+      end# }}}
+    end# }}}
+  end
+
+  describe "error message" do
+    context "when given no option" do# {{{
+      let(:test) { ValuesUniquenessTestWithoutOption.new }
+
+      context "when valid" do
+        before do
+          test.seq = ['1', '2', '3']
+          test.valid?
+        end
+
+        it "has no message" do
+          expect(test.errors.present?).to eq false
+        end
+      end
+      context "when invalid" do
+        before do
+          test.seq = ['1', '2', '1']
+          test.valid?
+        end
+
+        it "has 1 error message" do
+          expect(test.errors.empty?).to eq false
+          expect(test.errors.size).to eq 1
+        end
+        it "error message is associated with seq attribute" do
+          expect(test.errors.include?(:seq)).to eq true
+        end
+        it "error messsage is 'Seq contains duplicate value'" do
+          expect(test.errors.full_messages.first).to eq 'Seq contains duplicate value'
+        end
+      end
+      context "when using i18n" do
+        before do
+          @base_locale = I18n.locale
+          I18n.locale = :ja
+          test.seq = ['1', '2', '1']
+          test.valid?
+        end
+        after do
+          I18n.locale = @base_locale
+        end
+        it "error messsage is translated" do
+          expect(test.errors.full_messages.first).to eq 'Seq は重複する値を含んでいます'
+        end
+      end
+    end# }}}
+
+    context "when given message option" do# {{{
+      let(:test) { ValuesUniquenessTestWithMessageOption.new }
+
+      context "when invalid" do
+        before do
+          test.seq = ['1', '2', '1']
+          test.valid?
+        end
+        it "error messsage uses given message" do
+          expect(test.errors.full_messages.first).to eq 'Seq is invalid'
+        end
+      end
+      context "when using i18n" do
+        before do
+          @base_locale = I18n.locale
+          I18n.locale = :ja
+          test.seq = ['1', '2', '1']
+          test.valid?
+        end
+        after do
+          I18n.locale = @base_locale
+        end
+        it "error messsage is not translated" do
+          expect(test.errors.full_messages.first).to eq 'Seq is invalid'
+        end
+      end
+    end# }}}
+  end
+end
+

data/spec/test_class/values_uniqueness_test.rb

@@ -0,0 +1,27 @@
+# coding: utf-8
+require "test_class/model_base"
+
+class ValuesUniquenessTestWithoutOption < ModelBase
+  attr_accessor :seq
+
+  validates :seq, :values_uniqueness => true
+end
+
+class ValuesUniquenessTestWithIgnoreNilValueOption < ModelBase
+  attr_accessor :seq
+
+  validates :seq, :values_uniqueness => { :ignore_nil_value => true }
+end
+
+class ValuesUniquenessTestWithIgnoreBlankValueOption < ModelBase
+  attr_accessor :seq
+
+  validates :seq, :values_uniqueness => { :ignore_blank_value => true }
+end
+
+class ValuesUniquenessTestWithMessageOption < ModelBase
+  attr_accessor :seq
+
+  validates :seq, :values_uniqueness => { :message => "is invalid" }
+end
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: detox
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - pinzolo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-07 00:00:00.000000000 Z
+date: 2013-11-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -106,6 +106,7 @@ files:
 - lib/detox/validations/any.rb
 - lib/detox/validations/ordering.rb
 - lib/detox/validations/possession.rb
+- lib/detox/validations/values_uniqueness.rb
 - lib/detox/validity_broker.rb
 - lib/detox/version.rb
 - spec/detox/array_validity_spec.rb
@@ -128,6 +129,7 @@ files:
 - spec/detox/validations/any_validator_check_validity_spec.rb
 - spec/detox/validations/ordering_spec.rb
 - spec/detox/validations/possession_spec.rb
+- spec/detox/validations/values_uniqueness_spec.rb
 - spec/detox/validity_broker_spec.rb
 - spec/spec_helper.rb
 - spec/test_class/all_absence_test.rb
@@ -150,6 +152,7 @@ files:
 - spec/test_class/model_base.rb
 - spec/test_class/ordering_test.rb
 - spec/test_class/possession_test.rb
+- spec/test_class/values_uniqueness_test.rb
 homepage: https://github.com/pinzolo/detox
 licenses:
 - MIT
@@ -195,6 +198,7 @@ test_files:
 - spec/detox/validations/any_validator_check_validity_spec.rb
 - spec/detox/validations/ordering_spec.rb
 - spec/detox/validations/possession_spec.rb
+- spec/detox/validations/values_uniqueness_spec.rb
 - spec/detox/validity_broker_spec.rb
 - spec/spec_helper.rb
 - spec/test_class/all_absence_test.rb
@@ -217,3 +221,4 @@ test_files:
 - spec/test_class/model_base.rb
 - spec/test_class/ordering_test.rb
 - spec/test_class/possession_test.rb
+- spec/test_class/values_uniqueness_test.rb