policy 1.2.0 → 2.0.0

data/lib/policy/follower/violation_error.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+module Policy
+
+  module Follower
+
+    # An exception to be risen when a follower violates its policy
+    class ViolationError < RuntimeError
+
+      # @!scope class
+      # @!method new(follower, policy)
+      # Constructs an exception for the policy violated by the follower
+      #
+      # @param [Object] follower
+      # @param [#errors] policy
+      #
+      # @return [Policy::ViolationError]
+      def initialize(follower, policy)
+        @follower = follower
+        @policy = policy
+      end
+
+      # @!attribute [r] follower
+      # The follower object that causes the exception
+      #
+      # @return [Object]
+      attr_reader :follower
+
+      # @!attribute [r] policy
+      # The violated policy object
+      #
+      # @return [Policy::Base]
+      attr_reader :policy
+
+      # Returns the list of policy errors
+      #
+      # @return [ActiveModel::Errors]
+      def errors
+        policy.errors
+      end
+
+      # The human-readable exception message
+      #
+      # @return [String]
+      def message
+        "#{ follower.inspect } violates the policy #{ policy }"
+      end
+
+      # The human-readable description for the exception
+      #
+      # @return [String]
+      def inspect
+        "#<#{ self }: #{ message }>"
+      end
+
+    end # class ViolationError
+
+  end # module Follower
+
+end # module Policy

data/lib/policy/version.rb

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

data/policy.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |gem|
   gem.email       = "andrew.kozin@gmail.com"
   gem.homepage    = "https://github.com/nepalez/policy"
   gem.summary     = "Policy Objects for Ruby."
-  gem.description = "A tiny library implementing the Policy Object pattern."
+  gem.description = "A small library implementing the Policy Object pattern."
   gem.license     = "MIT"
 
   gem.files            = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
@@ -20,8 +20,7 @@ Gem::Specification.new do |gem|
 
   gem.required_ruby_version = "~> 2.0"
   gem.add_runtime_dependency "activemodel", ">= 3.1"
-  gem.add_runtime_dependency "adamantium", "~> 0.2"
-  gem.add_runtime_dependency "hexx-cli", "~> 0.0"
+  gem.add_development_dependency "hexx-cli", "~> 0.0"
   gem.add_development_dependency "hexx-rspec", "~> 0.3"
 
 end # Gem::Specification

data/spec/support/composer.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+# Mocks a valid policy object
+#
+# @return [Policy::Base::Node]
+def valid_policy
+  policy = Policy::Base::Node.new
+  allow(policy).to receive(:valid?)   { true  }
+  allow(policy).to receive(:invalid?) { false }
+  policy
+end
+
+# Mocks an invalid policy object
+#
+# @return [Policy::Base::Node]
+def invalid_policy(error: "error")
+  policy = Policy::Base::Node.new
+
+  add_errors = lambda do
+    policy.errors.clear
+    policy.errors.add(:base, error)
+  end
+
+  allow(policy).to receive(:valid?)   { add_errors.call && false }
+  allow(policy).to receive(:invalid?) { add_errors.call && true  }
+
+  policy
+end

data/spec/tests/lib/policy/base/and_spec.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+describe Policy::Base::And do
+
+  # defines mock builders #valid_policy and #invalid_policy
+  require "support/composer"
+
+  let(:one)   { valid_policy }
+  let(:two)   { valid_policy }
+  let(:three) { valid_policy }
+
+  subject { described_class.new one, two, three }
+
+  describe ".new" do
+
+    it "creates a Node" do
+      expect(subject).to be_kind_of Policy::Base::Node
+    end
+
+  end # new
+
+  describe "#policies" do
+
+    it "is initialized" do
+      expect(subject.policies).to contain_exactly one, two, three
+    end
+
+  end # describe #policies
+
+  describe "#valid?" do
+
+    context "when all the policies are valid" do
+
+      it "returns true" do
+        expect(subject).to be_valid
+      end
+
+      it "clears previous errors" do
+        subject.errors.add :base, :subject
+        expect { subject.valid? }.to change { subject.errors.blank? }.to true
+      end
+
+    end # context
+
+    context "when any policy is invalid" do
+
+      let(:three)   { invalid_policy error: "three" }
+      let!(:result) { subject.valid? }
+
+      it "returns false" do
+        expect(result).to eq false
+      end
+
+      it "picks up error from invalid policy" do
+        expect(subject.errors.full_messages).to contain_exactly "three"
+      end
+
+    end # context
+
+  end # describe #valid?
+
+end # describe Policy::Base::Not

