verifier 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9dfc1bf33da69d7167f3d952b11ea361d290985e
+  data.tar.gz: d3cbb113f342c8fb4720761f6ef9092943e561ce
+SHA512:
+  metadata.gz: 2ee5faa714966ff475c60f14ccf7003650cd8aa22061f911c092f35a600846d4d1401ba9dde5f534822586ab0387207b9842424e8e83e2e9ce9016a5ab80fdb8
+  data.tar.gz: f7963fb3309f2ec7d424977269df7d87a6278d069b6ca83cdcdf38fc999e3895019c8f8b795eb54058913e5de2687ac099f8170ab5bd9caf09e40d821199898b

data/.metrics

@@ -0,0 +1,5 @@
+# Settings for metric_fu and its packages are collected in the `config/metrics`
+# and loaded by the Hexx::Suit::Metrics::MetricFu.
+
+require "hexx-suit"
+Hexx::Suit::Metrics::MetricFu.load

data/.rspec

@@ -0,0 +1,2 @@
+--require spec_helper
+--color

data/.yardopts

@@ -0,0 +1,2 @@
+--asset LICENSE
+--exclude lib/**/version.rb

data/Guardfile

@@ -0,0 +1,6 @@
+guard :rspec, cmd: "bundle exec rspec" do
+  watch "spec/tests/**/*_spec.rb"
+  watch("lib/verifier.rb") { "spec/tests/lib/verifier_spec.rb" }
+  watch("spec/spec_helper.rb")  { "spec" }
+  watch("lib/verifier.rb") { "spec" }
+end

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2015 Andrew Kozin, andrew.kozin@gmail.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,126 @@
+# Verifier
+
+[![Gem Version](https://img.shields.io/gem/v/verifier.svg?style=flat)][gem]
+[![Build Status](https://img.shields.io/travis/nepalez/verifier/master.svg?style=flat)][travis]
+[![Dependency Status](https://img.shields.io/gemnasium/nepalez/verifier.svg?style=flat)][gemnasium]
+[![Code Climate](https://img.shields.io/codeclimate/coverage/github/nepalez/verifier.svg?style=flat)][codeclimate]
+[![Coverage](https://img.shields.io/coveralls/nepalez/verifier.svg?style=flat)][coveralls]
+[![License](https://img.shields.io/badge/license-MIT-blue.svg?style=flat)](file:LICENSE)
+
+[gem]: https://rubygems.org/gems/verifier
+[travis]: https://travis-ci.org/nepalez/verifier
+[gemnasium]: https://gemnasium.com/nepalez/verifier
+[codeclimate]: https://codeclimate.com/github/nepalez/verifier
+[coveralls]: https://coveralls.io/r/nepalez/verifier
+
+The library to verify variables are satisfy given condititions and raise `ArgumentError` otherwise.
+
+Defines a `#verify` instance method with a block to be yielded in a variable's scope and raised an error if the block returns false or fails.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+    gem "verifier"
+```
+
+And then execute:
+
+```
+    $ bundle
+```
+
+Or install it yourself as:
+
+```
+    $ gem install verifier
+```
+
+## Usage
+
+Include the module into class or Method to use it in the instance methods, or extend the class to check verifier of the class methods.
+
+```ruby
+require "verifier"
+
+class Greeter
+  include Verifier
+end
+```
+
+This will define the `#verify` instance method.
+
+Call it from your method with the names of the verified variable and the condition, and the block to be called **in the scope of a value, returned by the method**.
+
+```ruby
+class Greeter
+  # ...
+  def hello(name)
+    verify(:name, :long_enough) { count > 1 }
+    "Hello, #{ name }!"
+  end
+end
+```
+
+Then define i18n translations for error messages:
+
+```yaml
+# config/locales/en.yml
+---
+en:
+  verifier: # the module's scope
+    greeter:  # the class name
+      instance: # the scope for the method
+        # the message to be raised when the method raises an exception
+        fails: "The method fails: %{value}"
+        # the message to be raised when the method isn't defined
+        undefined: "The method undefined: %{value}"
+        name: # the name of the method to be verified
+          # the message to be raised when the block fails or returns false
+          long_enough: "The name to greet seems damn short: %{value}"
+```
+
+The block is yielded **in the scope of a corresponding variable**.
+
+An `ArgumentError` will be raised in any case when:
+* the verified method is undefined;
+* the method raises an exception;
+* the block raises an exception;
+* the block returns a value, whose negation is `true`
+  (see the motivation [below]{#negation}).
+
+```ruby
+greeter = Greeter.new
+
+greeter.hello "Al"
+# => "Hello, Al!"
+
+greeter.hello "A"
+# => <ArgumentError @message="The name to greet seems damn short: A" ...>
+```
+
+## Compatibility
+
+Tested under MRI rubies >= 2.1
+
+RSpec 3.0+ used for testing
+
+Collection of used testing, debugging and code metric tools is defined
+in the [hexx-suit](https://github.com/nepalez/hexx-suit) gem.
+
+## Contributing
+
+* Fork the project.
+* Read the [styleguide](file:./config/metrics/STYLEGUIDE).
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with Rakefile or version
+  (if you want to have your own version, that is fine but bump version
+  in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+## License
+
+See [MIT LICENSE](file:LICENSE).

data/Rakefile

@@ -0,0 +1,17 @@
+# encoding: utf-8
+begin
+  require "bundler/setup"
+rescue LoadError
+  puts "You must `gem install bundler` and `bundle install` to run rake tasks"
+  exit
+end
+
+# Loads bundler tasks
+Bundler::GemHelper.install_tasks
+
+# Loads the Hexx::Suit and its tasks
+require "hexx-suit"
+Hexx::Suit.install_tasks
+
+# Sets the Hexx::Suit :test task to default
+task default: "check:coverage:run"

data/config/metrics/STYLEGUIDE

@@ -0,0 +1,230 @@
+= Ruby Style Guide
+
+Adapted from Dan Kubb's Ruby Style Guide
+https://github.com/dkubb/styleguide/blob/master/RUBY-STYLE
+
+== Commiting:
+
+* Write descriptive commit messages, following the pattern:
+
+    [TYPE] name
+
+    The message, describing the changes being made
+
+* Use the types below to mark commits:
+
+  - FEATURE - for adding new features, or backward-compatible changes;
+  - CHANGE - for backward-incompatible changes;
+  - BUG FIX - for fixing bugs;
+  - REFACTORING - for other changes of the code not affecting the API;
+  - OTHER - for changes in documentaton, metrics etc, not touching the code;
+  - VERSION - for version changes.
+
+* Always separate commits of different types (such as FEATURE and CHANGE).
+
+* Try to separate various features from each other.
+
+* Include specification to the same commit as the code.
+
+* Run all tests before making a commit.
+  Never commit the code that break unit tests.
+
+* Use metric (run `rake check`) before making a commit.
+
+* Do refactoring before making a commit. Best writing is rewriting.
+
+* Follow semantic versioning.
+
+    http://semver.org/
+
+* For versions name the commit after a version number, following the pattern:
+
+    VERSION 1.0.0-rc2
+
+
+== Formatting:
+
+* Use UTF-8. Declare encoding in the first line of every file.
+
+    # encoding: utf-8
+
+* Use 2 space indent, no tabs.
+
+* Use Unix-style line endings.
+
+* Use spaces around operators, after commas, colons and semicolons,
+  around { and before }.
+
+* No spaces after (, [ and before ], ).
+
+* Align `when` and `else` with `case`.
+
+* Use an empty line before the return value of a method (unless it
+  only has one line), and an empty line between defs.
+
+* Use empty lines to break up a long method into logical paragraphs.
+
+* Keep lines fewer than 80 characters.
+
+* Strip trailing whitespace.
+
+
+== Syntax:
+
+* Write for 2.0.
+
+* Use double quotes
+  
+    http://viget.com/extend/just-use-double-quoted-ruby-strings
+
+* Use def with parentheses when there are arguments.
+
+* Never use for, unless you exactly know why.
+
+* Never use then, except in case statements.
+
+* Use when x then ... for one-line cases.
+
+* Use &&/|| for boolean expressions, and/or for control flow. (Rule
+  of thumb: If you have to use outer parentheses, you are using the
+  wrong operators.)
+
+* Avoid double negation (!!), unless Null Objects are expected.
+  
+    http://devblog.avdi.org/2011/05/30/null-objects-and-falsiness
+
+* Avoid multiline ?:, use if.
+
+* Use {...} when defining blocks on one line. Use do...end for multiline
+  blocks.
+
+* Avoid return where not required.
+
+* Use ||= freely.
+
+* Use OO regexps, and avoid =~ $0-9, $~, $` and $' when possible.
+
+* Do not use Enumerable#inject when the "memo" object does not change between
+  iterations, use Enumerable#each_with_object instead (in ruby 1.9,
+  active_support and backports).
+
+* Prefer ENV.fetch to ENV[] syntax.
+  Prefer block syntax for ENV.fetch to usage of the second argument.
+
+
+== Naming:
+
+* Use snake_case for methods.
+
+* Use CamelCase for classes and modules. (Keep acronyms like HTTP,
+  RFC, XML uppercase.)
+
+* Use SCREAMING_SNAKE_CASE for other constants.
+
+* Do not use single letter variable names. Avoid uncommunicative names.
+
+* Use consistent variable names. Try to keep the variable names close
+  to the object class name.
+
+* Use names prefixed with _ for unused variables.
+
+* When defining a predicate method that compares against another object of
+  a similar type, name the argument "other".
+
+* Prefer map over collect, detect over find, select over find_all.
+
+* Use def self.method to define singleton methods.
+
+* Avoid alias when alias_method will do.
+
+
+== Comments:
+
+* Use YARD and its conventions for API documentation. Don't put an
+  empty line between the comment block and the def.
+
+* Comments longer than a word are capitalized and use punctuation.
+  Use one space after periods.
+
+* Avoid superfluous comments.
+
+
+== Code structuring:
+
+* Break code into packages, decoupled from the environment.
+
+* Wrap packages into gems.
+
+* Inject dependencies explicitly.
+  Leave all outer references on the border of any package. Inside
+  the package use internal references only.
+
+* Follow SOLID principles.
+
+    http://en.wikipedia.org/wiki/SOLID_(object-oriented_design)
+
+* Only give a method one purpose for existing. If you pass in a boolean
+  to a method, what you're saying is that this method has two different
+  behaviours. Just split it into two single purpose methods. If you have
+  to use the words "AND" or "OR" to describe what the method does it
+  probably does too much.
+
+* Avoid long methods.
+  Try to keep them at no more than 6 lines long, and preferably 4 or less.
+
+  If sections of a method are logically separate by blank lines, then
+  that's probably a sign that those sections should be split into separate
+  methods.
+
+* Avoid hashes-as-optional-parameters. Does the method do too much?
+
+* Avoid long parameter lists.
+
+* Add "global" methods to Kernel (if you have to) and make them private.
+
+* Use OptionParser for parsing complex command line options and
+  ruby -s for trivial command line options.
+
+* Avoid needless metaprogramming.
+
+* Always freeze objects assigned to constants.
+
+
+== General:
+
+* Code in a functional way, avoid mutation when it makes sense.
+
+* Try to have methods either return the state of the object and have
+  no side effects, or return self and have side effects. This is
+  otherwise known as Command-query separation (CQS):
+
+    http://en.wikipedia.org/wiki/Command-query_separation
+
+* Do not mutate arguments unless that is the purpose of the method.
+
+* Try following TRUE heuristics by Sandi Metz
+
+    http://designisrefactoring.com/2015/02/08/introducing-sandi-metz-true/
+
+* Do not mess around in core classes when writing libraries.
+  Namespace your code inside the modules, or wrap core classes to
+  decorators of your own.
+
+* Do not program defensively.
+  
+    http://www.erlang.se/doc/programming_rules.shtml#HDR11
+
+* Keep the code simple.
+
+* Don't overdesign.
+
+* Don't underdesign.
+
+* Avoid bugs.
+
+* Read other style guides and apply the parts that don't dissent with
+  this list.
+
+* Be consistent.
+
+* Use common sense.

data/config/metrics/cane.yml

@@ -0,0 +1,5 @@
+---
+abc_max: "10"
+line_length: "80"
+no_doc: "y"
+no_readme: "y"

data/config/metrics/churn.yml

@@ -0,0 +1,6 @@
+---
+ignore_files:
+- spec
+- config
+minimum_churn_count: 0
+start_date: "1 year ago"

data/config/metrics/flay.yml

@@ -0,0 +1,2 @@
+---
+minimum_score: 5

data/config/metrics/metric_fu.yml

@@ -0,0 +1,15 @@
+---
+folders: # The list of folders to be used by any metric.
+- lib
+- app
+metrics: # The list of allowed metrics. The other metrics are disabled.
+- cane
+- churn
+- flay
+- flog
+- reek
+- roodi
+- saikuro
+format: html
+output: tmp/metric_fu
+verbose: false

data/config/metrics/pippi.yml

@@ -0,0 +1,3 @@
+---
+checkset: basic
+output: "tmp/pippi/output.log"

data/config/metrics/reek.yml

@@ -0,0 +1 @@
+---

data/config/metrics/roodi.yml

@@ -0,0 +1,24 @@
+---
+AssignmentInConditionalCheck:
+CaseMissingElseCheck:
+ClassLineCountCheck:
+  line_count: 300
+ClassNameCheck:
+  pattern: !ruby/regexp /^[A-Z][a-zA-Z0-9]*$/
+ClassVariableCheck:
+CyclomaticComplexityBlockCheck:
+  complexity: 4
+CyclomaticComplexityMethodCheck:
+  complexity: 8
+EmptyRescueBodyCheck:
+ForLoopCheck:
+MethodLineCountCheck:
+  line_count: 20
+MethodNameCheck:
+  pattern: !ruby/regexp /^[\||\^|\&|\!]$|^[_a-z<>=\[|+-\/\*`]+[_a-z0-9_<>=~@\[\]]*[=!\?]?$/
+ModuleLineCountCheck:
+  line_count: 300
+ModuleNameCheck:
+  pattern: !ruby/regexp /^[A-Z][a-zA-Z0-9]*$/
+ParameterNumberCheck:
+  parameter_count: 5

data/config/metrics/rubocop.yml

@@ -0,0 +1,79 @@
+---
+# settings added by the 'hexx-suit' module
+# output: "tmp/rubocop"
+# format: "html"
+
+AllCops:
+  Exclude:
+    - '**/db/schema.rb'
+
+Lint/HandleExceptions:
+  Exclude:
+    - 'spec/**/*'
+
+Lint/RescueException:
+  Exclude:
+    - 'spec/**/*'
+
+Metrics/ClassLength:
+  Exclude:
+    - 'lib/**/generator*'
+
+Style/AccessorMethodName:
+  Exclude:
+    - 'spec/**/*'
+
+Style/AsciiComments:
+  Enabled: false
+
+Style/ClassAndModuleChildren:
+  Exclude:
+    - 'spec/**/*'
+
+Style/Documentation:
+  Exclude:
+    - 'lib/**/version.rb'
+    - 'spec/**/*'
+
+Style/EmptyLinesAroundBlockBody:
+  Enabled: false
+
+Style/EmptyLinesAroundClassBody:
+  Enabled: false
+
+Style/EmptyLinesAroundMethodBody:
+  Enabled: false
+
+Style/EmptyLinesAroundModuleBody:
+  Enabled: false
+
+Style/EmptyLineBetweenDefs:
+  Enabled: false
+
+Style/FileName:
+  Enabled: false
+
+Style/RaiseArgs:
+  EnforcedStyle: compact
+
+Style/SingleLineMethods:
+  Exclude:
+    - 'spec/**/*'
+
+Style/SingleSpaceBeforeFirstArg:
+  Enabled: false
+
+Style/SpecialGlobalVars:
+  Exclude:
+    - 'Gemfile'
+    - '*.gemspec'
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Stype/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+
+Style/TrivialAccessors:
+  Exclude:
+    - 'spec/**/*'

data/config/metrics/saikuro.yml

@@ -0,0 +1,3 @@
+---
+warn_cyclo:  4
+error_cyclo: 6

data/config/metrics/simplecov.yml

@@ -0,0 +1,8 @@
+---
+output: tmp/coverage
+filters: # The list of paths to be excluded from coverage checkup
+- "spec/"
+- "config/"
+groups: # The list of groups to be shown in the coverage report
+  Libraries: "lib/"
+  Application: "app/"

data/config/metrics/yardstick.yml

@@ -0,0 +1,37 @@
+---
+# Settings added by the 'hexx-suit' gem
+output: "tmp/yardstick/output.log"
+path: "lib/**/*.rb"
+rules:
+  ApiTag::Presence:
+    enabled: false
+    exclude: []
+  ApiTag::Inclusion:
+    enabled: true
+    exclude: []
+  ApiTag::ProtectedMethod:
+    enabled: true
+    exclude: []
+  ApiTag::PrivateMethod:
+    enabled: false
+    exclude: []
+  ExampleTag:
+    enabled: true
+    exclude: []
+  ReturnTag:
+    enabled: true
+    exclude: []
+  Summary::Presence:
+    enabled: true
+    exclude: []
+  Summary::Length:
+    enabled: true
+    exclude: []
+  Summary::Delimiter:
+    enabled: true
+    exclude: []
+  Summary::SingleLine:
+    enabled: true
+    exclude: []
+threshold: 100
+verbose: false

data/lib/verifier.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+%w(
+  exceptions
+  scope
+  verification
+).each { |name| require_relative "verifier/#{ name }" }
+
+# Defines {#verify} method to check variables
+#
+# @example
+#   class Greeter
+#     include Verifier
+#
+#     def hello(name)
+#       verify(:name, :long_enough) { count > 1 }
+#       "Hello, #{ name }!"
+#     end
+#   end
+#
+#   greeter = Greeter.new
+#   greeter.hello "Ali"
+#   # => "Hello, Ali!"
+#
+#   greeter.hello "X"
+#   # => <Verifier::Invalid ...>
+module Verifier
+
+  # Runs a verification
+  #
+  # @param [Symbol] method
+  #   the name of the method to be verified
+  # @param [Symbol] name
+  #   the name of verification
+  # @param [Proc] block
+  #
+  # @yield block in the scope of a value returned by the method
+  #
+  # @raise  [Verifier::MethodNotDefined]
+  #   if the method not defined
+  # @raise  [Verifier::MethodFails]
+  #   it calling the method raises a +StandardError+
+  # @raise  [Verifier::Invalid]
+  #   if the block fails or returns a value whose negation is truthy
+  #
+  # @return [undefined]
+  #
+  # @api public
+  def verify(method, name, &block)
+    Verification.run(self, method, name, &block)
+  end
+end

data/lib/verifier/exceptions.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+# Exceptions raised by Verifier#verify method
+module Verifier
+
+  # Exception raised when a verification fails
+  Invalid = Class.new ::RuntimeError
+
+  # Exception raised when calling a verified method raises a StandardError
+  MethodFails = Class.new ::RuntimeError
+
+  # Exception raised when a verified method is not defined
+  MethodNotDefined = Class.new ::NameError
+end

data/lib/verifier/scope.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+require "extlib"
+
+module Verifier
+
+  # Provides the scope for I18n translations of verification errors
+  #
+  # @api private
+  class Scope
+
+    # Initializes a new instance
+    #
+    # @param [Object] object
+    #   the object whose method should be verified
+    # @param [Symbol] method
+    #   the name of the method to be verified
+    #
+    # @return [undefined]
+    def initialize(object, method)
+      @object, @method = object, method
+    end
+
+    # Returns a scope for all translations of {#object} verification errors
+    #
+    # @return [Array<Symbol>]
+    def short
+      @short ||= [:verifier, name, type]
+    end
+
+    # Returns a scope for translations of {#method} verification errors
+    #
+    # @return [Array<Symbol>]
+    def full
+      @full ||= short + [method.to_sym]
+    end
+
+    # Returns a tag (# or .) for the method
+    #
+    # @return [<String>]
+    def tag
+      (type == :class) ? "." : "#"
+    end
+
+    private
+
+    attr_reader :object, :method
+
+    def type
+      @type ||= object.is_a?(Class) ? :class : :instance
+    end
+
+    def name
+      @name ||= object_class_name.split("::").map(&:snake_case).join("/").to_sym
+    end
+
+    def object_class_name
+      object.class.name
+    end
+  end
+end

data/lib/verifier/verification.rb

@@ -0,0 +1,125 @@
+# encoding: utf-8
+
+module Verifier
+
+  # Verification runner
+  #
+  # @api private
+  class Verification
+
+    # Initializes a verification object
+    #
+    # @param [Object] object
+    #   the object whose method should be verified
+    # @param [Symbol] variable
+    #   the name of the variable to be verified
+    # @param [Symbol] name
+    #   the name of verification
+    # @param [Proc] block
+    #
+    # @return [undefined]
+    def initialize(object, variable, name, &block)
+      fail SyntaxError.new "No block given" unless block_given?
+      @object, @variable, @name, @block = object, variable, name, block
+    end
+
+    # Runs a verification
+    #
+    # @yield block in the scope of a value returned by the {#variable}
+    #
+    # @raise  [Verifier::MethodNotDefined]
+    #   if the {#variable} not defined by {#object}
+    # @raise  [Verifier::MethodFails]
+    #   it calling the {#variable} raises a +StandardError+
+    # @raise  [Verifier::Invalid]
+    #   if the block fails or returns a value whose negation is truthy
+    #
+    # @return [undefined]
+    def run
+      check_method_existence
+      check_condition
+    end
+
+    # Constructs and runs a verification object
+    #
+    # @param  (see #initialize)
+    #
+    # @raise  (see #run)
+    #
+    # @return (see #run)
+    def self.run(object, variable, name, &block)
+      send(:new, object, variable, name, &block).run
+    end
+
+    # @note
+    #   The class has a private constructor. Use {.run} method instead.
+    private_class_method :new
+
+    private
+
+    attr_reader :object, :variable, :name, :block
+
+    def check_method_existence
+      fail(undefined) unless object.respond_to?(variable)
+    end
+
+    def value
+      @value ||= object.send(variable)
+    rescue
+      raise method_fails
+    end
+
+    def check_condition
+      fail unless value.instance_eval(&block)
+    rescue
+      raise invalid
+    end
+
+    # Exceptions to be raised
+
+    def undefined
+      MethodNotDefined.new translate(
+        :undefined,
+        scope:   scope.short,
+        value:   variable,
+        default: "Method not defined: #{ method_name }"
+      )
+    end
+
+    def method_fails
+      MethodFails.new translate(
+        :fails,
+        scope:   scope.short,
+        value:   variable,
+        default: "Method fails: #{ method_name }"
+      )
+    end
+
+    def invalid
+      Invalid.new translate(
+        name,
+        scope:   scope.full,
+        value:   value,
+        default: default_message
+      )
+    end
+
+    def default_message
+      "#{ method_name } verification failed: #{ value.inspect } not #{ name }"
+    end
+
+    # Translation helpers
+
+    def method_name
+      @method_name ||= "#{ object.class.name }#{ scope.tag }#{ variable }"
+    end
+
+    def scope
+      @scope ||= Scope.new(object, variable)
+    end
+
+    def translate(name, options = {})
+      I18n.t(name, options)
+    end
+  end
+end

data/lib/verifier/version.rb

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

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+# Loads the RSpec test suit.
+require "hexx-suit"
+Hexx::Suit.load_metrics_for(self)
+
+# Loads the gem.
+require "verifier"

data/spec/verifier/invalid_spec.rb

@@ -0,0 +1,6 @@
+describe Verifier::Invalid do
+
+  it "is a RuntimeError" do
+    expect(described_class.superclass).to eq ::RuntimeError
+  end
+end

data/spec/verifier/method_fails_spec.rb

@@ -0,0 +1,6 @@
+describe Verifier::MethodFails do
+
+  it "is a RuntimeError" do
+    expect(described_class.superclass).to eq ::RuntimeError
+  end
+end

data/spec/verifier/method_not_defined_spec.rb

@@ -0,0 +1,6 @@
+describe Verifier::MethodNotDefined do
+
+  it "is a NameError" do
+    expect(described_class.superclass).to eq ::NameError
+  end
+end

data/spec/verifier/verify_spec.rb

@@ -0,0 +1,135 @@
+describe Verifier, "#verify" do
+
+  # subject is an instance of class, that includes Verifier and has #foo method
+  before  { Test = Class.new                          }
+  before  { Test.include described_class              }
+  before  { Test.send(:define_method, :foo) { "foo" } }
+  subject { Test.new                                  }
+  after   { Object.send :remove_const, :Test          }
+
+  it "is defined" do
+    expect(subject).to respond_to(:verify).with(2).arguments
+  end
+
+  context "when a block isn't given" do
+
+    it "raises SyntaxError" do
+      expect { subject.verify(:foo, :valid) }.to raise_error SyntaxError
+    end
+  end
+
+  context "when a method is not defined" do
+
+    it "raises Verifier::MethodNotDefined" do
+      expect { subject.verify(:bar, :valid) { true } }
+        .to raise_error Verifier::MethodNotDefined
+    end
+
+    it "displays proper error message" do
+      expected_message = "Method not defined: Test#bar"
+
+      begin
+        subject.verify(:bar, :valid) { true }
+      rescue => error
+        expect(error.message).to eq expected_message
+      end
+    end
+  end
+
+  context "when a method raises RuntimeError" do
+
+    before { Test.send(:define_method, :bar) { fail } }
+
+    it "raises Verifier::MethodFails" do
+      expect { subject.verify(:bar, :valid) { true } }
+        .to raise_error Verifier::MethodFails
+    end
+
+    it "displays proper error message" do
+      expected_message = "Method fails: Test#bar"
+
+      begin
+        subject.verify(:bar, :valid) { true }
+      rescue => error
+        expect(error.message).to eq expected_message
+      end
+    end
+  end
+
+  context "when a block raises RuntimeError" do
+
+    it "raises Verifier::Invalid" do
+      expect { subject.verify(:foo, :valid) { fail RuntimeError } }
+        .to raise_error Verifier::Invalid
+    end
+
+    it "displays proper error message" do
+      expected_message = "Test#foo verification failed: \"foo\" not valid"
+
+      begin
+        subject.verify(:foo, :valid) { false }
+      rescue => error
+        expect(error.message).to eq expected_message
+      end
+    end
+  end
+
+  context "when a block returns false" do
+
+    it "raises Verifier::Invalid" do
+      expect { subject.verify(:foo, :valid) { false } }
+        .to raise_error Verifier::Invalid
+    end
+
+    it "displays proper error message" do
+      expected_message = "Test#foo verification failed: \"foo\" not valid"
+
+      begin
+        subject.verify(:foo, :valid) { false }
+      rescue => error
+        expect(error.message).to eq expected_message
+      end
+    end
+  end
+
+  context "when a block returns nil" do
+
+    it "raises Verifier::Invalid" do
+      expect { subject.verify(:foo, :valid) { nil } }
+        .to raise_error Verifier::Invalid
+    end
+  end
+
+  context "when a block returns true" do
+
+    it "doesn't raise error" do
+      expect { subject.verify(:foo, :valid) { true } }.not_to raise_error
+    end
+  end
+
+  context "when negation of a block is truthy" do
+
+    let(:null) { double :null, :! => true }
+
+    it "raises Verifier::Invalid" do
+      expect { subject.verify(:foo, :valid) { null } }
+        .to raise_error Verifier::Invalid
+    end
+  end
+
+  context "when a block returns false in a variable's scope" do
+
+    it "raises Verifier::Invalid" do
+      expect { subject.verify(:foo, :valid) { self != "foo" } }
+        .to raise_error Verifier::Invalid
+    end
+  end
+
+  context "when a block returns true in a variable's scope" do
+
+    it "doesn't raise error" do
+      expect { subject.verify(:foo, :valid) { self == "foo" } }
+        .not_to raise_error
+    end
+  end
+end

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: verifier
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Andrew Kozin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: extlib
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: hexx-suit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+description: Variables verification.
+email: andrew.kozin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+- ".yardopts"
+files:
+- ".metrics"
+- ".rspec"
+- ".yardopts"
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- config/metrics/STYLEGUIDE
+- config/metrics/cane.yml
+- config/metrics/churn.yml
+- config/metrics/flay.yml
+- config/metrics/metric_fu.yml
+- config/metrics/pippi.yml
+- config/metrics/reek.yml
+- config/metrics/roodi.yml
+- config/metrics/rubocop.yml
+- config/metrics/saikuro.yml
+- config/metrics/simplecov.yml
+- config/metrics/yardstick.yml
+- lib/verifier.rb
+- lib/verifier/exceptions.rb
+- lib/verifier/scope.rb
+- lib/verifier/verification.rb
+- lib/verifier/version.rb
+- spec/spec_helper.rb
+- spec/verifier/invalid_spec.rb
+- spec/verifier/method_fails_spec.rb
+- spec/verifier/method_not_defined_spec.rb
+- spec/verifier/verify_spec.rb
+homepage: https://github.com/nepalez/verifier
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Variables verification.
+test_files:
+- ".rspec"
+- spec/verifier/verify_spec.rb
+- spec/verifier/method_fails_spec.rb
+- spec/verifier/method_not_defined_spec.rb
+- spec/verifier/invalid_spec.rb
+- spec/spec_helper.rb
+- Guardfile
+- Rakefile
+- ".metrics"
+- config/metrics/cane.yml
+- config/metrics/metric_fu.yml
+- config/metrics/simplecov.yml
+- config/metrics/yardstick.yml
+- config/metrics/flay.yml
+- config/metrics/rubocop.yml
+- config/metrics/churn.yml
+- config/metrics/saikuro.yml
+- config/metrics/reek.yml
+- config/metrics/roodi.yml
+- config/metrics/STYLEGUIDE
+- config/metrics/pippi.yml
+has_rdoc: