assertion 0.0.1

data/lib/assertion/exceptions/invalid_error.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+module Assertion
+
+  # The exception to be raised by invalid assertions' `validate!` method call
+  #
+  # @api public
+  #
+  class InvalidError < RuntimeError
+
+    # @!scope class
+    # @!method new(*names)
+    # Creates an exception instance
+    #
+    # @param [Symbol, Array<Symbol>] names Wrong names of attribute(s)
+    #
+    # @return [Assertion::InvalidError]
+    #
+    # @api private
+
+    # @private
+    def initialize(*messages)
+      @messages = messages.flatten.freeze
+      super
+      freeze
+    end
+
+    # @!attribute [r] messages
+    #
+    # @return [Array<String>] The list of error messages
+    #
+    attr_reader :messages
+
+  end # class InvalidError
+
+end # module Assertion

data/lib/assertion/exceptions/name_error.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module Assertion
+
+  # The exception to be raised when a Assertion attribute uses reserved name(s)
+  #
+  # @api public
+  #
+  class NameError < ::NameError
+
+    # @!scope class
+    # @!method new(*names)
+    # Creates an exception instance
+    #
+    # @param [Symbol, Array<Symbol>] names Wrong names of attribute(s)
+    #
+    # @return [Assertion::NameError]
+    #
+    # @api private
+
+    # @private
+    def initialize(*names)
+      super "Wrong name(s) for attribute(s): #{names.join(", ")}"
+      freeze
+    end
+
+  end # class NameError
+
+end # module Assertion

data/lib/assertion/exceptions/not_implemented_error.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module Assertion
+
+  # The exception to be raised when a assertion is applied to some data
+  # before its `check` method has been implemented
+  #
+  # @api public
+  #
+  class NotImplementedError < ::NotImplementedError
+
+    # @!scope class
+    # @!method new(klass, name)
+    # Creates an exception instance
+    #
+    # @param [Class] klass The class that should implement the instance method
+    # @param [Symbol] name The name of the method to be implemented
+    #
+    # @return [Assertion::NotImplementedError]
+
+    # @private
+    def initialize(klass, name)
+      super "#{klass.name}##{name} method not implemented"
+      freeze
+    end
+
+  end # class NotImplementedError
+
+end # module Assertion