data/spec/tests/lib/policy/base/negator_spec.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+describe Policy::Base::Negator do
+
+  let(:composer) { Policy::Base::Node }
+  let(:policy)   { double :policy     }
+
+  subject { described_class.new policy, composer }
+
+  describe "#policy" do
+
+    it "is initialized" do
+      expect(subject.policy).to eq policy
+    end
+
+  end # describe #policy
+
+  describe "#composer" do
+
+    it "is initialized" do
+      expect(subject.composer).to eq composer
+    end
+
+  end # describe #composer
+
+  describe "#not" do
+
+    let(:one) { double :one }
+
+    let(:result) { subject.not(one) }
+
+    it "creates a composer object" do
+      expect(result).to be_kind_of composer
+    end
+
+    it "sends the policy to the composer" do
+      expect(result.policies).to include policy
+    end
+
+    it "sends the negated arguments to the composer" do
+      not_one = double :not_one
+      expect(Policy::Base::Not).to receive(:new).with(one).and_return(not_one)
+
+      expect(result.policies).to include not_one
+    end
+
+  end # describe #not
+
+end # describe Policy::Base::Negator

data/spec/tests/lib/policy/base/not_spec.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+describe Policy::Base::Not do
+
+  # defines mock builders #valid_policy and #invalid_policy
+  require "support/composer"
+
+  let(:policy) { valid_policy }
+  subject      { described_class.new policy }
+
+  it "is a Node" do
+    expect(subject).to be_kind_of Policy::Base::Node
+  end
+
+  describe "#policies" do
+
+    it "is initialized" do
+      expect(subject.policies).to eq [policy]
+    end
+
+  end # describe #policies
+
+  describe "#valid?" do
+
+    context "when the policy is valid" do
+
+      it "returns false" do
+        expect(subject).not_to be_valid
+      end
+
+    end # context
+
+    context "when the policy is invalid" do
+
+      let(:policy) { invalid_policy }
+
+      it "returns true" do
+        expect(subject).to be_valid
+      end
+
+      it "clears previous errors" do
+        subject.errors.add :base, :subject
+        expect { subject.valid? }.to change { subject.errors.blank? }.to true
+      end
+
+    end # context
+
+  end # describe #valid?
+
+end # describe Policy::Base::Not

data/spec/tests/lib/policy/base/or_spec.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+describe Policy::Base::Or do
+
+  # defines mock builders #valid_policy and #invalid_policy
+  require "support/composer"
+
+  let(:one)   { invalid_policy error: "one" }
+  let(:two)   { invalid_policy error: "two" }
+  let(:three) { valid_policy   }
+
+  subject { described_class.new one, two, three }
+
+  describe ".new" do
+
+    it "creates a Node" do
+      expect(subject).to be_kind_of Policy::Base::Node
+    end
+
+  end # new
+
+  describe "#policies" do
+
+    it "is initialized" do
+      expect(subject.policies).to contain_exactly one, two, three
+    end
+
+  end # describe #policies
+
+  describe "#valid?" do
+
+    context "when any policy is valid" do
+
+      it "returns true" do
+        expect(subject).to be_valid
+      end
+
+      it "clears previous errors" do
+        subject.errors.add :base, :subject
+        expect { subject.valid? }.to change { subject.errors.blank? }.to true
+      end
+
+    end # context
+
+    context "when all policies are invalid" do
+
+      let(:three)   { invalid_policy error: "three" }
+      let!(:result) { subject.valid? }
+
+      it "returns false" do
+        expect(result).to eq false
+      end
+
+      it "picks up errors from all policies" do
+        expect(subject.errors).to contain_exactly "one", "two", "three"
+      end
+
+    end # context
+
+  end # describe #valid?
+
+end # describe Policy::Base::Not

data/spec/tests/lib/policy/base/xor_spec.rb

