policy 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 04a2d9deed6be482ce3cb6ce53a37794c63f9307
+  data.tar.gz: a3390592a7f9da64d2312d1deb2f252845145dd7
+SHA512:
+  metadata.gz: 822eb64145e1bd5b1eb50db79e806ad4bdcf4030cedada995854402331532ae62941d0eec77947555af0aeb201484698e502e3d14c434cd10ca09f3b14022ac3
+  data.tar.gz: df4bd42ef984ce5daf5465af0646536ff3a2683512f1e977d5482e12032a5380e9b447f5709633818de33c7dcfcea051befbf0942fa2dfe4616ac7e165a6b4d2

data/.coveralls.yml

@@ -0,0 +1,2 @@
+---
+service_name: travis-ci

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/.rubocop.yml

@@ -0,0 +1,2 @@
+---
+inherit_from: "./config/metrics/rubocop.yml"

data/.travis.yml

@@ -0,0 +1,18 @@
+---
+language: ruby
+bundler_args: --without=extras
+script: rake test:coverage
+matrix:
+  include:
+    - rvm: '2.0'
+      env: 'activemodel=3.1'
+    - rvm: 'ruby-head'
+      env: 'activemodel=master'
+    - rvm: 'rbx-2 --2.0'
+      env: 'activemodel=3.1'
+    - rvm: 'rbx-2 --2.0'
+      env: 'activemodel=master'
+    - rvm: 'jruby-20mode'
+      env: 'activemodel=3.1'
+    - rvm: 'jruby-head-20mode'
+      env: 'activemodel=master'

data/.yardopts

@@ -0,0 +1,3 @@
+--asset LICENSE
+--exclude lib/policies/version.rb
+--out doc/api

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+gemspec
+
+group :development, :test do
+  gem "hexx-suit", "~> 1.3", require: false
+end

