assertion 0.1.0 → 0.2.0

data/lib/assertion/dsl.rb

@@ -0,0 +1,77 @@
+# encoding: utf-8
+
+module Assertion
+
+  # Provides methods to build assertions and guards
+  #
+  module DSL
+
+    # Builds the subclass of `Assertion::Base` with predefined `attributes`
+    # and implementation of the `#check` method.
+    #
+    # @example
+    #   IsMan = Assertion.about :age, :gender do
+    #     (age >= 18) && (gender == :male)
+    #   end
+    #
+    #   # This is the same as:
+    #   class IsMan < Assertion::Base
+    #     attribute :age, :gender
+    #
+    #     def check
+    #       (age >= 18) && (gender == :male)
+    #     end
+    #   end
+    #
+    # @param [Symbol, Array<Symbol>] attributes
+    #   The list of attributes for the new assertion
+    # @param [Proc] block
+    #   The content for the `check` method
+    #
+    # @return [Class] The specific assertion class
+    #
+    def about(*attributes, &block)
+      __build__(Base, attributes, :check, &block)
+    end
+
+    # Builds the subclass of `Assertion::Guard` with given attribute
+    # (alias for the `object`) and implementation of the `#state` method.
+    #
+    # @example
+    #   VoterOnly = Assertion.guards :user do
+    #     IsAdult[user.attributes] & IsCitizen[user.attributes]
+    #   end
+    #
+    #   # This is the same as:
+    #   class VoterOnly < Assertion::Guard
+    #     alias_method :user, :object
+    #
+    #     def state
+    #       IsAdult[user.attributes] & IsCitizen[user.attributes]
+    #     end
+    #   end
+    #
+    # @param [Symbol] attribute
+    #   The alias for the `object` attribute
+    # @param [Proc] block
+    #   The content for the `state` method
+    #
+    # @return [Class] The specific guard class
+    #
+    def guards(attribute = nil, &block)
+      __build__(Guard, attribute, :state, &block)
+    end
+
+    private
+
+    def __build__(type, attributes, name, &block)
+      klass = Class.new(type)
+      klass.public_send(:attribute, attributes) if attributes
+      klass.__send__(:define_method, name, &block) if block_given?
+
+      klass
+    end
+
+  end # module DSL
+
+end # module Assertion

data/lib/assertion/guard.rb

@@ -32,29 +32,7 @@ module Assertion
   #
   class Guard
 
-    extend Attributes
-
-    class << self
-
-      # Initializes and guard for the provided object and calls it immediately
-      #
-      # @param [Object] object The object whose state should be tested
-      #
-      # @return (see #call)
-      #
-      # @raise (see #call)
-      #
-      def [](object)
-        new(object).call
-      end
-
-      private
-
-      def __forbidden_attributes__
-        [:state]
-      end
-
-    end # eigenclass
+    extend GuardDSL
 
     # @!attribute [r] object
     #
@@ -73,7 +51,6 @@ module Assertion
     # @private
     def initialize(object)
       @object = object
-      self.class.attributes.each(&method(:__set_attribute__))
       freeze
     end
 
@@ -88,12 +65,6 @@ module Assertion
       object
     end
 
-    private
-
-    def __set_attribute__(name)
-      singleton_class.instance_eval { alias_method name, :object }
-    end
-
   end # class Guard
 
 end # module Assertion

data/lib/assertion/guard_dsl.rb

@@ -0,0 +1,39 @@
+module Assertion
+
+  # Provides methods to describe and apply guards
+  #
+  module GuardDSL
+
+    # Initializes and guard for the provided object and calls it immediately
+    #
+    # @param [Object] object The object whose state should be tested
+    #
+    # @return (see Assertion::Guard#call)
+    #
+    # @raise (see Assertion::Guard#call)
+    #
+    def [](object)
+      new(object).call
+    end
+
+    # Adds alias to the [#object] method
+    #
+    # @param [#to_sym] name
+    #
+    # @return [undefined]
+    #
+    def attribute(name)
+      __check_attribute__(name)
+      alias_method name, :object
+    end
+
+    private
+
+    def __check_attribute__(key)
+      return unless (instance_methods << :state).include? key.to_sym
+      fail NameError.new "#{self}##{key} is already defined"
+    end
+
+  end # module GuardDSL
+
+end # module Assertion

data/lib/assertion/inversion.rb

@@ -5,14 +5,14 @@ module Assertion
   # Describes the inversion of the assertion object
   #
   # The inversion decorates the source assertion switching its message
