attestor 0.0.1

data/lib/attestor/validations/collection.rb

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

data/lib/attestor/validations/item.rb

@@ -0,0 +1,87 @@
+# encoding: utf-8
+
+module Attestor
+
+  module Validations
+
+    # Describes an item of validations' collection
+    #
+    # @api private
+    class Item
+
+      # @!scope class
+      # @!method new(name, except: [], only: [])
+      # Creates a named item with blacklist or whitelist of contexts
+      #
+      # @param  [#to_sym] name
+      # @option [#to_sym, Array<#to_sym>] :except
+      # @option [#to_sym, Array<#to_sym>] :only
+      #
+      # @return [Attestor::Collection::Item]
+
+      # @private
+      def initialize(name, except: nil, only: nil)
+        @name      = name.to_sym
+        @whitelist = normalize(only)
+        @blacklist = normalize(except)
+        generate_id
+        freeze
+      end
+
+      # @!attribute [r] name
+      # The name of the item
+      # @return [Symbol]
+      attr_reader :name
+
+      # Compares an item to another one
+      #
+      # @param [Object] other
+      #
+      # @return [Boolean]
+      def ==(other)
+        other.instance_of?(self.class) ? id.equal?(other.id) : false
+      end
+
+      # Checks if the item should be used in given context
+      #
+      # @param [#to_sym] context
+      #
+      # @return [Boolean]
+      def used_in_context?(context)
+        symbol = context.to_sym
+        whitelisted?(symbol) && !blacklisted?(symbol)
+      end
+
+      protected
+
+      # @!attribute [r] id
+      # The item's identity
+      #
+      # @return [String]
+      attr_reader :id
+
+      private
+
+      attr_reader :whitelist, :blacklist
+
+      def whitelisted?(symbol)
+        whitelist.empty? || whitelist.include?(symbol)
+      end
+
+      def blacklisted?(symbol)
+        blacklist.include? symbol
+      end
+
+      def generate_id
+        @id = [name, whitelist, blacklist].hash
+      end
+
+      def normalize(list)
+        Array(list).map(&:to_sym).uniq
+      end
+
+    end # class Item
+
+  end # module Validations
+
+end # module Attestor

