attestor 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 30d3fe02039b7df2f24461bd4eb4387deda2e93c
-  data.tar.gz: f1ec4731ded236180c094171dff71d10fad448db
+  metadata.gz: e5d5fbaf26c97f5c5dd838289b64904714d118b7
+  data.tar.gz: 777f4abaa5ef17cfe19627cbb69b9e960394a4c7
 SHA512:
-  metadata.gz: 595eaa79f730fdf98e8119e5d98c30f0711278ada88dde24b87dc3ea770a8206fef0d0a2c899714504299b530f4eeb93898f1666fb2d61601e01954a76ed6436
-  data.tar.gz: 47078bc23acc2749312d84e9b343ae9236b300b099bafbb7a4554a5c4b34a7c0f7579716597ccdd736d7b3e05edc2956f7b8ad7d353cb226aafbe31e844933d2
+  metadata.gz: 91138866beb8ef0615181d4ab9c3a9cbad86f3bb2b238b648f155b0b7fea5d6a1b2b48185762e7b5289b66965faa5f7bc9c62c49e85db2705744ae28f4bdfd42
+  data.tar.gz: 3ff1370688ca7712e5e7fdfad088e8298f73e10a85f17e247923cec2e05ed36f0791604342c1a3ae77c481c9d702710a90861b5d80640b5464910280582072e4

data/README.md

@@ -39,8 +39,6 @@ Approach
 
 Instead of collecting errors inside the object, the module's `validate` instance method just raises an exception (`Attestor::InvalidError`), that carries errors outside of the object. The object stays untouched (and can be made immutable).
 
-So to speak, validation just attests at the object and complains loudly when things goes wrong.
-
 Installation
 ------------
 
@@ -66,8 +64,6 @@ gem install attestor
 Basic Use
 ----------
 
-`Attestor::Validations` API consists of 1 class method `.validate` and 2 instance methods (`validate` and `invalid`).
-
 Declare validation in the same way as ActiveModel's `.validate` method does:
 
 ```ruby
@@ -95,11 +91,12 @@ end
 
 The `#invalid` method translates its argument in a current class scope and raises an exception.
 
-```ruby
+```yaml
 # config/locales/en.yml
+---
 en:
   attestor:
-    validations:
+    errors:
       transfer:
         inconsistent: "Credit differs from debet by %{fraud}"
 ```
@@ -120,7 +117,7 @@ rescue => error
 end
 ```
 
-Adding Contexts
+Use of Contexts
 ---------------
 
 Sometimes you need to validate the object agaist the subset of validations, not all of them.
@@ -142,17 +139,17 @@ fraud_transfer.validate                 # => InvalidError
 fraud_transfer.validate :steal_of_money # => PASSES!
 ```
 
-Just as the `:except` option blacklists validations, the `:only` method whitelists them:
+You can use the same validator several times with different contexts. Any validation will be made independently from the others:
 
 ```ruby
-class Transfer < Struct.new(:debet, :credit)
-  include Attestor::Validations
-
+class Transfer
+  # ...
   validate :consistent, only: :fair_trade
-end
+  validate :consistent, only: :legal
 
-fraud_transfer.validate             # => PASSES
-fraud_transfer.validate :fair_trade # => InvalidError
+  # This is the same as:
+  # validate :consistent, only: [:fair_trade, :legal]
+end
 ```
 
 Policy Objects
@@ -162,7 +159,7 @@ Extract a validator to the separate object (policy). Basically the policy includ
 
 ```ruby
 class ConsistencyPolicy < Struct.new(:debet, :credit)
-  include Attestor::Policy
+  include Attestor::Policy # includes Attestor::Validator as well
 
   validate :consistent
 
@@ -179,33 +176,40 @@ This looks mainly the same as before. But the policy's debet and credit are numb
 
 This is the core part of the [Policy Object design pattern] - it isolates the rule from unsignificant details of the target.
 
