assertion 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5cd46bf51eb8357641668f5f3762bf0fb5a0dbd7
-  data.tar.gz: 048a9c8f663aed972a4ee8e0ded514a7310a6742
+  metadata.gz: e02fce1546e9b7523fbff83894476957ca0b335d
+  data.tar.gz: 49d6ede0ddd7a992b8bd688cc55ef06b0b7a66bd
 SHA512:
-  metadata.gz: ec1de6dade9383cd776f497fe0bfbaf452a1a60ae3ed5b341fe8741fbf891a4f43bf3ac08cbfa7fa1541aae1ce71937ba350cbd3932ae0f1975a01f7ac859e79
-  data.tar.gz: 7fe6666427458a4291988444e4a333219297cde70cd1aa592d2d3624625d8bc0c39bb647eb25bc1c49c8a1963e609f927443ef6ba51d4cd35ee45a0e0c4d5a81
+  metadata.gz: d4db34e23434e46569f8fa530d41bec8a0d8b920e7d13344ed6a0a864a0c416398f4835faa1e1e77b35b8d63025416b1fc32b2e9f17ceb3c85b42678fda9e75e
+  data.tar.gz: d9d16dd22f86a0da3e37b6e23f68b0c049bc6832dfec864c94fbfe41f6dd6e2e71b8f0f677f35757fddd012b69116853a59bb1db2d3960db9b73d08c3f059a87

data/CHANGELOG.md

@@ -1,3 +1,19 @@
+## v0.2.1 2015-06-23
+
+### Bugs Fixed
+
+* Support any values returned by `Base#check` method, not only boolean ones (nepalez)
+
+### Internal
+
+* `[]` caller method is extracted from `BaseDSL`, `Inverter`, and `GuardDSL` to `DSL::Caller` (nepalez)
+* `GuardDSL` is splitted to `DSL::Caller` and `DSL::Attribute` (nepalez)
+* `.attribute`, `.attributes` and `#attributes` extracted from `BaseDSL` to `DSL::Attributes` (nepalez)
+* `BaseDSL` is splitted to `DSL::Attributes`, `DSL::Caller` and `DSL::Inversion` (nepalez)
+* `DSL` is renamed to `DSL::Builder` to follow the convention. `DSL` is reserved for collection of DSLs (nepalez)
+
+[Compare v0.2.0...v0.2.1](https://github.com/nepalez/assertion/compare/v0.2.0...v0.2.1)
+
 ## v0.2.0 2015-06-22
 
 ### Changed (backward-incompatible!)

data/README.md

@@ -29,7 +29,7 @@ No `ActiveSupport`, no mutation of any instances.
 ### Basic Usage
 
 Define an assertion by inheriting it from the `Assertion::Base` class with attributes to which it should be applied.
-Then implement the method `check` that should return a boolean value.
+Then implement the method `check` to describe if the assertion is truthy or falsey.
 
 You can do it either in the classic style:
 

data/lib/assertion.rb

@@ -4,15 +4,19 @@ require "transproc"
 
 require_relative "assertion/inflector"
 require_relative "assertion/invalid_error"
+
+require_relative "assertion/dsl/caller"
+require_relative "assertion/dsl/attribute"
+require_relative "assertion/dsl/attributes"
+require_relative "assertion/dsl/inversion"
+require_relative "assertion/dsl/builder"
+
 require_relative "assertion/translator"
 require_relative "assertion/state"
-require_relative "assertion/base_dsl"
 require_relative "assertion/base"
 require_relative "assertion/inversion"
 require_relative "assertion/inverter"
-require_relative "assertion/guard_dsl"
 require_relative "assertion/guard"
-require_relative "assertion/dsl"
 
 # The module declares:
 #
@@ -54,6 +58,6 @@ require_relative "assertion/dsl"
 #
 module Assertion
 
-  extend DSL
+  extend DSL::Builder
 
 end # module Assertion

data/lib/assertion/base.rb

@@ -35,7 +35,9 @@ module Assertion
   #
   class Base
 
-    extend BaseDSL
+    extend DSL::Attributes
+    extend DSL::Inversion
+    extend DSL::Caller
 
     # The translator of states for the current class
     #
@@ -81,7 +83,7 @@ module Assertion
     #
     # @return [String]
     #
-    def message(state)
+    def message(state = nil)
       self.class.translator.call(state, attributes)
     end
 
@@ -94,7 +96,7 @@ module Assertion
     #   The state of the assertion being applied to its attributes
     #
     def call
-      State.new check, message(false)
+      State.new check, message
     end
 
   end # class Base

data/lib/assertion/dsl/attribute.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+module Assertion
+
+  # Collection of DSLs for various modules and classes
+  #
+  module DSL
+
+    # Allows adding aliases to `#object` method.
+    #
+    module Attribute
+
+      # Adds alias to the [#object] method
+      #
+      # @param [#to_sym] name
+      #
+      # @return [undefined]
+      #
+      # @raise [NameError]
+      #   When a given name is either used by instance methods,
+      #   or reserved by the `#state` method to be implemented later.
+      #
+      def attribute(name)
+        __check_attribute__(name)
+        alias_method name, :object
+      end
+
+      # @private
+      def self.extended(klass)
+        klass.__send__ :attr_reader, :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 Attribute
+
+  end # module DSL
+
+end # module Assertion

data/lib/assertion/dsl/attributes.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+
+module Assertion
+
+  module DSL
+
+    # Allows adding aliases to values of the `#attributes` hash.
+    #
+    module Attributes
+
+      # List of declared attributes
+      #
+      # @return [Array<Symbol>]
+      #
+      def attributes
+        @attributes ||= []
+      end
+
+      # Declares new attribute(s) by name(s)
+      #
+      # @param [#to_sym, Array<#to_sym>] names
+      #
+      # @return [undefined]
+      #
+      # @raise [NameError]
+      #   When a given name is either used by instance methods,
+      #   or reserved by the `#check` method to be implemented later.
+      #
+      def attribute(*names)
+        names.flatten.map(&:to_sym).each(&method(:__add_attribute__))
+      end
+
+      # @private
+      def self.extended(klass)
+        klass.__send__(:define_method, :attributes) { @attributes ||= {} }
+      end
+
+      private
+
+      def __add_attribute__(name)
+        __check_attribute__(name)
+        attributes << define_method(name) { attributes[name] }
+      end
+
+      def __check_attribute__(name)
+        return unless (instance_methods << :check).include? name
+        fail NameError.new "#{self}##{name} is already defined"
+      end
+
+    end # module Attributes
+
+  end # module DSL
+
+end # module Assertion

data/lib/assertion/dsl/builder.rb

@@ -0,0 +1,81 @@
+# encoding: utf-8
+
+module Assertion
+
+  module DSL
+
+    # Provides methods to build assertions and guards
+    #
+    module Builder
+
+      # 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 Builder
+
+  end # module DSL
+
+end # module Assertion

data/lib/assertion/dsl/caller.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+module Assertion
+
+  module DSL
+
+    # Allows to initialize and call objects at once
+    #
+    module Caller
+
+      # Initializes and immediately calls the instance of the class
+      #
+      # @param [Object, Array<Object>] args
+      #   The <list of> arguments to initialize the instance with
+      #
+      # @return [Object] the result of #call method
+      #
+      def [](*args)
+        new(*args).call
+      end
+
+    end # module Caller
+
+  end # module DSL
+
+end # module Assertion

data/lib/assertion/dsl/inversion.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+module Assertion
+
+  module DSL
+
+    # Allows to provide inverter for objects of the current class
+    #
+    module Inversion
+
+      # Initializes the intermediate inverter with `new` and `[]` methods
+      #
+      # The inverter can be used to initialize the assertion, that describes
+      # just the opposite statement to the current one
+      #
+      # @example
+      #   IsAdult = Assertion.about :name, :age do
+      #     age >= 18
+      #   end
+      #
+      #   joe = { name: 'Joe', age: 19 }
+      #
+      #   IsAdult[joe].valid?     # => true
+      #   IsAdult.not[joe].valid? # => false
+      #
+      # @return [Assertion::Inverter]
+      #
+      def not
+        Inverter.new(self)
+      end
+
+    end # module Inversion
+
+  end # module DSL
+
+end # module Assertion

data/lib/assertion/guard.rb

@@ -32,13 +32,8 @@ module Assertion
   #
   class Guard
 
-    extend GuardDSL
-
-    # @!attribute [r] object
-    #
-    # @return [Object] The object whose state should be tested
-    #
-    attr_reader :object
+    extend DSL::Attribute
+    extend DSL::Caller
 
     # @!scope class
     # @!method new(object)

data/lib/assertion/inverter.rb

@@ -17,6 +17,8 @@ module Assertion
   #
   class Inverter
 
+    include DSL::Caller
+
     # @!attribute [r] source
     #
     # @return [Class] The `Assertion::Base` sublcass to build negators for
@@ -47,16 +49,6 @@ module Assertion
       Inversion.new source.new(hash)
     end
 
-    # Initializes an assertion, builds its inversion, and applies it to the data
-    #
-    # @param (see #new)
-    #
-    # @return (see Assertion::Base#call)
-    #
-    def [](hash = {})
-      new(hash).call
-    end
-
   end # class Inverter
 
 end # module Assertion

data/lib/assertion/translator.rb

@@ -87,7 +87,7 @@ module Assertion
     # @return [String] The translation
     #
     def call(state, args = {})
-      I18n.translate DICTIONARY[state], args.merge(scope: scope)
+      I18n.translate DICTIONARY[state ? true : false], args.merge(scope: scope)
     end
 
   end # class Translator

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.2.0".freeze
+  VERSION = "0.2.1".freeze
 
 end # module Assertion

data/spec/unit/assertion/base_spec.rb

@@ -5,6 +5,18 @@ describe Assertion::Base do
   let(:klass) { Class.new(described_class) }
   before { allow(klass).to receive(:name) { "Test" } }
 
+  it "implements DSL::Caller" do
+    expect(klass).to be_kind_of Assertion::DSL::Caller
+  end
+
+  it "implements DSL::Attributes" do
+    expect(klass).to be_kind_of Assertion::DSL::Attributes
+  end
+
+  it "implements DSL::Inversion" do
+    expect(klass).to be_kind_of Assertion::DSL::Inversion
+  end
+
   describe ".new" do
 
     let(:klass) { Class.new(described_class) { attribute :foo, :bar } }
@@ -37,158 +49,39 @@ describe Assertion::Base do
 
   end # describe .new
 
-  describe ".attributes" do
-
-    subject { klass.attributes }
-    it { is_expected.to eql [] }
-
-  end # describe .attributes
+  describe "#message" do
 
-  describe ".attribute" do
+    let(:klass)      { Class.new(described_class) { attribute :foo } }
+    let(:assertion)  { klass.new(foo: :FOO)                          }
 
-    shared_examples "defining attributes" do
+    shared_examples "translating" do |as: nil|
 
-      it "registers attributes" do
-        expect { subject }.to change { klass.attributes }.to [:foo, :bar]
-      end
+      let(:translator) { Assertion::Translator.new(klass) }
+      let(:attributes) { assertion.attributes             }
 
-      it "declares attributes" do
+      it "uses attributes in a translation" do
+        expect(I18n).to receive :translate do |_, args|
+          expect(args.merge(attributes)).to eql args
+        end
         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
+      it "returns a translation" do
+        expect(subject).to eql translator.call(as, attributes)
       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 }
-
-    it "creates the iverter for the current class" do
-      expect(subject).to be_kind_of Assertion::Inverter
-      expect(subject.source).to eql klass
+    it_behaves_like "translating", as: true do
+      subject { assertion.message(true) }
     end
 
-  end # describe .not
-
-  describe ".[]" do
-
-    let(:params)    { { foo: :FOO }      }
-    let(:state)     { double             }
-    let(:assertion) { double call: state }
-
-    context "with params" do
-
-      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
+    it_behaves_like "translating", as: false do
+      subject { assertion.message(false) }
     end
 
-  end # describe .translator
-
-  describe "#attributes" do
-
-    let(:attrs)     { { foo: :FOO, bar: :BAR } }
-    let(:klass)     { Class.new(described_class) { attribute :foo, :bar } }
-    let(:assertion) { klass.new attrs }
-
-    subject { assertion.attributes     }
-    it      { is_expected.to eql attrs }
-
-  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)
+    it_behaves_like "translating", as: false do
+      subject { assertion.message }
     end
 
   end # describe #message