attestor 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b4755994f9e2305a2cd5ee6e243fc47fe5f5b404
-  data.tar.gz: 149e89d4ed18c39bf51df1d75933b5e06fe4c5f0
+  metadata.gz: 7889c90de0f2f5e7a65ac09a622200903219fecf
+  data.tar.gz: da24f1d17b8705a96f505e28063b44d38051c222
 SHA512:
-  metadata.gz: 0daa45d47fef84269ac1f27a62f985ab6c585cef0c73d2be5de736a3ecfb9357f2632b1557f28dfdfd93caf75b222bc9a032e2370154d2c20ae1026a941d853f
-  data.tar.gz: 0107fd28176f7b61ff7c6240eac3ab2c6b781c1ccbda0091507f0d6b8190ebc04fe0fee7bf8e63aadfed30f17c2f454b4865b05dbede51fac771387791d9023c
+  metadata.gz: dd38ec23f72df933af48dfbdc3cbf26ec10845f4c6b6ec56796537c20c42b09d93113929efe89292835adcc1cf378894209dc87773b8f1870247e1a79ceda67c
+  data.tar.gz: ef469dd31b6df6f9f3176e5ebc74bff358e271b3c42974e6a70a07595369d66818585aea3aa660a3e54c2c646a959f6c26df8b18fff8c05502bdd2e3b08d260a

data/README.md