-From the other hand, the target needs to know nothing about how the policy works with data:
+When you have a policy to follow, use the `follow_policy` method:
 
 ```ruby
 class Transfer < Struct.new(:debet, :credit)
   include Attestor::Validations
 
-  validate :constistent
+  follow_policy :consistency, only: :fair_trade
 
   private
 
-  def consistent
-    policy = ConsistencyPolicy.new(debet.sum, credit.sum)
-    invalid :inconsistent if policy.invalid?
+  def consistency # should respond to #valid? and #invalid?
+    ConsistencyPolicy.new(debet.sum, credit.sum)
   end
 end
 ```
 
-The "new" method `valid?` just returns true or false, trowing error messages out as unsignificant details.
+In case the policy object is invalid, validation raises an exception.
 
-If you need messages from policy, you can use `validate` method and capture its exception. But should you?! Instead you'd better to provie the message, that makes sense in the Transfer context.
+The name of the method (`consistency`) will be used for the error message:
 
-[Policy Object design pattern]: http://blog.codeclimate.com/blog/2012/10/17/7-ways-to-decompose-fat-activerecord-models/
+```yaml
+# config/locales/en.yml
+---
+en:
+  attestor:
+    errors:
+      transfer:
+        consistency: "The transfer is inconsistent"
+```
 
 Complex Policies
 ----------------
 
-Now that we isolated policies, we can provide complex policies from simpler ones.
+Now that policies are isolated from their targets, we can provide complex policies from simpler ones.
 
 Suppose we have two policy objects:
 
@@ -214,7 +218,7 @@ valid_policy.valid?   # => true
 invalid_policy.valid? # => false
 ```
 
-Use `Policy` factory methods to provide compositions:
+Use factory methods to provide compositions:
 
 ```ruby
 complex_policy = valid_policy.not
@@ -233,7 +237,7 @@ complex_policy = valid_policy.xor(valid_poicy, invalid_policy)
 complex_policy.validate # => passes
 ```
 
-The `or`, `and` and `xor` methods, called without argument(s), don't provide a policy object. They return lazy composer, expecting `#not` method.
+The `or`, `and` and `xor` methods called without argument(s) don't provide a policy object. They return lazy composer, expecting `#not` method.
 
 ```ruby
 complex_policy = valid_policy.and.not(invalid_policy, invalid_policy)
@@ -245,13 +249,13 @@ If you prefer wrapping to chaining, use the `Policy` factory methods instead:
 
 ```ruby
 Policy.and(valid_policy, invalid_policy)
-# this is the same as: valid_policy.and invalid_policy
+# this is the same as: valid_policy.and(invalid_policy)
 
 Policy.or(valid_policy, invalid_policy)
-# this is the same as: valid_policy.or invalid_policy
+# this is the same as: valid_policy.or(invalid_policy)
 
 Policy.xor(valid_policy, invalid_policy)
-# this is the same as: valid_policy.xor invalid_policy
+# this is the same as: valid_policy.xor(invalid_policy)
 
 Policy.not(valid_policy)
 # this is the same as: valid_policy.not
@@ -259,25 +263,6 @@ Policy.not(valid_policy)
 
 As before, you can use any number of policies (except for negation of a single policy) at any number of nesting.
 
-This can be used either in targets or in complex policies. In the later case do it like this:
-
-```ruby
-class ComplexPolicy < Struct.new(:a, :b, :c)
-  include Attestor::Policy
-
-  validate :complex_rule
-
-  private
-
-  def complex_rule
-    first_policy  = FirstPolicy.new(a, b)
-    second_policy = SecondPolicy.new(b, c)
-
-    invalid :base unless first_policy.xor(second_policy).valid?
-  end
-end
-```
-
 Compatibility
 -------------
 
@@ -289,6 +274,9 @@ Tested under rubies compatible to rubies with API 2.0+:
 
 Uses [RSpec] 3.0+ for testing and [hexx-suit] for dev/test tools collection.
 