data/Guardfile

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+guard :rspec, cmd: "bundle exec rspec" do
+
+  watch("spec/spec_helper.rb") { "spec" }
+
+  watch("lib/policy.rb") { "spec" }
+
+  watch(/^lib(.+)\.rb$/) do |m|
+    "spec/tests#{ m[1] }_spec.rb"
+  end
+
+  watch(/^spec.+_spec\.rb$/)
+
+end # guard :rspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2015 Andrew Kozin, https://github.com/nepalez
+
+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,223 @@
+Policy
+======
+
+[![Gem Version](https://img.shields.io/gem/v/policy.svg?style=flat)][gem]
+[![Build Status](https://img.shields.io/travis/nepalez/policy/master.svg?style=flat)][travis]
+[![Dependency Status](https://img.shields.io/gemnasium/nepalez/policy.svg?style=flat)][gemnasium]
+[![Code Climate](https://img.shields.io/codeclimate/github/nepalez/policy.svg?style=flat)][codeclimate]
+[![Coverage](https://img.shields.io/coveralls/nepalez/policy.svg?style=flat)][coveralls]
+[![Inline docs](http://inch-ci.org/github/nepalez/policy.svg)][inch]
+
+[codeclimate]: https://codeclimate.com/github/nepalez/policy
+[coveralls]: https://coveralls.io/r/nepalez/policy
+[gem]: https://rubygems.org/gems/policy
+[gemnasium]: https://gemnasium.com/nepalez/policy
+[travis]: https://travis-ci.org/nepalez/policy
+[inch]: https://inch-ci.org/github/nepalez/policy
+
+A tiny library to implement a **Policy Object pattern**.
+
+The gem was inspired by:
+* the CodeClimate's blog post "[7 ways to decompose fat ActiveRecord module]" 
+* the part "How to Model Less Obvious Kinds of Concept" from the "[Domain-Driven Design]" by Eric Evans.
+
+A **Policy Object** encapsulates a business rule in isolation from objects (such as entities or services) following it.
+
+This separation provides a number of benefits:
+
+* It makes business rules **explicit** instead of spreading and hiding them inside application objects.
+* It makes the rules **reusable** in various context (think of the *transaction consistency* both in bank transfers and cach machine withdrawals).
+* It allows definition of rules for **numerous attributes** that should correspond to each other in some way.
+* It makes complex rules **testable** in isolation from even more complex objects.
+
+[7 ways to decompose fat ActiveRecord module]: http://blog.codeclimate.com/blog/2012/10/17/7-ways-to-decompose-fat-activerecord-models/
+[Domain-Driven Design]: http://www.amazon.com/dp/B00794TAUG/
+
+# Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "policy"
+```
+
+And then execute:
+
+```
+$ bundle
+```
+
+Or install it yourself as:
+
+```
+$ gem install policy
+```
+
+# Usage
+
+## The Model for Illustration
+
+Suppose an over-simplified model of bank account transactions and account-to-account transfers.
+
+```ruby
+# The account transaction (either enrollment or witdrawal)
+class Transaction < Struct.new(:sum); end
+
+# The transfer, connecting two separate transactions
+# (maybe this isn't an optimal model, but helpful for the subject)
+class Transfer < Struct.new(:withdrawal, :enrollment); end
+```
+
+What we need is to apply the simple policy (invariant):
+
+**The sum of withdrawal's and enrollment's sums should be 0.**
+
+Let's do it with Policy Objects! 
+
+## Policy Declaration
+
+Define policies with a list of necessary attributes like using [Struct].
+
+Tnen use [ActiveModel::Validations] methods to describe its rules:
+
+```ruby
+# An arbitrary namespace for financial policies
+module Policies::Financial
+
+  # Withdrawal from one account should be equal to enrollment to another
+  class Consistency < Policy.new(:withdrawal, :enrollment)
+
+    validates :withdrawal, :enrollment, presence: true
+    validates :total_sum, numericality: { equal_to: 0 }
+
+    private
+
+    def total_sum
+      withdrawal.sum + enrollment.sum
+    end
+  end
+end
+```
+
+Note a policy knows nothing about the complex nature of its attributes until their quack like transactions with `#sum` method defined.
+
+[Struct]: http://ruby-doc.org//core-2.2.0/Struct.html
+[ActiveModel::Validations]: http://apidock.com/rails/ActiveModel/Validations
+
+## Following a Policy
+
+Include the `Policy::Follower` module to the class and apply policies to corresponding attributes with `follow_policy` **class** method.
+
+```ruby
+class Transfer < Struct.new(:withdrawal, :enrollment)
+  include Policy::Follower # also includes ActiveModel::Validations
+
+  follow_policy Policies::Financial::Consistency, :withdrawal, :enrollment
+end
+```
+
+The order of attributes should correspond to the policy definition.
+
+You can swap attributes (this is ok for our example)...
+
+```ruby
+follow_policy Policies::Financial::Consistency, :enrollment, :withdrawal
+```
+
+...or use the same attribute several times when necessary (not in our example, though):
+
+```ruby
+follow_policy Policies::Financial::Consistency, :withdrawal, :withdrawal
+```
+
+Applied policies can be grouped by namespaces (useful when the object should follow many policies):
+
+```ruby
+use_policies Policies::Financial do
+  follow_policy :Consistency, :withdrawal, :enrollment
+end
+```
+
+## Policies Verification
+
+To verify object use `#follow_policies?` or `#follow_policies!` **instance** methods.
+
+```ruby
+Transaction = Struct.new(:account, :sum)
+withdrawal  = Transaction.new(account_1, -100)
+enrollment  = Transaction.new(account_2, 1000)
+
+transfer = Transfer.new withdrawal, enrollment
+
+transfer.follow_policies?
+# => false
+
+transfer.follow_policies!
+# => raises <Policy::ViolationError>
+```
+
+The policies are verified one-by-one until the first break - in just the same order they were declared.
+
+### Asyncronous Verification
+
+Define names for policies using `as:` option. The names should be unique in the class' scope:
+
+```ruby
+class Transfer < Struct.new(:withdrawal, :enrollment)
+  include Policy::Follower
+
+  use_policies Policies::Financial do
+    follow_policy :Consistency, :withdrawal, :enrollment, as: :consistency
+  end
+end
+```
+
+Check policies by names (you can also use singular forms `follow_policy?` and `follow_policy!`):
+
+```ruby
+# Checks only consistency and skips all other policies
+transaction.follow_policy? :consistency
+transaction.follow_policy! :consistency
+```
+
+The set of policies can be checked at once:
+
+```ruby
+transaction.follow_policies? :consistency, ...
+```
+
+Now the policies are verified one-by-one in **given order** (it may differ from the order of policies declaration) until the first break.
+
+# Compatibility
+
+Tested under rubies, compatible with MRI 2.0+:
+
+* MRI rubies 2.0+
+* Rubinius 2+ (2.0+ mode)
+* JRuby 1.7+ (2.0+ mode)
+
+Rubies with API 1.9 are not supported.
+
+Uses [ActiveModel::Validations] - tested for 3.1+
+
+Uses [RSpec] 3.0+ for testing and [hexx-suit] for dev/test tools collection.
+
+[RSpec]: http://rspec.info/
+[hexx-suit]: https://github.com/nepalez/hexx-suit/
+[ActiveModel::Validations]: http://apidock.com/rails/v3.1.0/ActiveModel/Validations
+
+# Contributing
+
+* Fork the project.
+* Read the [STYLEGUIDE](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](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::RSpec :test task to default
+task default: :test

data/config/metrics/STYLEGUIDE

@@ -0,0 +1,231 @@
+= 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;
+  - UPDATE  - for backward-compatible changes of existing code;
+  - 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.
+
+* Try to 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,14 @@
+---
+folders: # The list of folders to be used by any metric.
+- lib
+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: 150
+ClassNameCheck:
+  pattern: !ruby/regexp /^[A-Z][a-zA-Z0-9]*$/
+ClassVariableCheck:
+CyclomaticComplexityBlockCheck:
+  complexity: 2
+CyclomaticComplexityMethodCheck:
+  complexity: 2
+EmptyRescueBodyCheck:
+ForLoopCheck:
+MethodLineCountCheck:
+  line_count: 5
+MethodNameCheck:
+  pattern: !ruby/regexp /^[\||\^|\&|\!]$|^[_a-z<>=\[|+-\/\*`]+[_a-z0-9_<>=~@\[\]]*[=!\?]?$/
+ModuleLineCountCheck:
+  line_count: 150
+ModuleNameCheck:
+  pattern: !ruby/regexp /^[A-Z][a-zA-Z0-9]*$/
+ParameterNumberCheck:
+  parameter_count: 4