@@ -0,0 +1,73 @@
+# encoding: utf-8
+
+describe Policy::Base::Xor do
+
+  # defines mock builders #valid_policy and #invalid_policy
+  require "support/composer"
+
+  let(:one)   { invalid_policy error: "one" }
+  let(:two)   { invalid_policy error: "two" }
+  let(:three) { valid_policy   }
+
+  subject { described_class.new one, two, three }
+
+  describe ".new" do
+
+    it "creates a Node" do
+      expect(subject).to be_kind_of Policy::Base::Node
+    end
+
+  end # new
+
+  describe "#policies" do
+
+    it "is initialized" do
+      expect(subject.policies).to contain_exactly one, two, three
+    end
+
+  end # describe #policies
+
+  describe "#valid?" do
+
+    context "when both valid and invalid policies are present" do
+
+      it "returns true" do
+        expect(subject).to be_valid
+      end
+
+      it "clears previous errors" do
+        subject.errors.add :base, :subject
+        expect { subject.valid? }.to change { subject.errors.blank? }.to true
+      end
+
+    end # context
+
+    context "when all policies are valid" do
+
+      let(:one) { valid_policy }
+      let(:two) { valid_policy }
+
+      it "returns false" do
+        expect(subject).not_to be_valid
+      end
+
+    end # context
+
+    context "when all policies are invalid" do
+
+      let(:three)   { invalid_policy error: "three" }
+      let!(:result) { subject.valid? }
+
+      it "returns false" do
+        expect(result).to eq false
+      end
+
+      it "picks up errors from all policies" do
+        expect(subject.errors).to contain_exactly "one", "two", "three"
+      end
+
+    end # context
+
+  end # describe #valid?
+
+end # describe Policy::Base::Not

data/spec/tests/lib/policy/base_spec.rb

@@ -0,0 +1,123 @@
+# encoding: utf-8
+
+describe Policy::Base do
+
+  let(:test_class) { Class.new.send(:include, described_class) }
+  subject          { test_class.new }
+
+  it "includes ActiveModel::Validations" do
+    expect(test_class).to include ActiveModel::Validations
+  end
+
+  let(:one) { double :one }
+  let(:two) { double :two }
+
+  describe "#and" do
+
+    context "without policies" do
+
+      let(:result) { subject.and }
+
+      it "creates the negator object" do
+        expect(result).to be_kind_of Policy::Base::Negator
+      end
+
+      it "assigns self as a negator policy" do
+        expect(result.policy).to eq subject
+      end
+
+      it "assings And as a negator composer" do
+        expect(result.composer).to eq Policy::Base::And
+      end
+
+    end # context
+
+    context "with policies" do
+
+      let(:result) { subject.and(one, two) }
+
+      it "creates an And composition" do
+        expect(result).to be_kind_of Policy::Base::And
+      end
+
+      it "assigns given parts to the composition" do
+        expect(result.policies).to contain_exactly subject, one, two
+      end
+
+    end # context
+
+  end # describe #and
+
+  describe "#or" do
+
+    context "without policies" do
+
+      let(:result) { subject.or }
+
+      it "creates the negator object" do
+        expect(result).to be_kind_of Policy::Base::Negator
+      end
+
+      it "assigns self as a negator policy" do
+        expect(result.policy).to eq subject
+      end
+
+      it "assings Or as a negator composer" do
+        expect(result.composer).to eq Policy::Base::Or
+      end
+
+    end # context
+
+    context "with policies" do
+
+      let(:result) { subject.or(one, two) }
+
+      it "creates an Or composition" do
+        expect(result).to be_kind_of Policy::Base::Or
+      end
+
+      it "assigns given parts to the composition" do
+        expect(result.policies).to contain_exactly subject, one, two
+      end
+
+    end # context
+
+  end # describe #or
+
+  describe "#xor" do
+
+    context "without policies" do
+
+      let(:result) { subject.xor }
+
+      it "creates the negator object" do
+        expect(result).to be_kind_of Policy::Base::Negator
+      end
+
+      it "assigns self as a negator policy" do
+        expect(result.policy).to eq subject
+      end
+
+      it "assings Xor as a negator composer" do
+        expect(result.composer).to eq Policy::Base::Xor
+      end
+
+    end # context
+
+    context "with policies" do
+
+      let(:result) { subject.xor(one, two) }
+
+      it "creates an Xor composition" do
+        expect(result).to be_kind_of Policy::Base::Xor
+      end
+
+      it "assigns given parts to the composition" do
+        expect(result.policies).to contain_exactly subject, one, two
+      end
+
+    end # context
+
+  end # describe #xor
+
+end # describe Policy::Base