+[RSpec]: http://rspec.info
+[hexx-suit]: https://github.com/nepalez/hexx-suit
+
 Contributing
 ------------
 

data/lib/attestor.rb

@@ -7,8 +7,8 @@ require_relative "attestor/version"
 require_relative "attestor/invalid_error"
 
 require_relative "attestor/validations"
-require_relative "attestor/validations/item"
-require_relative "attestor/validations/collection"
+require_relative "attestor/validations/validator"
+require_relative "attestor/validations/validators"
 require_relative "attestor/validations/message"
 
 require_relative "attestor/policy/factory"

data/lib/attestor/validations.rb

@@ -5,14 +5,14 @@ module Attestor
   # API for objects to be validated
   module Validations
 
-    # Calls all validations used in the selected context
+    # Calls all validators for given context
     #
-    # @raise [Attestor::Validations::InvalidError] if validations fail
-    # @raise [NoMethodError] if some of validations are not implemented
+    # @raise [Attestor::Validations::InvalidError] if validators fail
+    # @raise [NoMethodError] if some of validators are not implemented
     #
     # @return [undefined]
     def validate(context = :all)
-      self.class.validations.set(context).each(&method(:__send__))
+      self.class.validators.set(context).each { |item| item.validate(self) }
     end
 
     # Raises InvalidError with a corresponding message
@@ -42,18 +42,18 @@ module Attestor
     # @private
     module ClassMethods
 
-      # Returns a collection of items describing applied validations
+      # Returns a collection of applied validators
       #
-      # @return [Attestor::Collection]
+      # @return [Attestor::Validators]
       #
       # @api private
-      def validations
-        @validations ||= Collection.new
+      def validators
+        @validators ||= Validators.new
       end
 
-      # Adds an item to {#validations}
+      # Registers a validator
       #
-      # Mutates the class by changing its {#validations} attribute!
+      # Mutates the class by changing its {#validators} attribute!
       #
       # @param [#to_sym] name
       # @param [Hash] options
@@ -62,9 +62,25 @@ module Attestor
       # @option options [#to_sym, Array<#to_sym>] :only
       #   the white list of contexts for validation
       #
-      # @return [Attestor::Collection] the updated collection
+      # @return [Attestor::Validators] the updated collection
       def validate(name, options = {})
-        @validations = validations.add(name, options)
+        @validators = validators.add(name, options)
+      end
+
+      # Registers a followed policy
+      #
+      # Mutates the class by changing its {#validators} attribute!
+      #
+      # @param [#to_sym] name
+      # @param [Hash] options
+      # @option options [#to_sym, Array<#to_sym>] :except
+      #   the black list of contexts for validation
+      # @option options [#to_sym, Array<#to_sym>] :only
+      #   the white list of contexts for validation
+      #
+      # @return [Attestor::Collection] the updated collection
+      def follow_policy(name, options = {})
+        @validators = validators.add(name, options.merge(policy: true))
       end
 
     end # module ClassMethods

data/lib/attestor/validations/{item.rb → validator.rb}

@@ -4,10 +4,16 @@ module Attestor
 
   module Validations
 
-    # Describes an item of validations' collection
+    # Describe a validator for class instances
+    #
+    # @example
+    #   validator = Validator.new(:foo, policy: :bar, only: :baz)
+    #
+    #   validator.used_in_context? :baz # => true
+    #   validator.validate object
     #
     # @api private
-    class Item
+    class Validator
 
       # @!scope class
       # @!method new(name, except: [], only: [])
@@ -17,11 +23,12 @@ module Attestor
       # @option [#to_sym, Array<#to_sym>] :except
       # @option [#to_sym, Array<#to_sym>] :only
       #
-      # @return [Attestor::Collection::Item]
+      # @return [Attestor::Validations::Validator]
 
       # @private