-  # (from wrong to right) and reverting its `check`.
+  # (from falsey to truthy) and reverting its `check`.
   #
   # @example
-  #   Adult = Assertion.about :name, :age do
+  #   IsAdult = Assertion.about :name, :age do
   #     age >= 18
   #   end
   #
-  #   assertion = Adult.new
+  #   assertion = IsAdult.new
   #   inversion = Inversion.new(assertion)
   #
   #   assertion.call.valid? == inversion.call.invalid? # => true

data/lib/assertion/inverter.rb

@@ -5,13 +5,13 @@ module Assertion
   # Builds inversions for instances of some `Assertion::Base` subclass
   #
   # @example
-  #   Adult = Assertion.about :name, :age do
+  #   IsAdult = Assertion.about :name, :age do
   #     age >= 18
   #   end
   #
   #   joe = OpenStruct.new(name: "Joe", age: 40)
   #
-  #   child = Inverter.new(Adult)
+  #   child = Inverter.new(IsAdult)
   #   child[name: "Joe"].validate!
   #   # => #<Assertion::InvalidError @messages=["Joe is an adult (age 40)"]>
   #

data/lib/assertion/translator.rb

@@ -0,0 +1,95 @@
+# encoding: utf-8
+
+require "i18n"
+
+module Assertion
+
+  # Module defines how to translate messages describing the desired state
+  # of the current assertion
+  #
+  # You need to declare a hash of attributes to be added to the translation.
+  #
+  # @example
+  #   class MyClass
+  #     include Assertion::Translator
+  #     def attributes
+  #       {}
+  #     end
+  #   end
+  #
+  #   item = MyClass.new
+  #   item.message(true)
+  #   # => "translation missing: en.assertion.my_class.truthy"
+  #   item.message(false)
+  #   # => "translation missing: en.assertion.my_class.falsey"
+  #
+  # @author Andrew Kozin <Andrew.Kozin@gmail.com>
+  #
+  class Translator
+
+    # The gem-specific root scope for translations
+    #
+    # @return [Symbol]
+    #
+    ROOT = :assertion
+
+    # The states to be translated with their dictionary names
+    #
+    # @return [Hash<Object => Symbol>]
+    #
+    DICTIONARY = { true => :truthy, false => :falsey }
+
+    # Provides a scope for the class
+    #
+    # @param [Class] klass
+    #
+    # @return [Array<Symbol>]
+    #
+    def self.scope(klass)
+      [ROOT, Inflector[:to_snake_path][klass.name].to_sym]
+    end
+
+    # @!attribute [r] scope
+    #
+    # @return [Array<Symbol>] the scope for translations
+    #
+    attr_reader :scope
+
+    # @!attribute [r] scope
+    #
+    # @return [Class] the assertion whose state should be translated
+    #
+    attr_reader :assertion
+
+    # @!scope class
+    # @!method new(assertion)
+    # Creates a state translator for the given assertion class
+    #
+    # @param [Class] assertion
+    #
+    # @return [Assertion::Translator]
+
+    # @private
+    def initialize(assertion)
+      @assertion = assertion
+      @scope = self.class.scope(assertion)
+      freeze
+    end
+
+    # Returns the message describing the desired state of given assertion
+    #
+    # The translation is provided for the gem-specific scope for the
+    # current class
+    #
+    # @param [Boolean] state The state of the assertion
+    # @param [Hash] args The hash of arguments to be avaliable in a translation
+    #
+    # @return [String] The translation
+    #
+    def call(state, args = {})
+      I18n.translate DICTIONARY[state], args.merge(scope: scope)
+    end
+
+  end # class Translator
+
+end # module Assertion

data/lib/assertion/version.rb

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

data/spec/integration/guard_spec.rb

@@ -13,7 +13,7 @@ describe Assertion do
     end
 
     AdultOnly = Assertion.guards :user do
-      IsAdult[user]
+      IsAdult[user.to_h]
     end
 
     andrew = OpenStruct.new(name: "Andrew", age: 13, city: "Moscow")

data/spec/shared/en.yml

@@ -3,8 +3,8 @@
 en:
   assertion:
     is_adult:
-      right: "%{name} is an adult (age %{age})"
-      wrong: "%{name} is a child (age %{age})"
+      truthy: "%{name} is an adult (age %{age})"
+      falsey: "%{name} is a child (age %{age})"
     is_male:
-      right: "%{name} is a male"
-      wrong: "%{name} is a female"
+      truthy: "%{name} is a male"
+      falsey: "%{name} is a female"

