hydra-validations 0.3.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 14a1051a97f663c054e73db5a4f50c90a45a447a
-  data.tar.gz: d7ffb762b468269fc1275604c50bacdabb05f83b
+  metadata.gz: 6cd9dc181595609320187b6967b7419c584e5592
+  data.tar.gz: e87ae57ed9847709bccd5979eee498381707cc13
 SHA512:
-  metadata.gz: ceca377220db7fc7391c1d8bc2cc4729579b74c8fc9508cc11f60a98f3a79aff6d08c7480f4218e8e6f39811a1ba06f7b39fd83255ce8e72cd249865a7b69d05
-  data.tar.gz: 4c24af4ec23bfddbb3635486be91d310d2acd4c8225bdc17166b06be0f90ea1ef57e59105dcedba9f6106f53e60e53d0f1820d1db149d867a25bf187d7500f46
+  metadata.gz: 45b9a25dd9f59461d336b8877e14371f67ef764ed0b879960f375f97e60236a646c29cef36660703598a2fe3ac46f6f7a7a0ea2ee1be020ea6552e94c914bfa7
+  data.tar.gz: 0212d9e7f159ddbacf0a291b4a80a91f95659aa95474c7cff67e337e57132fb37d2f39e2be660c4cfaaa0f856d51d62884c715196ca6b061522645e8c154aa23

data/README.md

@@ -25,13 +25,15 @@ and
 bundle install
 ```
 
+## EnumerableBehavior Mixin
+
 ## Validators
 
 See also the source code and spec tests.
 
 ### FormatValidator
 
-Extends the ActiveModel version to validate the format of *each member* of an enumerable attribute value.
+Extends the ActiveModel::Validations::FormatValidator, adding EnumerableBehavior.
 
 See documentation for ActiveModel::Validations::FormatValidator for usage and options.
 
@@ -63,7 +65,7 @@ end
 
 ### InclusionValidator
 
-Extends the ActiveModel version to validate inclusion of *each member* of an enumerable attribute value.
+Extends ActiveModel::Validations::InclusionValidator, adding EnumerableBehavior.
 
 See documentation for ActiveModel::Validations::InclusionValidator for usage and options.
 
@@ -73,6 +75,8 @@ class InclusionValidatable
   include Hydra::Validations
   attr_accessor :field
   validates :field, inclusion: { in: ["foo", "bar", "baz"] }
+  # or using helper method ...
+  # validates_inclusion_of :field, in: ["foo", "bar", "baz"]
 end
 
 > v = InclusionValidatable.new
@@ -103,7 +107,6 @@ class UniquenessValidatable < ActiveFedora::Base
   has_metadata name: 'descMetadata', type: ActiveFedora::QualifiedDublinCoreDatastream
   has_attributes :title, datastream: 'descMetadata', multiple: false
   # Can use with multi-value attributes, but single cardinality is required.
-  # See SingleCardinalityValidator below.
   has_attributes :source, datastream: 'descMetadata', multiple: true
   validates :source, uniqueness: { solr_name: "source_ssim" }
   # ... or using helper method
@@ -111,20 +114,35 @@ class UniquenessValidatable < ActiveFedora::Base
 end
 ```
 
-### SingleCardinalityValidator
+### CardinalityValidator
+
+Validates the cardinality of the attribute value. 
+
+CardinalityValidator is a subclass of ActiveModel::Validations::LengthValidator which
+"tokenizes" values with `Array.wrap(value)`.  The "cardinality" of the value
+is the length the array. Hence,
+
+- `nil` and empty enumerables have cardinality 0
+- scalar values (including empty string) have cardinality 1.
 