@@ -106,7 +106,7 @@ Alternatively, you can describe validation in the block (called in the scope of
 ```ruby
 class Transfer
   # ...
-  validate(:consistent) { invalid :inconsistent if credit.sum != debet.sum }
+  validate { invalid :inconsistent if credit.sum != debet.sum }
 end
 ```
 
@@ -161,71 +161,86 @@ class Transfer
 end
 ```
 
-Policy Objects
---------------
-
-Extract a validator to the separate object (policy). Basically the policy includes `Attestor::Validations` with additional methods.
+Delegation
+----------
 
-To create a policy as a `Struct` use the builder method:
+Extract validator to the external object (policy), that responds to `validate`.
 
 ```ruby
-ConsistencyPolicy = Attestor::Policy.new(:debet, :credit) do
+class ConsistentTransfer.new(:debet, :credit)
+  include Attestor::Validations
+
   def validate
-    fraud = credit - debet
-    invalid :inconsistent, fraud: fraud if fraud != 0
+    invalid :inconsistent unless debet.sum == credit.sum
   end
 end
 ```
 
-This looks mainly the same as before. But the policy's debet and credit are numbers, not the transactions. **The policy knows nothing about the nature of its attributes** - whether they are sums of transactions, or anything else.
+Then use `validates` helper:
 
-This is the core part of the [Policy Object design pattern] - it isolates the rule from unsignificant details of the target.
+```ruby
+class Transfer 
+  # ...
+  validates { ConsistentTransfer.new(:debet, :credit) }
+end
+```
 
-When you have a policy to follow, use the `follow_policy` method:
+or by method name:
 
 ```ruby
-class Transfer < Struct.new(:debet, :credit)
-  include Attestor::Validations
+class Transfer
+  # ...
+  validates :consistent_transfer
 
-  follow_policy :consistency, only: :fair_trade
+  def consistent_transfer
+    ConsistentTransfer.new(:debet, :credit)
+  end
+```
 
-  private
+The change between `validate :something` and `validates :something` is that:
+* `validate` expects `#something` to make checks and raise error by itself
+* `validates` expects `#something` to respond to `#validate`
 
-  def consistency # should respond to #valid? and #invalid?
-    ConsistencyPolicy.new(debet.sum, credit.sum)
+Policy Objects
+--------------
+
+Basically the policy includes `Attestor::Validations` with additional methods to allow chaining policies by logical methods.
+
+To create a policy as a `Struct` use the builder method:
+
+```ruby
+ConsistencyPolicy = Attestor::Policy.new(:debet, :credit) do
+  def validate
+    fraud = credit - debet
+    invalid :inconsistent, fraud: fraud if fraud != 0
   end
 end
 ```
 
-In case the policy object is invalid, validation raises an exception.
+If you doesn't need Struct, include `Attestor::Policy` to the class and initialize its arguments somehow else:
 
-The name of the method (`consistency`) will be used for the error message:
-
-```yaml
-# config/locales/en.yml
----
-en:
-  attestor:
-    errors:
-      transfer:
-        consistency: "The transfer is inconsistent"
+```ruby
+class ConsistencyPolicy < OpenStruct
+  include Attestor::Policy
+  # ...
+end
 ```
 
-Alternatively, you can describe a policy in the block (called in the scope of instance):
+Policy objects can be used by `validates` method like other validatable objects:
 
 ```ruby
 class Transfer
   # ...
-  follow_policy :consistency, only: :fair_trade do
-    ConsistencyPolicy.new(debet.sum, credit.sum)
-  end
+  validates { ConsistencyPolicy.new(debet, credit) }
 end
 ```
 
+They also respond to `valid?` and `invalid?` methods (that just rescues from `vaidate` missing any error messages).
+
 Complex Policies
 ----------------
 
-Now that policies are isolated from their targets, we can provide complex policies from simpler ones.
+Policies (assertions) can be combined by logical methods.
 
 Suppose we have two policy objects:
 

data/lib/attestor.rb

@@ -8,6 +8,7 @@ require_relative "attestor/invalid_error"
 
 require_relative "attestor/validations"
 require_relative "attestor/validations/validator"
+require_relative "attestor/validations/delegator"
 require_relative "attestor/validations/follower"
 require_relative "attestor/validations/validators"
 require_relative "attestor/validations/message"

data/lib/attestor/policy.rb

@@ -31,7 +31,7 @@ module Attestor
     # @return [Class] the policy class, based on Struct
     def self.new(*attributes, &block)
       Struct.new(*attributes) do
-        include Attestor::Policy
+        include Policy
         instance_eval(&block) if block_given?
       end
     end

data/lib/attestor/policy/and.rb

@@ -25,7 +25,7 @@ module Attestor
       #
       # @return [undefined]
       def validate
-        return unless any_invalid?
+        return unless detect(&:invalid?)
         super
       end
 

data/lib/attestor/policy/node.rb

@@ -9,6 +9,7 @@ module Attestor
     # @api private
     class Node
       include Attestor::Policy
+      include Enumerable
 
       # @!scope class
       # @!method new(*branches)
@@ -41,14 +42,11 @@ module Attestor
         invalid :base
       end
 
-      private
-
-      def any_valid?
-        branches.detect(&:valid?)
-      end
-
-      def any_invalid?
-        branches.detect(&:invalid?)
+      # Iterates throught branches
+      #
+      # @return [Enumerator]
+      def each
+        block_given? ? branches.each { |item| yield(item) } : to_enum
       end
 
     end # class Node

data/lib/attestor/policy/not.rb

@@ -37,7 +37,7 @@ module Attestor
       #
       # @return [undefined]
       def validate
-        return unless any_valid?
+        return unless detect(&:valid?)
         super
       end
 

data/lib/attestor/policy/or.rb

@@ -25,7 +25,7 @@ module Attestor
       #
       # @return [undefined]
       def validate
-        return if any_valid?
+        return if detect(&:valid?)
         super
       end
 

data/lib/attestor/policy/xor.rb

@@ -25,7 +25,7 @@ module Attestor
       #
       # @return [undefined]
       def validate
-        return if any_valid? && any_invalid?
+        return if detect(&:valid?) && detect(&:invalid?)
         super
       end
 

data/lib/attestor/validations.rb

@@ -51,21 +51,53 @@ module Attestor
         @validators ||= Validators.new
       end
 
-      # @!method follow_validator(name, except: nil, only: nil)
-      # Registers a validator
+      # @!method validate(name = nil, except: nil, only: nil, &block)
+      # Uses an instance method or block for validation
       #
       # 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::Validators] the updated collection
-      def validate(*args)
-        @validators = validators.add_validator(*args)
+      # @overload validate(name, except: nil, only: nil)
+      #   Uses the instance method for validation
+      #
+      #   @param [#to_sym] name The name of the instance method
+      #
+      # @overload validate(except: nil, only: nil, &block)
+      #   Uses the block (in the scope of the instance) for validation
+      #
+      #   @param [Proc] block
+      #
+      # @return [Attestor::Validators] the updated list of validators
+      def validate(*args, &block)
+        @validators = validators.add_validator(*args, &block)
+      end
+
+      # @!method validates(name = nil, except: nil, only: nil, &block)
+      # Delegates a validation to instance method or block
+      #
+      # Mutates the class by changing its {#validators} attribute!
+      #
+      # @option (see #validate)
+      #
+      # @overload validates(name, except: nil, only: nil)
+      #   Delegates a validation to instance method
+      #
+      #   @param [#to_sym] name
+      #     The name of the instance method that should respond to #validate
+      #
+      # @overload validates(except: nil, only: nil, &block)
+      #   Uses the block (in the scope of the instance) for validation
+      #
+      #   @param [Proc] block
+      #     The block that should respond to #validate
+      #
+      # @return (see #validate)
+      def validates(*args, &block)
+        @validators = validators.add_delegator(*args, &block)
       end
 
       # @!method follow_policy(name, except: nil, only: nil)

data/lib/attestor/validations/delegator.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+module Attestor
+
+  module Validations
+
+    # Describe a validator that delegates validation to instance method or block
+    #
+    # The follower not only calls an instance method (block) as validator does,
+    # but calls #validate method of the result.
+    #
+    # @example
+    #   follower = Validator.new(:foo, only: :baz) { FooPolicy.new(foo) }
+    #
+    # @api private
+    class Delegator < Validator
+
+      # Validates an object by delegation
+      #
+      # @param [Object] object
+      #
+      # @raise [Attestor::InvalidError] if a policy isn't valid
+      #
+      # @return [undefined]
+      def validate(_)
+        super.validate
+      end
+
+    end # class Follower
+
+  end # module Validations
+
+end # module Attestor

data/lib/attestor/validations/validator.rb

@@ -26,7 +26,7 @@ module Attestor
       # @return [Attestor::Validations::Validator]
 
       # @private
-      def initialize(name, except: nil, only: nil, &block)
+      def initialize(name = :invalid, except: nil, only: nil, &block)
         @name      = name.to_sym
         @whitelist = normalize(only)
         @blacklist = normalize(except)

data/lib/attestor/validations/validators.rb

@@ -42,7 +42,8 @@ module Attestor
       # @return [Attestor::Validators]
       def set(context)
         validators = select { |item| item.used_in_context? context }
-        (validators == items) ? self : self.class.new(validators)
+        
+        self.class.new(validators)
       end
 
       # Returns validators updated by a new validator with given args
@@ -50,16 +51,23 @@ module Attestor
       # @param  [Array] args
       #
       # @return [Attestor::Validators]
-      def add_validator(*args)
-        add_item Validator, *args
+      def add_validator(*args, &block)
+        add_item Validator, *args, &block
       end
 
-      # Returns validators updated by a new follower with given args
+      # Returns validators updated by a new validator with given args
       #
       # @param  [Array] args
       #
       # @return [Attestor::Validators]
+      def add_delegator(*args, &block)
+        add_item Delegator, *args, &block
+      end
+
+      # @deprecated
       def add_follower(*args)
+        warn "[DEPRECATED] .add_follower is deprecated since v1.0.0" \
+             " Use .validates method instead."
         add_item Follower, *args
       end
 
@@ -67,8 +75,8 @@ module Attestor
 
       attr_reader :items
 
-      def add_item(type, *args)
-        item = type.new(*args)
+      def add_item(type, *args, &block)
+        item = type.new(*args, &block)
         include?(item) ? self : self.class.new(items, item)
       end
 

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.3.0".freeze
+  VERSION = "0.4.0".freeze
 
 end # module Attestor

data/spec/features/example_spec.rb

@@ -53,16 +53,14 @@ describe "Base example" do
     class Transfer
       include Attestor::Validations
 
-      follow_policy :consistent
-      follow_policy :limited, except: :blocked
-      follow_policy :internal,  only: :blocked
+      validates { ConsistencyPolicy.new(debet, credit) }
+      validates :limited, except: :blocked
+      validate  only: :blocked do
+        internal.validate
+      end
 
       private
 
-      def consistent
-        ConsistencyPolicy.new(debet, credit)
-      end
-
       def limited
         LimitPolicy.new(debet).or internal
       end

data/spec/support/policies.rb

@@ -3,11 +3,11 @@
 # Definitions for testing compound policies
 
 def valid_policy
-  double valid?: true, invalid?: false
+  double valid?: true, invalid?: false, validate: nil
 end
 
 def invalid_policy
-  double valid?: false, invalid?: true
+  double valid?: false, invalid?: true, validate: nil
 end
 
 shared_examples "creating a node" do

data/spec/tests/policy/node_spec.rb

@@ -11,6 +11,10 @@ describe Attestor::Policy::Node do
       expect(subject).to be_kind_of policy_class
     end
 
+    it "creates a collection" do
+      expect(subject).to be_kind_of Enumerable
+    end
+
     it "creates immutable object" do
       expect(subject).to be_frozen
     end
@@ -33,12 +37,37 @@ describe Attestor::Policy::Node do
 
   end # describe #branches
 
+  describe "#each" do
+
+    let(:branches) { 3.times.map { double } }
+
+    it "returns an enumerator" do
+      expect(subject.each).to be_kind_of Enumerator
+    end
+
+    it "iterates through brances" do
+      subject = described_class.new(branches)
+      expect(subject.to_a).to eq branches
+    end
+
+  end # each
+
   describe "#validate" do
 
+    let(:message) { Attestor::Validations::Message.new :base, subject }
+
     it "raises InvalidError" do
       expect { subject.validate }.to raise_error invalid_error
     end
 
+    it "adds the :invalid message" do
+      begin
+        subject.validate
+      rescue => error
+        expect(error.messages).to contain_exactly message
+      end
+    end
+
   end # describe #validate
 
 end # describe Attestor::Policy::Node

data/spec/tests/policy_spec.rb

@@ -12,32 +12,36 @@ describe Attestor::Policy do
   after   { Object.send :remove_const, :Test }
   subject { test_class.new }
 
-  it "is a factory" do
-    expect(test_class).to be_kind_of factory
-  end
+  describe ".included" do
+
+    it "is a factory" do
+      expect(test_class).to be_kind_of factory
+    end
+
+  end # describe .included
 
   describe ".new" do
 
-    let(:build) { described_class.new(:foo) { attr_reader :bar } }
-    subject     { build.new(:baz) }
+    subject { described_class.new(:foo) }
 
     it "builds the struct" do
-      expect(subject).to be_kind_of Struct
+      expect(subject.new(:baz)).to be_kind_of Struct
     end
 
     it "adds given attributes" do
-      expect(subject.foo).to eq :baz
+      expect(subject.new(:baz).foo).to eq :baz
     end
 
     it "builds the policy" do
-      expect(subject).to be_kind_of described_class
+      expect(subject.new(:baz)).to be_kind_of described_class
     end
 
     it "yields the block in class scope" do
-      expect(subject).to respond_to :bar
+      subject = described_class.new(:foo) { attr_reader :bar }
+      expect(subject.new(:baz)).to respond_to :bar
     end
 
-  end
+  end # describe .new
 
   describe ".included" do
 

data/spec/tests/validations/delegator_spec.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+require "support/policies"
+
+describe Attestor::Validations::Delegator do
+
+  let(:validator) { Attestor::Validations::Validator }
+
+  describe ".new" do
+
+    subject { described_class.new "foo" }
+    it { is_expected.to be_kind_of validator }
+
+  end # describe .new
+
+  describe "#validate" do
+
+    let(:object) { double foo: valid_policy }
+
+    context "when initialized without a block" do
+
+      subject { described_class.new "foo" }
+      after   { subject.validate object   }
+
+      it "delegates validation to named method" do
+        expect(object).to receive_message_chain(:foo, :validate)
+      end
+
+    end # context
+
+    context "when initialized with a block" do
+
+      subject { described_class.new { foo } }
+      after   { subject.validate object }
+
+      it "delegates validation to block" do
+        expect(object).to receive_message_chain(:foo, :validate)
+      end
+
+    end # context
+
+  end # describe #validate
+
+end # describe Attestor::Validations::Delegator

data/spec/tests/validations/validator_spec.rb

@@ -46,6 +46,10 @@ describe Attestor::Validations::Validator do
       expect(subject.name).to eq :foo
     end
 
+    it "is initialized by default as :invalid" do
+      expect(described_class.new.name).to eq :invalid
+    end
+
   end # describe .name
 
   describe "#==" do
@@ -154,8 +158,8 @@ describe Attestor::Validations::Validator do
 
   describe "#validate" do
 
-    let(:object) { double foo: nil }
-    after { subject.validate object }
+    let(:object) { Class.new { private def foo; end }.new }
+    after        { subject.validate object }
 
     context "when no block initialized" do
 

data/spec/tests/validations/validators_spec.rb

@@ -3,7 +3,7 @@
 describe Attestor::Validations::Validators do
 
   let(:validator_class) { Attestor::Validations::Validator }
-  let(:follower_class)  { Attestor::Validations::Follower  }
+  let(:delegator_class) { Attestor::Validations::Delegator  }
 
   describe ".new" do
 
@@ -34,7 +34,7 @@ describe Attestor::Validations::Validators do
 
   describe "#add_validator" do
 
-    context "without contexts" do
+    context "with a name" do
 
       let(:result) { subject.add_validator "foo" }
 
@@ -42,10 +42,10 @@ describe Attestor::Validations::Validators do
         expect(result).to be_kind_of described_class
       end
 
-      it "adds validator (not a follower)" do
+      it "adds validator (not a delegator)" do
         item = result.first
         expect(item).to be_kind_of validator_class
-        expect(item).not_to be_kind_of follower_class
+        expect(item).not_to be_kind_of delegator_class
       end
 
       it "assigns a name" do
@@ -54,49 +54,54 @@ describe Attestor::Validations::Validators do
       end
 
       it "preserves existing items" do
-        expect(result.add_validator(:bar).map(&:name))
-          .to contain_exactly :foo, :bar
+        expect(result.add_validator(:bar).count).to be 2
       end
 
     end # context
 
-    context "with contexts" do
+    context "with a block" do
 
-      let(:result) { subject.add_validator "foo", only: [:foo] }
+      let(:result) { subject.add_validator { foo } }
 
-      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 []
+      it "returns validators" do
+        expect(result).to be_kind_of described_class
+      end
+
+      it "adds validator (not a delegator)" do
+        item = result.first
+        expect(item).to be_kind_of validator_class
+        expect(item).not_to be_kind_of delegator_class
       end
 
     end # context
 
-    context "existing validator" do
+    context "with contexts" do
 
-      subject { described_class.new.add_validator "foo" }
+      let(:result) { subject.add_validator "foo", only: [:foo] }
 
-      it "returns itself" do
-        expect(subject.add_validator "foo").to eq subject
+      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
 
   end # describe #add_validator
 
-  describe "#add_follower" do
+  describe "#add_delegator" do
 
-    context "without contexts" do
+    context "with a name" do
 
-      let(:result) { subject.add_follower "foo" }
+      let(:result) { subject.add_delegator "foo" }
 
       it "returns validators" do
         expect(result).to be_kind_of described_class
       end
 
-      it "adds a follower" do
+      it "adds a delegator" do
         item = result.first
-        expect(item).to be_kind_of follower_class
+        expect(item).to be_kind_of delegator_class
       end
 
       it "assigns a name" do
@@ -105,41 +110,45 @@ describe Attestor::Validations::Validators do
       end
 
       it "preserves existing items" do
-        expect(result.add_follower(:bar).map(&:name))
-          .to contain_exactly :foo, :bar
+        expect(result.add_delegator(:bar).count).to eq 2
       end
 
     end # context
 
-    context "with contexts" do
+    context "with a block" do
 
-      let(:result) { subject.add_follower "foo", only: [:foo] }
+      let(:result) { subject.add_delegator { foo } }
 
-      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 []
+      it "returns validators" do
+        expect(result).to be_kind_of described_class
+      end
+
+      it "adds a delegator" do
+        item = result.first
+        expect(item).to be_kind_of delegator_class
       end
 
     end # context
 
-    context "existing validator" do
+    context "with contexts" do
 
-      subject { described_class.new.add_follower "foo" }
+      let(:result) { subject.add_delegator "foo", only: [:foo] }
 
-      it "returns itself" do
-        expect(subject.add_follower "foo").to eq subject
+      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
 
-  end # describe #add_follower
+  end # describe #add_delegator
 
   describe "#set" do
 
     subject do
       described_class.new
-        .add_validator("foo", only:   %w(cad cam))
+        .add_validator("foo")
         .add_validator("bar", except: %w(cad))
         .add_validator("baz", except: %w(cam))
     end
@@ -151,7 +160,7 @@ describe Attestor::Validations::Validators do
     it "returns a set of items used in given context" do
       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
+      expect(subject.set("all").map(&:name)).to contain_exactly :foo, :bar, :baz
     end
 
   end # describe #set

data/spec/tests/validations_spec.rb

@@ -6,15 +6,14 @@ describe Attestor::Validations do
 
   let(:validators_class) { Attestor::Validations::Validators }
   let(:validator_class)  { Attestor::Validations::Validator  }
-  let(:follower_class)   { Attestor::Validations::Follower   }
-  let(:collection_class) { Attestor::Validations::Validators }
+  let(:delegator_class)  { Attestor::Validations::Delegator  }
   let(:item_class)       { Attestor::Validations::Item       }
   let(:message_class)    { Attestor::Validations::Message    }
   let(:invalid_error)    { Attestor::InvalidError            }
 
   let(:test_class) { Class.new.send(:include, described_class) }
-  before { Test = test_class                }
-  after  { Object.send :remove_const, :Test }
+  before           { Test = test_class                         }
+  after            { Object.send :remove_const, :Test          }
 
   subject { test_class.new }
 
@@ -38,7 +37,7 @@ describe Attestor::Validations do
 
       it "registers a validator" do
         expect(test_class.validators.map(&:name)).to eq [:foo]
-        expect(test_class.validators.first).not_to be_kind_of follower_class
+        expect(test_class.validators.first).not_to be_kind_of delegator_class
       end
 
     end # context
@@ -57,22 +56,22 @@ describe Attestor::Validations do
 
   end # describe .validate
 
-  describe ".follow_policy" do
+  describe ".validates" do
 
     context "without options" do
 
-      before { test_class.follow_policy :foo }
+      before { test_class.validates :foo }
 
-      it "registers a follower" do
+      it "registers a delegator" do
         expect(test_class.validators.map(&:name)).to eq [:foo]
-        expect(test_class.validators.first).to be_kind_of follower_class
+        expect(test_class.validators.first).to be_kind_of delegator_class
       end
 
     end # context
 
     context "with restrictions" do
 
-      before { test_class.follow_policy :foo, only: %w(bar baz), except: "bar" }
+      before { test_class.validates :foo, only: %w(bar baz), except: "bar" }
 
       it "uses options" do
         expect(test_class.validators.map(&:name)).to eq [:foo]
@@ -82,7 +81,7 @@ describe Attestor::Validations do
 
     end # context
 
-  end # describe .follow_policy
+  end # describe .validates
 
   describe "#invalid" do
 
@@ -126,9 +125,9 @@ describe Attestor::Validations do
   describe "#validate" do
 
     before do
-      test_class.validate :foo
-      test_class.validate :bar, only: :all
-      test_class.follow_policy :baz, only: :foo
+      test_class.validate  :foo
+      test_class.validate  :bar, only: :all
+      test_class.validates :baz, only: :foo
 
       allow(subject).to receive(:foo)
       allow(subject).to receive(:bar)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: attestor
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Andrew Kozin
@@ -81,6 +81,7 @@ files:
 - lib/attestor/policy/or.rb
 - lib/attestor/policy/xor.rb
 - lib/attestor/validations.rb
+- lib/attestor/validations/delegator.rb
 - lib/attestor/validations/follower.rb
 - lib/attestor/validations/message.rb
 - lib/attestor/validations/validator.rb
@@ -98,7 +99,7 @@ files:
 - spec/tests/policy/or_spec.rb
 - spec/tests/policy/xor_spec.rb
 - spec/tests/policy_spec.rb
-- spec/tests/validations/follower_spec.rb
+- spec/tests/validations/delegator_spec.rb
 - spec/tests/validations/message_spec.rb
 - spec/tests/validations/validator_spec.rb
 - spec/tests/validations/validators_spec.rb
@@ -133,8 +134,8 @@ test_files:
 - spec/tests/invalid_error_spec.rb
 - spec/tests/validations_spec.rb
 - spec/tests/validations/message_spec.rb
-- spec/tests/validations/follower_spec.rb
 - spec/tests/validations/validator_spec.rb
+- spec/tests/validations/delegator_spec.rb
 - spec/tests/validations/validators_spec.rb
 - spec/tests/policy/or_spec.rb
 - spec/tests/policy/factory_spec.rb

data/spec/tests/validations/follower_spec.rb

@@ -1,44 +0,0 @@
-# encoding: utf-8
-
-require "support/policies"
-
-describe Attestor::Validations::Follower do
-
-  let(:validator) { Attestor::Validations::Validator }
-  subject { described_class.new "foo" }
-
-  describe ".new" do
-
-    it { is_expected.to be_kind_of validator }
-
-  end # describe .new
-
-  describe "#validate" do
-
-    after { subject.validate object }
-
-    context "when a policy is valid" do
-
-      let(:object) { double foo: valid_policy }
-
-      it "calls policy method and passes" do
-        expect(object).to receive :foo
-        expect(object).not_to receive :invalid
-      end
-
-    end # context
-
-    context "when a policy is invalid" do
-
-      let(:object) { double foo: invalid_policy }
-
-      it "calls policy method and fails" do
-        expect(object).to receive :foo
-        expect(object).to receive(:invalid).with(:foo)
-      end
-
-    end # context
-
-  end # describe #validate
-
-end # describe Attestor::Validations::Follower