data/spec/unit/assertion/base_spec.rb

@@ -5,14 +5,6 @@ describe Assertion::Base do
   let(:klass) { Class.new(described_class) }
   before { allow(klass).to receive(:name) { "Test" } }
 
-  it "can declare attributes" do
-    expect(klass).to be_kind_of Assertion::Attributes
-  end
-
-  it "can translate states" do
-    expect(klass).to include Assertion::Messages
-  end
-
   describe ".new" do
 
     let(:klass) { Class.new(described_class) { attribute :foo, :bar } }
@@ -45,6 +37,82 @@ describe Assertion::Base do
 
   end # describe .new
 
+  describe ".attributes" do
+
+    subject { klass.attributes }
+    it { is_expected.to eql [] }
+
+  end # describe .attributes
+
+  describe ".attribute" do
+
+    shared_examples "defining attributes" do
+
+      it "registers attributes" do
+        expect { subject }.to change { klass.attributes }.to [:foo, :bar]
+      end
+
+      it "declares attributes" do
+        subject
+        assertion = klass.new(foo: :FOO, bar: :BAR, baz: :BAZ)
+        expect(assertion.attributes).to eql(foo: :FOO, bar: :BAR)
+        expect(assertion.foo).to eql :FOO
+        expect(assertion.bar).to eql :BAR
+      end
+
+    end # shared examples
+
+    shared_examples "raising NameError" do |with: nil|
+
+      it "fails" do
+        expect { subject }.to raise_error do |exception|
+          expect(exception).to be_kind_of NameError
+          expect(exception.message).to eql "#{klass}##{with} is already defined"
+        end
+      end
+
+    end # shared examples
+
+    context "with a single name" do
+
+      subject do
+        klass.attribute :foo
+        klass.attribute "bar"
+      end
+      it_behaves_like "defining attributes"
+
+    end # context
+
+    context "with a list of names" do
+
+      subject { klass.attribute :foo, :bar }
+      it_behaves_like "defining attributes"
+
+    end # context
+
+    context "with an array of names" do
+
+      subject { klass.attribute %w(foo bar) }
+      it_behaves_like "defining attributes"
+
+    end # context
+
+    context ":check" do
+
+      subject { klass.attribute :check }
+      it_behaves_like "raising NameError", with: :check
+
+    end # context
+
+    context ":call" do
+
+      subject { klass.attribute :call }
+      it_behaves_like "raising NameError", with: :call
+
+    end # context
+
+  end # describe .attribute
+
   describe ".not" do
 
     subject { klass.not }
@@ -58,20 +126,46 @@ describe Assertion::Base do
 
   describe ".[]" do
 
-    subject { klass[params] }
-
     let(:params)    { { foo: :FOO }      }
     let(:state)     { double             }
     let(:assertion) { double call: state }
 
-    before { allow(klass).to receive(:new).with(params) { assertion } }
+    context "with params" do
 
-    it "checks the assertion for given attributes" do
-      expect(subject).to eql state
-    end
+      subject { klass[params] }
+
+      it "checks the assertion for given attributes" do
+        allow(klass).to receive(:new).with(params) { assertion }
+        expect(subject).to eql state
+      end
+
+    end # context
+
+    context "without params" do
+
+      subject { klass[] }
+
+      it "checks the assertion" do
+        allow(klass).to receive(:new) { assertion }
+        expect(subject).to eql state
+      end
+
+    end # context
 
   end # describe .[]
 
+  describe ".translator" do
+
+    subject { klass.translator }
+
+    it { is_expected.to be_kind_of Assertion::Translator }
+
+    it "refers to the current class" do
+      expect(subject.assertion).to eql klass
+    end
+
+  end # describe .translator
+
   describe "#attributes" do
 
     let(:attrs)     { { foo: :FOO, bar: :BAR } }
@@ -83,6 +177,22 @@ describe Assertion::Base do
 
   end # describe #attributes
 
+  describe "#message" do
+
+    let(:state)      { double }
+    let(:attrs)      { { foo: :FOO, bar: :BAR } }
+    let(:klass)      { Class.new(described_class) { attribute :foo, :bar } }
+    let(:assertion)  { klass.new attrs }
+    let(:translator) { double call: nil }
+
+    it "calls a translator with state and attributes" do
+      allow(klass).to receive(:translator) { translator }
+      expect(translator).to receive(:call).with(state, attrs)
+      assertion.message(state)
+    end
+
+  end # describe #message
+
   describe "#call" do
 
     subject { assertion.call }