-      def initialize(name, except: nil, only: nil)
+      def initialize(name, except: nil, only: nil, policy: nil)
         @name      = name.to_sym
+        @policy    = policy
         @whitelist = normalize(only)
         @blacklist = normalize(except)
         generate_id
@@ -30,9 +37,18 @@ module Attestor
 
       # @!attribute [r] name
       # The name of the item
+      #
       # @return [Symbol]
       attr_reader :name
 
+      # @!method policy?
+      # Whether the validator uses a policy
+      #
+      # @return [Boolean]
+      def policy?
+        @policy ? true : false
+      end
+
       # Compares an item to another one
       #
       # @param [Object] other
@@ -52,6 +68,19 @@ module Attestor
         whitelisted?(symbol) && !blacklisted?(symbol)
       end
 
+      # Validates given object
+      #
+      # @param [Object] object
+      #
+      # @raise [Attestor::InvalidError]
+      #   if object doesn't match validation rule
+      #
+      # @return [undefined]
+      def validate(object)
+        result = object.__send__(name)
+        object.__send__(:invalid, name) if policy? && result.invalid?
+      end
+
       protected
 
       # @!attribute [r] id
@@ -80,7 +109,7 @@ module Attestor
         Array(list).map(&:to_sym).uniq
       end
 
-    end # class Item
+    end # class Validator
 
   end # module Validations
 

data/lib/attestor/validations/{collection.rb → validators.rb}

@@ -7,16 +7,16 @@ module Attestor
     # The collection of validations used by class instances
     #
     # @api private
-    class Collection
+    class Validators
       include Enumerable
 
       # @!scope class
       # @!method new(items = [])
       # Creates an immutable collection with optional list of items
       #
-      # @param [Array<Attestor::Collection::Item>] items
+      # @param [Array<Attestor::Validators::Validator>] items
       #
-      # @return [Attestor::Collection]
+      # @return [Attestor::Validators]
 
       # @private
       def initialize(items = [])
@@ -27,46 +27,46 @@ module Attestor
       # Iterates through the collection
       #
       # @yield the block
-      # @yieldparam [Attestor::Collection::Item] item
+      # @yieldparam [Attestor::Validators::Validator] item
       #   items from the collection
       #
       # @return [Enumerator]
       def each
-        return to_enum unless block_given?
-        items.map(&:name).uniq.each { |item| yield(item) }
+        block_given? ? @items.each { |item| yield(item) } : to_enum
       end
 
-      # Returns the collection, updated with new item
+      # Returns validators updated by new item
       #
       # @param  [#to_sym] name
       # @param  [Hash] options
       # @option options [Array<#to_sym>] :except
       # @option options [Array<#to_sym>] :only
+      # @option options [Symbol, nil] :policy
       #
-      # @return [Attestor::Collection]
+      # @return [Attestor::Validators]
       def add(name, options = {})
-        item = Item.new(name, options)
-        return self if items.include? item
+        item = Validator.new(name, options)
+        return self if include? item
 
-        self.class.new(items + [item])
+        self.class.new(@items + [item])
       end
 
-      # Returns the collection of items used in given context
+      # Returns validators used in given context
       #
       # @param  [#to_sym] context
       #
-      # @return [Attestor::Collection]
+      # @return [Attestor::Validators]
       def set(context)
-        collection = items.select { |item| item.used_in_context? context }
+        validators = select { |item| item.used_in_context? context }
 
-        self.class.new(collection)
+        self.class.new(validators)
       end
 
       private
 
       attr_reader :items
 
-    end # class Collection
+    end # class Validators
 
   end # module Validations
 

data/lib/attestor/version.rb

@@ -4,6 +4,6 @@ module Attestor
 
   # The semantic version of the module.
   # @see http://semver.org/ Semantic versioning 2.0
-  VERSION = "0.0.1".freeze
+  VERSION = "0.1.0".freeze
 
 end # module Attestor