data/lib/attestor/validations/message.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+module Attestor
+
+  module Validations
+
+    # Bulder for error messages
+    #
+    # @api private
+    class Message < String
+
+      # @!scope class
+      # @!method new(value, object, options = {})
+      # Builds a string from value
+      #
+      # @param [#to_s] value
+      # @param [Object] object
+      # @param [Hash] options
+      #   options for translating symbolic value
+      #
+      # @return [String]
+      #   either translation of symbolic value or stringified value argument
+
+      # @private
+      def initialize(value, object, options = {})
+        @value   = value
+        @object  = object
+        @options = options
+        super(@value.instance_of?(Symbol) ? translation : @value.to_s)
+        freeze
+      end
+
+      private
+
+      def translation
+        I18n.t @value, @options.merge(scope: scope, default: default)
+      end
+
+      def scope
+        %W(attestor errors #{ class_scope })
+      end
+
+      def class_scope
+        @object.class.to_s.split("::").map(&:snake_case).join("/")
+      end
+
+      def default
+        "#{ @object } is invalid (#{ @value })"
+      end
+
+    end # class Message
+
+  end # module Validations
+
+end # module Attestor

data/lib/attestor/validations.rb

@@ -0,0 +1,81 @@
+# encoding: utf-8
+
+module Attestor
+
+  # API for objects to be validated
+  module Validations
+
+    # Calls all validations used in the selected context
+    #
+    # @raise [Attestor::Validations::InvalidError] if validations fail
+    # @raise [NoMethodError] if some of validations are not implemented
+    #
+    # @return [undefined]
+    def validate(context = :all)
+      self.class.validations.set(context).each(&method(:__send__))
+    end
+
+    # Raises InvalidError with a corresponding message
+    #
+    # @overload invalid(name, options = {})
+    #
+    #   @param [Symbol] name
+    #     the name of the error
+    #   @param [Hash] options
+    #     the options for symbolic name translation
+    #
+    #   @return [String]
+    #     translation of symbolic name in the current object's scope
+    #
+    # @overload invalid(name)
+    #
+    #   @param [#to_s] name
+    #     the error message (not a symbol)
+    #
+    #   @return [String]
+    #     the name converted to string
+    def invalid(name, options = {})
+      message = Message.new(name, self, options)
+      fail InvalidError.new self, [message]
+    end
+
+    # @private
+    module ClassMethods
+
+      # Returns a collection of items describing applied validations
+      #
+      # @return [Attestor::Collection]
+      #
+      # @api private
+      def validations
+        @validations ||= Collection.new
+      end
+
+      # Adds an item to {#validations}
+      #
+      # Mutates the class by changing its {#validations} 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 validate(name, options = {})
+        @validations = validations.add(name, options)
+      end
+
+    end # module ClassMethods
+
+    # @private
+    def self.included(klass)
+      klass.instance_eval { extend ClassMethods }
+    end
+
+    # @!parse extend Attestor::Validations::ClassMethods
+
+  end # module Validations
+
+end # module Attestor

data/lib/attestor/version.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+module Attestor
+
+  # The semantic version of the module.
+  # @see http://semver.org/ Semantic versioning 2.0
+  VERSION = "0.0.1".freeze
+
+end # module Attestor

data/lib/attestor.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+require "extlib"
+
+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/message"
+
+require_relative "attestor/policy/factory"
+require_relative "attestor/policy"
+require_relative "attestor/policy/node"
+require_relative "attestor/policy/and"
+require_relative "attestor/policy/or"
+require_relative "attestor/policy/xor"
+require_relative "attestor/policy/not"
+require_relative "attestor/policy/negator"
+
+# Namespace for the code of the 'attestor' gem
+module Attestor
+
+end # module Attestor

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+require "hexx-rspec"
+
+begin
+  require "hexx-suit"
+rescue LoadError
+  false
+end
+
+# Loads runtime metrics
+Hexx::RSpec.load_metrics_for(self)
+
+# Loads the code under test
+require "attestor"

data/spec/support/policies.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+# Definitions for testing compound policies
+
+def valid_policy
+  double valid?: true, invalid?: false
+end
+
+def invalid_policy
+  double valid?: false, invalid?: true
+end
+
+shared_examples "creating a node" do
+
+  it { is_expected.to be_kind_of Attestor::Policy::Node }
+
+end # shared examples
+
+shared_examples "creating an immutable object" do
+
+  it "[freezes a policy]" do
+    expect(subject).to be_frozen
+  end
+
+end # shared examples
+
+shared_examples "failing validation" do
+
+  it "[raises exception]" do
+    expect { subject.validate }.to raise_error Attestor::InvalidError
+  end
+
+  it "[adds itself to exception]" do
+    begin
+      subject.validate
+    rescue => error
+      expect(error.object).to eq subject
+    end
+  end
+
+end # shared examples
+
+shared_examples "passing validation" do
+
+  it "[raises exception]" do
+    expect { subject.validate }.not_to raise_error
+  end
+
+end # shared examples

data/spec/tests/invalid_error_spec.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+describe Attestor::InvalidError do
+
+  let(:object) { double :object }
+  subject      { described_class.new object }
+
+  describe ".new" do
+
+    it "creates a RuntimeError" do
+      expect(subject).to be_kind_of RuntimeError
+    end
+
+    it "creates immutable object" do
+      expect(subject).to be_frozen
+    end
+
+    it "doesn't freeze object" do
+      subject
+      expect(object).not_to be_frozen
+    end
+
+    it "doesn't freeze messages" do
+      messages = %i(foo bar)
+      described_class.new object, messages
+
+      expect(messages).not_to be_frozen
+    end
+
+  end # describe .new
+
+  describe "#object" do
+
+    it "is initialized" do
+      expect(subject.object).to be_eql object
+    end
+
+  end # describe #object
+
+  describe "#messages" do
+
+    it "returns an empty array" do
+      expect(subject.messages).to eq []
+    end
+
+    it "can be initialized" do
+      subject = described_class.new(object, %w(cad cam))
+      expect(subject.messages).to eq %w(cad cam)
+    end
+
+    it "is immutable" do
+      expect(subject.messages).to be_frozen
+    end
+
+  end # describe #messages
+
+end # describe Attestor::ValidError

data/spec/tests/policy/and_spec.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+# describe #valid_policy and #invalid_policy builders
+# also describes shared examples for all policies
+require "support/policies"
+
+describe Attestor::Policy::And do
+
+  subject { described_class.new items }
+
+  describe ".new" do
+
+    let(:items) { [valid_policy] }
+
+    it_behaves_like "creating a node"
+    it_behaves_like "creating an immutable object"
+
+  end # context
+
+  describe "#validate" do
+
+    context "when all the parts are valid" do
+
+      let(:items) { 3.times.map { valid_policy } }
+
+      it_behaves_like "passing validation"
+
+    end # context
+
+    context "when a part is invalid" do
+
+      let(:items) { [valid_policy, valid_policy, invalid_policy] }
+
+      it_behaves_like "failing validation"
+
+    end # context
+
+  end # describe #validate
+
+end # describe Policy::Base::Not

data/spec/tests/policy/factory_spec.rb

@@ -0,0 +1,100 @@
+# encoding: utf-8
+
+describe Attestor::Policy::Factory do
+
+  let(:test_class) { Class.new.send :include, described_class }
+  let(:subject)    { test_class.new }
+  let(:policy)     { double :policy }
+  let(:others)     { 2.times.map { double } }
+
+  shared_examples "creating a node" do |composer|
+
+    it "[creates a Node]" do
+      expect(result).to be_kind_of composer
+    end
+
+    it "[sets policies]" do
+      expect(result.branches).to match_array [policy, *others]
+    end
+
+  end # shared examples
+
+  shared_examples "creating a negator" do |composer|
+
+    it "[creates a Negator]" do
+      expect(result).to be_kind_of Attestor::Policy::Negator
+    end
+
+    it "[sets a policy]" do
+      expect(result.policy).to eq policy
+    end
+
+    it "[sets a composer]" do
+      expect(result.composer).to eq composer
+    end
+
+  end # shared examples
+
+  describe "#and" do
+
+    context "with one argument" do
+
+      let(:result) { subject.and(policy, []) }
+      it_behaves_like "creating a negator", Attestor::Policy::And
+
+    end # context
+
+    context "with several arguments" do
+
+      let(:result) { subject.and(policy, others) }
+      it_behaves_like "creating a node", Attestor::Policy::And
+
+    end # context
+
+  end # describe #and
+
+  describe "#or" do
+
+    context "with one argument" do
+
+      let(:result) { subject.or(policy, []) }
+      it_behaves_like "creating a negator", Attestor::Policy::Or
+
+    end # context
+
+    context "with several arguments" do
+
+      let(:result) { subject.or(policy, others) }
+      it_behaves_like "creating a node", Attestor::Policy::Or
+
+    end # context
+
+  end # describe #or
+
+  describe "#xor" do
+
+    context "with one argument" do
+
+      let(:result) { subject.xor(policy, []) }
+      it_behaves_like "creating a negator", Attestor::Policy::Xor
+
+    end # context
+
+    context "with several arguments" do
+
+      let(:result) { subject.xor(policy, others) }
+      it_behaves_like "creating a node", Attestor::Policy::Xor
+
+    end # context
+
+  end # describe #or
+
+  describe "#not" do
+
+    let(:others) { [] }
+    let(:result) { subject.not(policy) }
+    it_behaves_like "creating a node", Attestor::Policy::Not
+
+  end # describe #or
+
+end # describe Attestor::Policy::Factory

data/spec/tests/policy/negator_spec.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+describe Attestor::Policy::Negator do
+
+  let(:composer)  { Attestor::Policy::Node }
+  let(:not_class) { Attestor::Policy::Not  }
+  let(:policy)    { double :policy }
+
+  subject { described_class.new composer, policy }
+
+  describe ".new" do
+
+    it "creates immutable object" do
+      expect(subject).to be_frozen
+    end
+
+  end
+
+  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(:another) { double :another }
+    let(:result)  { subject.not(another) }
+
+    it "creates a composer object" do
+      expect(result).to be_kind_of composer
+    end
+
+    it "sends its policy to the composer" do
+      expect(result.branches).to include policy
+    end
+
+    it "sends the negated arguments to the composer" do
+      negation = double :negation
+      expect(not_class).to receive(:new).with(another).and_return(negation)
+
+      expect(result.branches).to include negation
+    end
+
+  end # describe #not
+
+end # describe Policy::Base::Negator

data/spec/tests/policy/node_spec.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+describe Attestor::Policy::Node do
+
+  let(:policy_class)  { Attestor::Policy }
+  let(:invalid_error) { Attestor::InvalidError }
+
+  describe ".new" do
+
+    it "creates a policy" do
+      expect(subject).to be_kind_of policy_class
+    end
+
+    it "creates immutable object" do
+      expect(subject).to be_frozen
+    end
+
+  end # describe .new
+
+  describe "#branches" do
+
+    let(:branches) { 3.times.map { double } }
+
+    it "are initialized from list" do
+      subject = described_class.new(*branches)
+      expect(subject.branches).to match_array branches
+    end
+
+    it "are initialized from array" do
+      subject = described_class.new(branches)
+      expect(subject.branches).to match_array branches
+    end
+
+  end # describe #branches
+
+  describe "#validate" do
+
+    it "raises InvalidError" do
+      expect { subject.validate }.to raise_error invalid_error
+    end
+
+  end # describe #validate
+
+end # describe Attestor::Policy::Node