-Validates that the attribute value is a scalar or single-member enumerable.
+CardinalityValidator customizes the `:wrong_length`, `:too_short` and `:too_long` messages
+of LengthValidator to use language appropriate to cardinality. You can also override these 
+options.
 
 ```ruby
-class Validatable
+class CardinalityValidatable
   include ActiveModel::Validations # required if not already included in class
   include Hydra::Validations
   attr_accessor :field
-  validates :field, single_cardinality: true
+  validates :field, cardinality: { is: 1 }
+  # or with helper method ...
+  # validates_cardinality_of :field, is: 1
+  # or, for single cardinality (same as above) ...
+  # validates_single_cardinality_of :field
 end
 
-> Validatable.validators
- => [#<Hydra::Validations::SingleCardinalityValidator:0x007fb91d1e9460 @attributes=[:field], @options={}>] 
+> CardinalityValidatable.validators
+ => [#<Hydra::Validations::CardinalityValidator:0x007fb91d1e9460 @attributes=[:field], @options={:is=>1}>] 
 > v = Validatable.new
  => #<Validatable:0x007fb91d1c9188> 
 > v.field = "foo"

data/lib/hydra/validations.rb

@@ -14,7 +14,7 @@ module Hydra
       protected
       # Overwrites ActiveModel::Validations::ClassMethods, adding :allow_empty
       def _validates_default_keys
-        [:if, :unless, :on, :allow_blank, :allow_nil , :strict, :allow_empty]
+        [:if, :unless, :on, :allow_blank, :allow_nil, :strict, :allow_empty]
       end
     end
 

data/lib/hydra/validations/cardinality.rb

@@ -1,20 +1,57 @@
+require 'active_support/core_ext/array/wrap'
+
 module Hydra
   module Validations
     #
-    # Cardinality - a mixin adding cardinality validation methods.
+    # CardinalityValidator - A cardinality validator for enumerable values based on
+    # ActiveModel's LengthValidator.
+    #
+    # validates :field, cardinality: { minimum: 1, maximum: 5 }
+    # validates :field, cardinality: { in: 1..5 }
+    # validates :field, cardinality: { within: 1..5 }
+    # validates :field, cardinality: { is: 1 }
     #
-    module Cardinality
+    # See ActiveModel::Validations::LengthValidator for options.
+    #
+    class CardinalityValidator < ActiveModel::Validations::LengthValidator
+
+      def initialize(options = {})
+        super(default_options.merge(options))
+      end
 
-      def validate_cardinality(cardinality, record, attribute, value)
-        return validate_single_cardinality(record, attribute, value) if cardinality == :single
-        raise ArgumentError, "Cardinality validation not supported: #{cardinality.inspect}"
+      def validate_each(record, attribute, value)
+        return if options[:allow_empty] && value.respond_to?(:empty?) && value.empty?
+        super
       end
 
-      def validate_single_cardinality(record, attribute, value)
-        # TODO i18n message
-        record.errors.add(attribute, "can't have more than one value") if value.respond_to?(:each) && value.size > 1
+      protected
+
+      def default_options
+        { wrong_length: "has the wrong cardinality (should have %{count} value(s))", 
+          too_short: "has too few values (minimum cardinality is %{count})", 
+          too_long: "has too many values (maximum cardinality is %{count})"
+        }
+      end
+
+      private 
+
+      # Override
+      def tokenize(value)
+        Array.wrap(value)
       end
 
     end
+
+    module HelperMethods
+      def validates_cardinality_of *attr_names
+        validates_with CardinalityValidator, _merge_attributes(attr_names)
+      end
+
+      def validates_single_cardinality_of *attr_names
+        options = _merge_attributes(attr_names).merge(is: 1)
+        validates_with CardinalityValidator, options
+      end
+    end
+
   end
 end

data/lib/hydra/validations/enumerable_behavior.rb

@@ -7,10 +7,15 @@ module Hydra
     # Behavior includes 'fixing' each error message to include the specific value
     # which was invalid.
     #
-    # `allow_empty` option can be used instead of `allow_blank` for greater
+    # The `allow_empty` option can be used instead of `allow_blank` for greater
     # clarity and precision with enumerable values. If a validator includes
-    # this mixin, then an empty enumerable value will always be invalid if
-    # `allow_empty` is false or nil.
+    # this mixin, an empty enumerable value will *always* be invalid unless
+    # `allow_empty` is true.
+    #
+    # Note that `allow_nil` and `allow_blank` options apply to the enumerable
+    # value, not to its members. Thus, for example, `allow_blank: true` will
+    # not bypass validation of the value `[""]` even though its member `""` 
+    # is blank.
     #
     module EnumerableBehavior
 

data/lib/hydra/validations/uniqueness.rb

@@ -1,5 +1,4 @@
-require 'hydra/validations'
-require 'hydra/validations/cardinality'
+require 'active_support/core_ext/array/wrap'
 
 module Hydra
   module Validations
@@ -25,22 +24,26 @@ module Hydra
     #
     class UniquenessValidator < ActiveModel::EachValidator
 
-      include Cardinality
-
       def check_validity!
-        raise ArgumentError, "UniquenessValidator accepts only a single attribute: #{attribues}" if attributes.length > 1 
-        raise ArgumentError, "UniquenessValidator requires the :solr_name option be present." unless options[:solr_name].present?
+        if attributes.length > 1 
+          raise ArgumentError, "UniquenessValidator accepts only a single attribute: #{attributes}" 
+        end
+        unless options[:solr_name].present?
+          raise ArgumentError, "UniquenessValidator requires the :solr_name option be present." 
+        end
       end
 
       def validate_each(record, attribute, value)
-        # TODO: i18n messages
-        validate_cardinality(:single, record, attribute, value)
-        # Validate uniqueness proper only if value is of single cardinality
-        return if record.errors.added?(attribute, "can't have more than one value") 
-        value = value.first if value.respond_to?(:each)
-        conditions = {options[:solr_name] => value}
-        conditions.merge!("-id" => record.id) if record.persisted?
-        record.errors.add attribute, "has already been taken" if record.class.exists?(conditions)
+        wrapped_value = Array.wrap(value)
+        if wrapped_value.length > 1
+          record.errors.add(attribute, "can't have more than one value") 
+        elsif wrapped_value.empty? 
+          record.errors.add(attribute, "can't be empty") unless options[:allow_empty]
+        else
+          conditions = {options[:solr_name] => wrapped_value.first}
+          conditions.merge!("-id" => record.id) if record.persisted?
+          record.errors.add attribute, "has already been taken" if record.class.exists?(conditions)
+        end
       end
 
     end

data/lib/hydra/validations/version.rb

@@ -1,5 +1,5 @@
 module Hydra
   module Validations
-    VERSION = "0.3.2"
+    VERSION = "0.4.0"
   end
 end

data/spec/validations/cardinality_validator_spec.rb

@@ -0,0 +1,199 @@
+require 'spec_helper'
+
+describe Hydra::Validations::CardinalityValidator do
+
+  before(:all) do
+    class Validatable
+      include ActiveModel::Validations
+      include Hydra::Validations
+      attr_accessor :field
+    end
+  end
+
+  before(:each) do
+    Validatable.clear_validators!
+    Validatable.validates :field, options 
+    allow(record).to receive(:field) { value }
+  end
+
+  after(:all) { Object.send(:remove_const, :Validatable) }
+
+  let(:record) { Validatable.new }
+
+  let(:opts) { { cardinality: cardinality } }
+
+  shared_examples "it has cardinality 0" do
+    let(:options) { opts }
+    describe "and :is == 0" do
+      let(:cardinality) { { is: 0 } }
+      it "should be valid" do
+        expect(record).to be_valid
+      end
+    end
+    describe "and :is > 0" do
+      let(:cardinality) { { is: 1 } }
+      it "should be invalid" do
+        expect(record).to be_invalid
+      end
+    end
+    describe "and :minimum == 0" do
+      let(:cardinality) { { minimum: 0 } }
+      it "should be valid" do
+        expect(record).to be_valid
+      end
+    end
+    describe "and :minimum > 0" do
+      let(:cardinality) { { minimum: 1 } }
+      it "should be invalid" do
+        expect(record).to be_invalid
+      end
+    end
+  end
+
+  shared_examples "it has cardinality 1" do
+    let(:options) { opts }
+    describe "and is == 0" do
+      let(:cardinality) { { is: 0 } }
+      it "should be invalid" do
+        expect(record).to be_invalid
+      end
+    end
+    describe "and :is == 1" do
+      let(:cardinality) { { is: 1 } }
+      it "should be valid" do
+        expect(record).to be_valid
+      end
+    end
+    describe "and :is > 1" do
+      let(:cardinality) { { is: 2 } }
+      it "should be invalid" do
+        expect(record).to be_invalid
+      end
+    end
+    describe "and :minimum == 0" do
+      let(:cardinality) { { minimum: 0 } }
+      it "should be valid" do
+        expect(record).to be_valid
+      end
+    end
+    describe "and :minimum == 1" do
+      let(:cardinality) { { minimum: 1 } }
+      it "should be valid" do
+        expect(record).to be_valid
+      end
+    end
+    describe "and :minimum > 1" do
+      let(:cardinality) { { minimum: 2 } }
+      it "should be invalid" do
+        expect(record).to be_invalid
+      end
+    end
+    describe "and :maximum == 0" do
+      let(:cardinality) { { maximum: 0 } }
+      it "should be invalid" do
+        expect(record).to be_invalid
+      end
+    end
+    describe "and :maximum == 1" do
+      let(:cardinality) { { maximum: 1 } }
+      it "should be valid" do
+        expect(record).to be_valid
+      end
+    end
+    describe "and :maximum > 1" do
+      let(:cardinality) { { maximum: 2 } }
+      it "should be valid" do
+        expect(record).to be_valid
+      end
+    end
+  end
+
+  describe "when value is nil" do
+    let(:value) { nil }
+    it_behaves_like "it has cardinality 0"
+  end
+
+  describe "when value is an empty string" do
+    let(:value) { "" }
+    it_behaves_like "it has cardinality 1"
+  end
+
+  describe "when value is a non-empty string" do
+    let(:value) { "foo" }
+    it_behaves_like "it has cardinality 1"
+  end
+
+  describe "when value is an empty enumerable" do
+    let(:value) { [] }
+    it_behaves_like "it has cardinality 0"
+    describe "and `allow_empty: true`" do
+      let(:options) { opts.merge(allow_empty: true) }
+      describe "and :is != 0" do
+        let(:cardinality) { { is: 1 } }
+        it "should be valid" do
+          expect(record).to be_valid
+        end
+      end
+      describe "and :minimum > 0" do
+        let(:cardinality) { { minimum: 1 } }
+        it "should be valid" do
+          expect(record).to be_valid
+        end
+      end
+    end
+  end
+
+  describe "when value is a non-empty enumerable" do
+    let(:value) { ["foo", "bar"] }
+    let(:options) { opts }
+    describe "and :is != length" do
+      let(:cardinality) { { is: 1 } }
+      it "should be invalid" do
+        expect(record).to be_invalid
+      end
+    end
+    describe "and :is == length" do
+      let(:cardinality) { { is: 2 } }
+      it "should be valid" do
+        expect(record).to be_valid
+      end
+    end
+    describe "and :minimum < length" do
+      let(:cardinality) { { minimum: 1 } }
+      it "should be valid" do
+        expect(record).to be_valid
+      end
+    end
+    describe "and :minimum == length" do
+      let(:cardinality) { { minimum: 2 } }
+      it "should be valid" do
+        expect(record).to be_valid
+      end
+    end
+    describe "and :minimum > length" do
+      let(:cardinality) { { minimum: 3 } }
+      it "should be invalid" do
+        expect(record).to be_invalid
+      end
+    end
+    describe "and :maximum < length" do
+      let(:cardinality) { { maximum: 1 } }
+      it "should be invalid" do
+        expect(record).to be_invalid
+      end
+    end
+    describe "and :maximum == length" do
+      let(:cardinality) { { maximum: 2 } }
+      it "should be valid" do
+        expect(record).to be_valid
+      end
+    end
+    describe "and :maximum > length" do
+      let(:cardinality) { { maximum: 3 } }
+      it "should be valid" do
+        expect(record).to be_valid
+      end
+    end
+  end
+
+end

data/spec/validations/format_validator_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Hydra::Validations::FormatValidator do
+
+  before(:all) do
+    class Validatable
+      include ActiveModel::Validations
+      include Hydra::Validations
+      attr_accessor :field
+      validates :field, format: { with: /\A[[:alpha:]]+\Z/ }
+    end
+  end
+
+  after(:all) { Object.send(:remove_const, :Validatable) }
+
+  before(:each) { allow(record).to receive(:field) { value } }
+
+  let(:record) { Validatable.new }
+
+  describe "when the value is a scalar" do
+    describe "which matches the format" do
+      let(:value) { "foo" }
+      it "should be valid" do
+        expect(record).to be_valid
+      end
+    end
+    describe "which does not match the format" do
+      let(:value) { "foo1" }
+      it "should be invalid" do
+        expect(record).to be_invalid
+      end
+      it "should have the standard error message" do
+        record.valid?
+        # TODO i18n
+        expect(record.errors[:field]).to eq ["is invalid"]
+      end
+    end
+  end
+
+  describe "when the value is an enumerable" do
+    describe "and all value members match the format" do
+      let(:value) { ["foo", "bar"] }
+      it "should be valid" do
+        expect(record).to be_valid
+      end
+    end
+    describe "and one value member does not match the format" do
+      let(:value) { ["foo1", "bar"] }
+      it "should be invalid" do
+        expect(record).to be_invalid
+      end
+      it "should 'fix' the error message to include the value" do
+        record.valid?
+        # TODO i18n
+        expect(record.errors[:field]).to eq ["value \"foo1\" is invalid"]
+      end
+    end
+  end
+
+end

data/spec/validations/helper_methods_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe Hydra::Validations::HelperMethods do
+
+  before(:all) do
+    class Validatable
+      include ActiveModel::Validations
+      include Hydra::Validations
+      attr_accessor :field
+    end
+  end
+
+  before(:each) { Validatable.clear_validators! }
+
+  after(:all) { Object.send(:remove_const, :Validatable) }
+
+  subject { Validatable.validators.first }
+
+  describe ".validates_cardinality_of" do
+    before { Validatable.validates_cardinality_of :field, is: 1 }
+    it "should add a cardinality validator" do
+      expect(subject).to be_a Hydra::Validations::CardinalityValidator
+      expect(subject.options).to include({ is: 1 })
+    end
+  end
+
+  describe ".validates_single_cardinality_of" do
+    before { Validatable.validates_single_cardinality_of :field }
+    it "should add a cardinality validator having :is=>1" do
+      expect(subject).to be_a Hydra::Validations::CardinalityValidator
+      expect(subject.attributes).to eq [:field]
+      expect(subject.options).to include({ is: 1 })
+    end
+  end
+
+  describe ".validates_format_of" do
+    before { Validatable.validates_format_of :field, with: /\A[[:alpha:]]+\Z/ }
+    it "should add a format validator" do
+      expect(subject).to be_a Hydra::Validations::FormatValidator
+      expect(subject.attributes).to eq [:field]
+      expect(subject.options).to include({ with: /\A[[:alpha:]]+\Z/ })
+    end
+  end
+
+  describe ".validates_inclusion_of" do
+    before { Validatable.validates_inclusion_of :field, in: ["foo", "bar", "baz"] }
+    it "should add an inclusion validator" do
+      expect(subject).to be_a Hydra::Validations::InclusionValidator
+      expect(subject.attributes).to eq [:field]
+      expect(subject.options).to include({ in: ["foo", "bar", "baz"] })
+    end
+  end
+
+  describe ".validates_uniqueness_of" do
+    before { Validatable.validates_uniqueness_of :title, solr_name: "title_ssi" }
+    it "should add a uniqueness validator" do
+      expect(subject).to be_a Hydra::Validations::UniquenessValidator
+      expect(subject.attributes).to eq [:title]
+      expect(subject.options).to include({ solr_name: "title_ssi" })
+    end
+  end
+
+end

data/spec/{validators → validations}/uniqueness_validator_spec.rb

@@ -1,21 +1,6 @@
 require 'spec_helper'
 require 'support/shared_examples_for_validators'
 
-shared_examples "it validates the uniqueness of the attribute value" do
-  context "when the value is not taken" do
-    before { allow(Validatable).to receive(:exists?).with(conditions) { false } }
-    it "should be valid" do
-      expect(subject).to be_valid
-    end
-  end
-  context "when the value is taken" do
-    before { allow(Validatable).to receive(:exists?).with(conditions) { true } }
-    it "should not be valid" do
-      expect(subject).not_to be_valid
-    end
-  end
-end
-
 describe Hydra::Validations::UniquenessValidator do
 
   before(:all) do
@@ -41,8 +26,9 @@ describe Hydra::Validations::UniquenessValidator do
 
   after(:all) { Object.send(:remove_const, :Validatable) }
 
+  before(:each) { Validatable.clear_validators! }
+
   describe "exceptions" do
-    before { Validatable.clear_validators! }
     it "cannot be used on more than one attribute at a time" do
       expect { Validatable.validates :title, :source, uniqueness: { solr_name: "snafu_ssim" } }.to raise_error
     end
@@ -52,18 +38,26 @@ describe Hydra::Validations::UniquenessValidator do
   end
 
   describe "validation" do
+
     subject { Validatable.new(pid: "foobar:1", title: "I am Unique!", source: ["Outer Space"]) }
-    context "with a scalar attribute (:multiple=>false)" do
-      before(:all) do
-        Validatable.clear_validators!
-        Validatable.validates_uniqueness_of :title, solr_name: "title_ssi"
+
+    shared_examples "it validates the uniqueness of the attribute value" do
+      context "when the value is not taken" do
+        before { allow(Validatable).to receive(:exists?).with(conditions) { false } }
+        it "should be valid" do
+          expect(subject).to be_valid
+        end
       end
-      context "cardinality validation" do
-        before { allow(Validatable).to receive(:exists?) { false } }
-        it_behaves_like "it validates the single cardinality of a scalar attribute" do
-          let(:attribute) { :title }
+      context "when the value is taken" do
+        before { allow(Validatable).to receive(:exists?).with(conditions) { true } }
+        it "should not be valid" do
+          expect(subject).not_to be_valid
         end
       end
+    end
+
+    context "with a scalar attribute (:multiple=>false)" do
+      before { Validatable.validates :title, uniqueness: { solr_name: "title_ssi" } }
       context "when the record is new" do
         before { allow(subject).to receive(:persisted?) { false } }
         it_behaves_like "it validates the uniqueness of the attribute value" do
@@ -77,17 +71,9 @@ describe Hydra::Validations::UniquenessValidator do
         end
       end
     end
+
     context "with an enumerable attribute (:multiple=>true)" do
-      before(:all) do
-        Validatable.clear_validators!
-        Validatable.validates_uniqueness_of :source, solr_name: "source_ssim"
-      end
-      context "cardinality validation" do
-        before { allow(Validatable).to receive(:exists?) { false } }
-        it_behaves_like "it validates the single cardinality of an enumerable attribute" do
-          let(:attribute) { :source }
-        end
-      end
+      before { Validatable.validates :source, uniqueness: { solr_name: "source_ssim" } }
       context "when the record is new" do
         before { allow(subject).to receive(:persisted?) { false } }
         it_behaves_like "it validates the uniqueness of the attribute value" do
@@ -101,5 +87,6 @@ describe Hydra::Validations::UniquenessValidator do
         end
       end
     end
+
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hydra-validations
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.4.0
 platform: ruby
 authors:
 - dchandekstark
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-08 00:00:00.000000000 Z
+date: 2014-09-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -88,15 +88,15 @@ files:
 - lib/hydra/validations/enumerable_behavior.rb
 - lib/hydra/validations/format.rb
 - lib/hydra/validations/inclusion.rb
-- lib/hydra/validations/single_cardinality.rb
 - lib/hydra/validations/uniqueness.rb
 - lib/hydra/validations/version.rb
 - spec/spec_helper.rb
 - spec/support/shared_examples_for_validators.rb
-- spec/validators/format_validator_spec.rb
-- spec/validators/inclusion_validator_spec.rb
-- spec/validators/single_cardinality_validator_spec.rb
-- spec/validators/uniqueness_validator_spec.rb
+- spec/validations/cardinality_validator_spec.rb
+- spec/validations/format_validator_spec.rb
+- spec/validations/helper_methods_spec.rb
+- spec/validations/inclusion_validator_spec.rb
+- spec/validations/uniqueness_validator_spec.rb
 homepage: https://github.com/duke-libraries/hydra-validations
 licenses:
 - APACHE2
@@ -125,7 +125,8 @@ summary: Validations for Hydra applications, based on ActiveModel::Validations
 test_files:
 - spec/spec_helper.rb
 - spec/support/shared_examples_for_validators.rb
-- spec/validators/format_validator_spec.rb
-- spec/validators/inclusion_validator_spec.rb
-- spec/validators/single_cardinality_validator_spec.rb
-- spec/validators/uniqueness_validator_spec.rb
+- spec/validations/cardinality_validator_spec.rb
+- spec/validations/format_validator_spec.rb
+- spec/validations/helper_methods_spec.rb
+- spec/validations/inclusion_validator_spec.rb
+- spec/validations/uniqueness_validator_spec.rb

data/lib/hydra/validations/single_cardinality.rb

@@ -1,32 +0,0 @@
-require 'hydra/validations/cardinality'
-
-module Hydra
-  module Validations
-    #
-    # SingleCardinalityValidator - validates that an enumerator value has size 0 or 1
-    #
-    #    validates :myattr, single_cardinality: true
-    #    validates_single_cardinality_of :myattr
-    #
-    # Blank and nil values are considered valid (even without :allow_blank or :allow_nil
-    # validator options).
-    #
-    class SingleCardinalityValidator < ActiveModel::EachValidator
-      
-      include Cardinality
-
-      def validate_each(record, attribute, value)
-        validate_cardinality(:single, record, attribute, value)
-      end
-
-    end
-
-    module HelperMethods
-      def validates_single_cardinality_of *attr_names
-        validates_with SingleCardinalityValidator, _merge_attributes(attr_names)
-      end
-    end
-
-  end
-end
-

data/spec/validators/format_validator_spec.rb

@@ -1,61 +0,0 @@
-require 'spec_helper'
-require 'support/shared_examples_for_validators'
-
-shared_examples "it validates the format of each member of the attribute value" do
-  context "all attribute value members are valid" do
-    before { record.field = ["foo", "bar"] }
-    it "should be valid" do
-      expect(record).to be_valid
-    end
-  end
-
-  context "one of the attribute value members is invalid" do
-    before { record.field = ["foo1", "bar"] }
-    it "should be invalid" do
-      expect(record).to be_invalid
-    end
-    it "should 'fix' the error message to include the value" do
-      record.valid?
-      expect(record.errors[:field]).to eq ["value \"foo1\" is invalid"]
-    end
-  end
-end
-
-describe Hydra::Validations::FormatValidator do
-
-  before(:all) do
-    class Validatable
-      include ActiveModel::Validations
-      include Hydra::Validations
-      attr_accessor :field
-    end
-  end
-
-  before(:each) { Validatable.clear_validators! }
-
-  after(:all) { Object.send(:remove_const, :Validatable) }
-
-  describe "class methods" do
-    describe ".validates" do
-      before { Validatable.validates :field, format: { with: /\A[[:alpha:]]+\Z/ } }
-      it_behaves_like "it validates the format of each member of the attribute value" do
-        let(:record) { Validatable.new }
-      end
-    end
-  end
-  describe "helper methods" do
-    describe ".validates_format_of" do
-      before { Validatable.validates_format_of :field, with: /\A[[:alpha:]]+\Z/ }
-      it_behaves_like "it validates the format of each member of the attribute value" do
-        let(:record) { Validatable.new }
-      end
-    end
-  end
-
-  it_behaves_like "an enumerable validator" do
-    let(:options) { { format: { with: /\A[[:alpha:]]+\Z/ } } }
-    let(:record_class) { Validatable }
-    let(:attribute) { :field }
-  end
-
-end

data/spec/validators/single_cardinality_validator_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-require 'support/shared_examples_for_validators'
-
-shared_examples "it validates the single cardinality of the attribute" do
-  it_behaves_like "it validates the single cardinality of a scalar attribute"
-  it_behaves_like "it validates the single cardinality of an enumerable attribute"
-end
-
-describe Hydra::Validations::SingleCardinalityValidator do
-  before(:all) do
-    class Validatable
-      include ActiveModel::Validations
-      include Hydra::Validations
-      attr_accessor :field
-    end
-  end
-  before(:each) { Validatable.clear_validators! }
-  after(:all) { Object.send(:remove_const, :Validatable) }
-  subject { Validatable.new }
-  describe ".validates" do
-    before { Validatable.validates :field, single_cardinality: true }
-    it_behaves_like "it validates the single cardinality of the attribute" do
-      let(:attribute) { :field }
-    end
-  end
-  describe ".validates_single_cardinality_of" do
-    before { Validatable.validates_single_cardinality_of :field }
-    it_behaves_like "it validates the single cardinality of the attribute" do
-      let(:attribute) { :field }
-    end
-  end
-end
-