data/spec/features/example_spec.rb

@@ -0,0 +1,109 @@
+# encoding: utf-8
+
+describe "Base example" do
+
+  before do
+    Account     = Struct.new(:client, :limit)
+    Transaction = Struct.new(:account, :sum)
+    Transfer    = Struct.new(:debet, :credit)
+
+    ConsistencyPolicy = Struct.new(:debet, :credit)
+    LimitPolicy       = Struct.new(:transaction)
+    InternalTransfer  = Struct.new(:debet, :credit)
+
+    class ConsistencyPolicy
+      include Attestor::Policy
+
+      validate :consistent
+
+      private
+
+      def consistent
+        return if debet.sum + credit.sum == 0
+        invalid :inconsistent
+      end
+    end
+
+    class LimitPolicy
+      include Attestor::Policy
+
+      validate :limited
+
+      private
+
+      def limited
+        return unless (transaction.account.limit + transaction.sum) < 0
+        invalid :over_the_limit
+      end
+    end
+
+    class InternalTransfer
+      include Attestor::Policy
+
+      validate :internal
+
+      private
+
+      def internal
+        return if debet.account.client == credit.account.client
+        invalid :external
+      end
+    end
+
+    class Transfer
+      include Attestor::Validations
+
+      follow_policy :consistent
+      follow_policy :limited, except: :blocked
+      follow_policy :internal,  only: :blocked
+
+      private
+
+      def consistent
+        ConsistencyPolicy.new(debet, credit)
+      end
+
+      def limited
+        LimitPolicy.new(debet).or internal
+      end
+
+      def internal
+        InternalTransfer.new(debet, credit)
+      end
+    end
+  end
+
+  let(:alice) { Account.new("Alice", 100) }
+  let(:bob)   { Account.new("Bob", 100) }
+
+  let(:a_to_a) do
+    Transfer.new Transaction.new(alice, -150), Transaction.new(alice, 150)
+  end
+
+  let(:a_to_b) do
+    Transfer.new Transaction.new(alice, -150), Transaction.new(bob, 150)
+  end
+
+  let(:b_to_a) do
+    Transfer.new Transaction.new(bob, -50), Transaction.new(alice, 50)
+  end
+
+  it "works fine" do
+    expect { a_to_a.validate }.not_to raise_error
+    expect { b_to_a.validate }.not_to raise_error
+
+    expect { a_to_b.validate }.to raise_error Attestor::InvalidError
+    expect { b_to_a.validate :blocked }.to raise_error Attestor::InvalidError
+  end
+
+  after do
+    %w(
+      Transfer
+      InternalTransfer
+      LimitPolicy
+      ConsistencyPolicy
+      Transaction
+      Account
+    ).each { |klass| Object.send :remove_const, klass }
+  end
+end

data/spec/tests/validations/{item_spec.rb → validator_spec.rb}

@@ -1,6 +1,8 @@
 # encoding: utf-8
 
-describe Attestor::Validations::Item do
+require "support/policies"
+
+describe Attestor::Validations::Validator do
 
   subject { described_class.new "foo" }
 
@@ -36,9 +38,13 @@ describe Attestor::Validations::Item do
         .to eq(described_class.new "foo", only: %i(bar))
     end
 
+    it "accepts array option :policy" do
+      expect { described_class.new "foo", policy: :bar }.not_to raise_error
+    end
+
   end # describe .new
 
-  describe ".name" do
+  describe "#name" do
 
     it "is initialized as a symbol" do
       expect(subject.name).to eq :foo
@@ -46,11 +52,24 @@ describe Attestor::Validations::Item do
 
   end # describe .name
 
+  describe "#policy?" do
+
+    it "is set to false by default" do
+      expect(subject.policy?).to eq false
+    end
+
+    it "can be initialized" do
+      subject = described_class.new "foo", policy: 1
+      expect(subject.policy?).to eq true
+    end
+
+  end # describe #policy?
+
   describe "#==" do
 
     subject { described_class.new :foo, except: [:foo], only: %i(bar) }
 