data/lib/assertion/inversion.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+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`.
+  #
+  # @example
+  #   Adult = Assertion.about :name, :age do
+  #     age >= 18
+  #   end
+  #
+  #   assertion = Adult.new
+  #   inversion = Inversion.new(assertion)
+  #
+  #   assertion.call.valid? == inversion.call.invalid? # => true
+  #
+  # @api private
+  #
+  class Inversion < Base
+
+    # @!scope class
+    # @!method new(assertion)
+    # Creates the inversion for the selected assertion object
+    #
+    # @param [Assertion::Base] assertion The assertion being inverted
+    #
+    # @return [Assertion::Inversion]
+
+    # @private
+    def initialize(assertion)
+      @assertion = assertion
+      freeze
+    end
+
+    # @!attribute [r] assertion
+    #
+    # @return [Assertion::Base] The assertion being inverted
+    #
+    attr_reader :assertion
+
+    # The translated message describing the state of assertion
+    #
+    # @param [Boolean] state
+    #
+    # @return [String]
+    #
+    def message(state = nil)
+      assertion.message(!state)
+    end
+
+    # Checks the current state of the assertion
+    #
+    # @return [Boolean]
+    #
+    def check
+      !assertion.check
+    end
+
+  end # class Inversion
+
+end # module Assertion

data/lib/assertion/inverter.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+module Assertion
+
+  # Builds inversions for instances of some `Assertion::Base` subclass
+  #
+  # @example
+  #   Adult = Assertion.about :name, :age do
+  #     age >= 18
+  #   end
+  #
+  #   joe = OpenStruct.new(name: "Joe", age: 40)
+  #
+  #   child = Inverter.new(Adult)
+  #   child[name: "Joe"].validate!
+  #   # => #<Assertion::InvalidError @messages=["Joe is an adult (age 40)"]>
+  #
+  class Inverter
+
+    # @!attribute [r] source
+    #
+    # @return [Class] The `Assertion::Base` sublcass to build negators for
+    #
+    attr_reader :source
+
+    # @!scope class
+    # @!method new(source)
+    # Creates an immutable inversion object for the `Assertion::Base` subclass
+    #
+    # @param [Class] source
+    #
+    # @return [Assertion::Inverter]
+
+    # @private
+    def initialize(source)
+      @source = source
+      freeze
+    end
+
+    # Initializes a [#source] object and builds a negator for it
+    #
+    # @param [Hash] hash The hash of attributes to apply the assertion to
+    #
+    # @return [Assertion::Inverter::Inversion]
+    #
+    def new(hash = {})
+      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/state.rb

@@ -0,0 +1,79 @@
+# encoding: utf-8
+
+module Assertion
+
+  # Describes the state of the assertion applied to given arguments
+  # (the result of the checkup)
+  #
+  # @api public
+  #
+  class State
+
+    # @!scope class
+    # @!method new(state, *messages)
+    # Creates the immutable state instance with a corresponding error messages
+    #
+    # @param [Boolean] state
+    # @param [String, Array<String>] messages
+    #
+    # @return [Assertion::State]
+
+    # @private
+    def initialize(state, *messages)
+      @state = state
+      @messages = (state ? [] : messages.flatten.uniq).freeze
+      freeze
+    end
+
+    # @!attribute [r] messages
+    #
+    # @return [Array<String>] error messages
+    #
+    attr_reader :messages
+
+    # Check whether a stated assertion is satisfied by its attributes
+    #
+    # @return [Boolean]
+    #
+    def valid?
+      !invalid?
+    end
+
+    # Check whether a stated assertion is not satisfied by its attributes
+    #
+    # @return [Boolean]
+    #
+    def invalid?
+      !@state
+    end
+
+    # Check whether a stated assertion is satisfied by its attributes
+    #
+    # @return [true]
+    #
+    # @raise [Assertion::InvalidError]
+    #   When a assertion is not satisfied (validation fails)
+    #
+    def validate!
+      invalid? ? fail(InvalidError.new messages) : true
+    end
+
+    # Composes the state with the other state
+    #
+    # @param [Assertion::State] other
+    #
+    # @return [Assertion::State]
+    #   The composed state that carries messages from both the states
+    #
+    # @alias >>
+    # @alias +
+    #
+    def &(other)
+      self.class.new(valid? & other.valid?, messages + other.messages)
+    end
+    alias_method :>>, :&
+    alias_method :+, :&
+
+  end # class State
+
+end # module Assertion

data/lib/assertion/transprocs/i18n.rb

@@ -0,0 +1,55 @@
+module Assertion
+
+  # The collection of pure functions for translating strings in the gem-specific
+  # scopes of `Assertion::Base` subclasses.
+  #
+  # @api private
+  #
+  module I18n
+
+    extend ::Transproc::Registry
+
+    uses :to_snake_path, from: Inflector, as: :snake
+
+    # Converts the name of the class to the corresponding gem-specific scope
+    #
+    # @example
+    #   fn = I18n[:scope]
+    #   fn["Foo::BarBaz"]
+    #   # => [:assertion, :"foo/bar_baz"]
+    #
+    # @param [String] name The name of the class
+    #
+    # @return [Array<Symbol>] The `I18n`-compatible gem-specific scope
+    #
+    def scope(name)
+      [:assertion, snake(name).to_sym]
+    end
+
+    # Translates the key with hash of attributes in a given scope
+    #
+    # @example
+    #   # config/locales/en.yml
+    #   # ---
+    #   # en:
+    #   #   assertion:
+    #   #     foo:
+    #   #       qux: "message %{bar}"
+    #
+    #   fn = I18n[:translate, [:assertion, :foo], bar: :BAZ]
+    #   fn[:qux]
+    #   # => "message BAZ"
+    #
+    # @param [key] key The key to be translated
+    # @param [Array<Symbol>] scope The I18n scope for the translations
+    # @param [Hash] hash The hash of attributes for the translation
+    #
+    # @return [String] The translated string
+    #
+    def translate(key, scope, hash)
+      ::I18n.t(key, hash.merge(scope: scope))
+    end
+
+  end # module I18n
+
+end # module Assertion

data/lib/assertion/transprocs/inflector.rb

@@ -0,0 +1,39 @@
+module Assertion
+
+  # The collection of pure functions for converting constants
+  # to corresponding path names.
+  #
+  # @api private
+  #
+  module Inflector
+
+    extend ::Transproc::Registry
+
+    # @private
+    def to_snake(name)
+      name.gsub(/([a-z])([A-Z])/, '\1_\2').gsub(/_+/, "_").downcase
+    end
+
+    # @private
+    def to_path(name)
+      name.split(%r{\:\:|-|/}).reject(&:empty?).join("/")
+    end
+
+    # Converts the name of the constant to the corresponding path
+    #
+    # @example
+    #   fn = Inflector[:to_snake_path]
+    #   fn["::Foo::BarBaz"]
+    #   # => "foo/bar_baz"
+    #
+    # @param [String] name The name of the constant
+    #
+    # @return [String] The path
+    #
+    def to_snake_path(name)
+      to_path(to_snake(name))
+    end
+
+  end # module Inflector
+
+end # module Assertion

data/lib/assertion/transprocs/list.rb

@@ -0,0 +1,30 @@
+module Assertion
+
+  # The collection of pure functions for converting arrays
+  #
+  # @api private
+  #
+  module List
+
+    extend ::Transproc::Registry
+
+    # Converts the nested array of strings and symbols into the flat
+    # array of unique symbols
+    #
+    # @example
+    #   fn = List[:symbolize]
+    #   source = [:foo, ["foo", "bar"], :bar, "baz"]
+    #   fn[source]
+    #   # => [:foo, :bar, :baz]
+    #
+    # @param [Array<String, Symbol, Array>] array
+    #
+    # @return [Array<Symbol>]
+    #
+    def symbolize(array)
+      array.flatten.map(&:to_sym).uniq
+    end
+
+  end # module List
+
+end # module Assertion

data/lib/assertion/version.rb

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

data/spec/integration/assertion_spec.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+describe Assertion do
+
+  let(:load_path) { Dir[File.expand_path "../*.yml", __FILE__] }
+
+  around do |example|
+    old_locale, I18n.locale = I18n.locale, :en
+    old_path, I18n.load_path = I18n.load_path, load_path
+    I18n.backend.load_translations
+
+    example.run
+
+    I18n.locale    = old_locale
+    I18n.load_path = old_path
+  end
+
+  it "works" do
+    IsMale = Assertion.about :name, :gender do
+      gender == :male
+    end
+
+    IsAdult = Assertion.about :name, :age do
+      age.to_i >= 18
+    end
+
+    jane = { name: "Jane", gender: :female, age: 19 }
+
+    jane_is_a_male   = IsMale[jane]
+    jane_is_a_female = IsMale.not[jane]
+    jane_is_an_adult = IsAdult[jane]
+    jane_is_a_child  = IsAdult.not[jane]
+
+    jane_is_a_women  = jane_is_a_female & jane_is_an_adult
+    expect(jane_is_a_women).to be_valid
+    expect { jane_is_a_women.validate! }.not_to raise_error
+
+    jane_is_a_boy = jane_is_a_male & jane_is_a_child
+    expect(jane_is_a_boy).not_to be_valid
+    expect(jane_is_a_boy.messages)
+      .to eql ["Jane is a female", "Jane is an adult (age 19)"]
+    expect { jane_is_a_boy.validate! }.to raise_error Assertion::InvalidError
+  end
+
+  after do
+    Object.send :remove_const, :IsAdult
+    Object.send :remove_const, :IsMale
+  end
+
+end # describe Assertion