-    context "item with the same name and options" do
+    context "item with the same arguments" do
 
       let(:other) { described_class.new :foo, except: %i(foo), only: %i(bar) }
 
@@ -150,4 +169,51 @@ describe Attestor::Validations::Item do
 
   end # describe #name
 
+  describe "#validate" do
+
+    after { subject.validate object }
+
+    context "when a #policy isn't set" do
+
+      let(:object) { double foo: nil }
+      subject { described_class.new :foo }
+
+      it "calls validation method" do
+        expect(object).to receive :foo
+      end
+
+    end # context
+
+    context "when a #policy is set to valid policy" do
+
+      let(:object) { double foo: valid_policy }
+      subject { described_class.new :foo, policy: true }
+
+      it "calls policy method" do
+        expect(object).to receive(:foo)
+      end
+
+      it "doesn't call #invalid" do
+        expect(object).not_to receive(:invalid)
+      end
+
+    end # context
+
+    context "when a #policy is set to valid policy" do
+
+      let(:object) { double foo: invalid_policy, invalid: nil }
+      subject { described_class.new :foo, policy: true }
+
+      it "calls policy method" do
+        expect(object).to receive(:foo)
+      end
+
+      it "calls #invalid with name" do
+        expect(object).to receive(:invalid).with(:foo)
+      end
+
+    end # context
+
+  end # describe #validate
+
 end # describe Attestor::Validation

data/spec/tests/validations/{collection_spec.rb → validators_spec.rb}

@@ -1,8 +1,8 @@
 # encoding: utf-8
 
-describe Attestor::Validations::Collection do
+describe Attestor::Validations::Validators do
 
-  let(:item_class) { Attestor::Validations::Item }
+  let(:validator_class) { Attestor::Validations::Validator }
 
   describe ".new" do
 
@@ -22,11 +22,11 @@ describe Attestor::Validations::Collection do
       expect(subject.each).to be_kind_of Enumerator
     end
 
-    it "iterates trough the unique item names" do
-      items   = %w(foo bar foo).map(&item_class.method(:new))
-      subject = described_class.new items
+    it "iterates trough validators" do
+      validators = %w(foo bar foo).map(&validator_class.method(:new))
+      subject = described_class.new validators
 
-      expect(subject.to_a).to match_array %i(foo bar)
+      expect(subject.to_a).to match_array validators
     end
 
   end # describe #each
@@ -37,17 +37,17 @@ describe Attestor::Validations::Collection do
 
       let(:result) { subject.add("foo") }
 
-      it "returns the collection" do
+      it "returns validators" do
         expect(result).to be_kind_of described_class
       end
 
-      it "adds item to the collection" do
+      it "adds item to validators" do
         item = result.first
-        expect(item).to eq :foo
+        expect(item.name).to eq :foo
       end
 
       it "preserves existing items" do
-        expect(result.add(:bar).to_a).to contain_exactly :foo, :bar
+        expect(result.add(:bar).map(&:name)).to contain_exactly :foo, :bar
       end
 
     end # context
@@ -56,15 +56,15 @@ describe Attestor::Validations::Collection do
 
       let(:result) { subject.add "foo", only: [:foo] }
 
-      it "adds item to the collection" do
-        expect(result.to_a).to eq [:foo]
-        expect(result.set(:foo).to_a).to eq [:foo]
-        expect(result.set(:all).to_a).to eq []
+      it "adds item to validators" do
+        expect(result.map(&:name)).to eq [:foo]
+        expect(result.set(:foo).map(&:name)).to eq [:foo]
+        expect(result.set(:all).map(&:name)).to eq []
       end
 
     end # context
 
-    context "existing item" do
+    context "existing validator" do
 
       subject { described_class.new.add "foo" }
 
@@ -90,11 +90,11 @@ describe Attestor::Validations::Collection do
     end
 
     it "returns a set of items used in given context" do
-      expect(subject.set("cad").to_a).to contain_exactly :foo, :baz
-      expect(subject.set("cam").to_a).to contain_exactly :foo, :bar
-      expect(subject.set("all").to_a).to contain_exactly :bar, :baz
+      expect(subject.set("cad").map(&:name)).to contain_exactly :foo, :baz
+      expect(subject.set("cam").map(&:name)).to contain_exactly :foo, :bar
+      expect(subject.set("all").map(&:name)).to contain_exactly :bar, :baz
     end
 
   end # describe #context
 
-end # describe Attestor::Collection
+end # describe Attestor::Validators

data/spec/tests/validations_spec.rb

@@ -1,8 +1,12 @@
 # encoding: utf-8
 
+require "support/policies" # for #valid_policy and #invalid_policy definitions
+
 describe Attestor::Validations do
 
-  let(:collection_class) { Attestor::Validations::Collection }
+  let(:validators_class) { Attestor::Validations::Validators }
+  let(:validator_class)  { Attestor::Validations::Validator }
+  let(:collection_class) { Attestor::Validations::Validators }
   let(:item_class)       { Attestor::Validations::Item }
   let(:message_class)    { Attestor::Validations::Message }
   let(:invalid_error)    { Attestor::InvalidError }
@@ -13,17 +17,17 @@ describe Attestor::Validations do
 
   subject { test_class.new }
 
-  describe ".validations" do
+  describe ".validators" do
 
-    it "returns a Collection" do
-      expect(test_class.validations).to be_kind_of collection_class
+    it "returns Validators" do
+      expect(test_class.validators).to be_kind_of validators_class
     end
 
     it "is empty by default" do
-      expect(test_class.validations.to_a).to be_empty
+      expect(test_class.validators.to_a).to be_empty
     end
 
-  end # describe .validations
+  end # describe .validators
 
   describe ".validate" do
 
@@ -31,58 +35,59 @@ describe Attestor::Validations do
 
       before { test_class.validate :foo }
 
-      it "adds the item to the collection" do
-        expect(test_class.validations.to_a).to eq [:foo]
+      it "registers a validator" do
+        expect(test_class.validators.map(&:name)).to eq [:foo]
+      end
+
+      it "sets a validator's policy to false" do
+        expect(test_class.validators.first).not_to be_policy
       end
 
     end # context
 
-    context "with options" do
+    context "with restrictions" do
 
       before { test_class.validate :foo, only: %w(bar baz), except: "bar" }
 
       it "uses options" do
-        expect(test_class.validations.to_a).to eq [:foo]
-        expect(test_class.validations.set(:baz).to_a).to eq [:foo]
-        expect(test_class.validations.set(:bar).to_a).to eq []
+        expect(test_class.validators.map(&:name)).to eq [:foo]
+        expect(test_class.validators.set(:baz).map(&:name)).to eq [:foo]
+        expect(test_class.validators.set(:bar).map(&:name)).to eq []
       end
 
     end # context
 
   end # describe .validate
 
-  describe "#validate" do
+  describe ".follow_policy" do
 
-    before do
-      test_class.validate :foo
-      test_class.validate :bar, only: :all
-      test_class.validate :baz, only: :foo
-      %i(foo bar baz).each { |method| allow(subject).to receive(method) }
-    end
+    context "without options" do
 
-    context "without an argument" do
+      before { test_class.follow_policy :foo }
 
-      it "calls validations for :all context" do
-        expect(subject).to receive(:foo)
-        expect(subject).to receive(:bar)
-        expect(subject).not_to receive(:baz)
-        subject.validate
+      it "registers a validator" do
+        expect(test_class.validators.map(&:name)).to eq [:foo]
+      end
+
+      it "sets a validator's policy to true" do
+        expect(test_class.validators.first).to be_policy
       end
 
     end # context
 
-    context ":foo" do
+    context "with restrictions" do
 
-      it "calls validations for :foo context" do
-        expect(subject).to receive(:foo)
-        expect(subject).to receive(:baz)
-        expect(subject).not_to receive(:bar)
-        subject.validate :foo
+      before { test_class.follow_policy :foo, only: %w(bar baz), except: "bar" }
+
+      it "uses options" do
+        expect(test_class.validators.map(&:name)).to eq [:foo]
+        expect(test_class.validators.set(:baz).map(&:name)).to eq [:foo]
+        expect(test_class.validators.set(:bar).map(&:name)).to eq []
       end
 
     end # context
 
-  end # describe #validate
+  end # describe .follow_policy
 
   describe "#invalid" do
 
@@ -123,4 +128,40 @@ describe Attestor::Validations do
 
   end # invalid
 
+  describe "#validate" do
+
+    before do
+      test_class.validate :foo
+      test_class.validate :bar, only: :all
+      test_class.follow_policy :baz, only: :foo
+
+      allow(subject).to receive(:foo)
+      allow(subject).to receive(:bar)
+      allow(subject).to receive(:baz) { valid_policy }
+    end
+
+    context "without an argument" do
+
+      it "calls validators for :all context" do
+        expect(subject).to receive(:foo)
+        expect(subject).to receive(:bar)
+        expect(subject).not_to receive(:baz)
+        subject.validate
+      end
+
+    end # context
+
+    context ":foo" do
+
+      it "calls validators for :foo context" do
+        expect(subject).to receive(:foo)
+        expect(subject).to receive(:baz)
+        expect(subject).not_to receive(:bar)
+        subject.validate :foo
+      end
+
+    end # context
+
+  end # describe #validate
+
 end # describe Attestor::Validations

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: attestor
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Andrew Kozin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-25 00:00:00.000000000 Z
+date: 2015-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: extlib
@@ -81,10 +81,11 @@ files:
 - lib/attestor/policy/or.rb
 - lib/attestor/policy/xor.rb
 - lib/attestor/validations.rb
-- lib/attestor/validations/collection.rb
-- lib/attestor/validations/item.rb
 - lib/attestor/validations/message.rb
+- lib/attestor/validations/validator.rb
+- lib/attestor/validations/validators.rb
 - lib/attestor/version.rb
+- spec/features/example_spec.rb
 - spec/spec_helper.rb
 - spec/support/policies.rb
 - spec/tests/invalid_error_spec.rb
@@ -96,9 +97,9 @@ files:
 - spec/tests/policy/or_spec.rb
 - spec/tests/policy/xor_spec.rb
 - spec/tests/policy_spec.rb
-- spec/tests/validations/collection_spec.rb
-- spec/tests/validations/item_spec.rb
 - spec/tests/validations/message_spec.rb
+- spec/tests/validations/validator_spec.rb
+- spec/tests/validations/validators_spec.rb
 - spec/tests/validations_spec.rb
 homepage: https://github.com/nepalez/attestor
 licenses:
@@ -130,8 +131,8 @@ test_files:
 - spec/tests/invalid_error_spec.rb
 - spec/tests/validations_spec.rb
 - spec/tests/validations/message_spec.rb
-- spec/tests/validations/collection_spec.rb
-- spec/tests/validations/item_spec.rb
+- spec/tests/validations/validator_spec.rb
+- spec/tests/validations/validators_spec.rb
 - spec/tests/policy/or_spec.rb
 - spec/tests/policy/factory_spec.rb
 - spec/tests/policy/and_spec.rb
@@ -139,5 +140,6 @@ test_files:
 - spec/tests/policy/negator_spec.rb
 - spec/tests/policy/not_spec.rb
 - spec/tests/policy/node_spec.rb
+- spec/features/example_spec.rb
 - spec/support/policies.rb
 has_rdoc: