informator 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 88050d195612b6c522dd73ce402377bb0eef1205
+  data.tar.gz: ad5e5fad66364bcbde46b4db64a827e6348d1419
+SHA512:
+  metadata.gz: 2d14dc46cf3956d2605b9b5ca01e47596c42985c14aa2c98f28d19ef75af5109efe1dc2cd47bbec0ed2ea9113da7b96b458327eb44ea9940c2d84b8765a4d4ab
+  data.tar.gz: 9949843cdfd102984541ccd34e3cf7238e63d499279fd23f0c452adce57942d512ab8c4be8f6109a860603ad2917da6acdffecb10aecbf2d2365d6d78cc12aeb

data/.coveralls.yml

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

data/.gitignore

@@ -0,0 +1,9 @@
+*.gem
+*.lock
+.bundle/
+.yardoc/
+coverage/
+doc/
+log/
+pkg/
+tmp/

data/.metrics

@@ -0,0 +1,9 @@
+# Settings for metric_fu and its packages are collected in the `config/metrics`
+# and loaded by the Hexx::Suit::Metrics::MetricFu.
+
+begin
+  require "hexx-suit"
+  Hexx::Suit::Metrics::MetricFu.load
+rescue LoadError
+  puts "The 'hexx-suit' gem is not installed"
+end

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,15 @@
+---
+language:     ruby
+bundler_args: --without metrics
+cache:        bundler
+script:       rake test:coverage:run
+rvm:
+  - '2.1'
+  - ruby-head
+  - rbx-2 --2.1
+  - jruby-9.0.0.0.pre1
+  - jruby-head
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: jruby-head

data/.yardopts

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

data/Gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem "hexx-suit", "~> 2.2", group: :metrics if RUBY_ENGINE == "ruby"

data/Guardfile

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

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2015 Andrew Kozin (nepalez), 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,141 @@
+Informator
+==========
+
+[![Gem Version](https://img.shields.io/gem/v/informator.svg?style=flat)][gem]
+[![Build Status](https://img.shields.io/travis/nepalez/informator/master.svg?style=flat)][travis]
+[![Dependency Status](https://img.shields.io/gemnasium/nepalez/informator.svg?style=flat)][gemnasium]
+[![Code Climate](https://img.shields.io/codeclimate/github/nepalez/informator.svg?style=flat)][codeclimate]
+[![Coverage](https://img.shields.io/coveralls/nepalez/informator.svg?style=flat)][coveralls]
+[![Inline docs](http://inch-ci.org/github/nepalez/informator.svg)][inch]
+
+[codeclimate]: https://codeclimate.com/github/nepalez/informator
+[coveralls]: https://coveralls.io/r/nepalez/informator
+[gem]: https://rubygems.org/gems/informator
+[gemnasium]: https://gemnasium.com/nepalez/informator
+[travis]: https://travis-ci.org/nepalez/informator
+[inch]: https://inch-ci.org/github/nepalez/informator
+
+The [wisper]-inspired tiny implementation of publish/subscribe design pattern.
+
+The implementation differs from the original wisper's approach in the following aspects:
+
+* Unlike `Wisper::Publisher` that calls listener methods depending on the event, the `Informator` uses the same listener's callback for sending all events. Instead it wraps data to `Informator::Event` container and uses its as the argument for the callback.
+
+* The `Informator` has two separate methods - `#remember` and `#publish`. The first one is used to build and collect events, while the second one publishes all unpublished events at once (and clears the list of events to be published).
+
+* The `Informator` also defines `#publish!` method that is the same as `#publish` except for it throws the `:published`, that should be catched somewhere. This is just a shortcut for exiting from a use cases.
+
+* The `#publish` method returns the list of published events. The exception thrown by `#publish!` carries that list as well. This allows not only to publish them to listeners but to return them to caller. This is necessary to simplify chaining of service objects that includes the `Informator`.
+
+* The `Informator` has no global neither async subscribers. The gem's scope is narrower. Its main goal is to support service objects, that are either chained to each other, or publishes their results to decoupled listeners.
+
+[wisper]: https://github.com/krisleech/wisper
+
+Synopsis
+--------
+
+The `Informator` module API defines 4 instance methods:
+
+* `#subscribe` to subscribe listeners for receiving events, published by the informator
+* `#remember` to build an event and keep it unpublished
+* `#publish` to publish all events keeped since last publishing
+* `#publish!` the same as `#publish`, except for it throws `:published` exception which carries a list of events
+
+Except for the `Informator` the module defines public class `Informator::Event` for immutable events, that has 3 attributes:
+
+* `#type` for symbolic type of the event
+* `#data` for hash of data, carried by the event
+* `#messages` for array of human-readable messages, describing the event
+
+The event instance is build by the `#remember`, `#publish` or `#publish!` methods and is sent to listeners by either `#publish` or `#publish!`. When sending an event, the informator just calls the listeners callback, defined by `#subscribe` method, and gives it a corresponding event object as the only argument.
+
+```ruby
+require "informator"
+
+class Listener
+  def receive(event)
+    puts "The listener received #{ event.type }: #{ event.messages }"
+  end
+end
+
+listener = Listener.new
+
+class Service
+  include Informator
+
+  def call
+    catch(:published) { do_some_staff }
+  end
+
+  def do_some_staff
+    # ...
+    remember :success, "for now all is fine", foo: :bar
+    #
+    publish! :error, "OMG!", bar: :baz
+  end
+end
+
+service = Service.new
+service.subscribe listener, :receive
+result = service.call
+# The listener received success: ["for now all is fine"]
+# The listener received error: ["OMG!"]
+# => [
+#      #<Informator::Event @type=:success @data={ foo: :bar } @messages=["for now all is fine"]>,
+#      #<Informator::Event @type=:error @data={ bar: :baz } @messages=["OMG!"]>
+#    ]
+
+```
+
+In the example above the `listener#receive` method is called twice with the first, and then with the second event as an argument.
+
+Then the `publish!` throws an exception that carries the list of messages.
+The `service#call` catches it and returns the array of events. With this feature it is possible not only to subscribe for the service's events but receive it directly, combining [both telling and asking](http://martinfowler.com/bliki/TellDontAsk.html) when necessary.
+
+Installation
+------------
+
+Add this line to your application's Gemfile:
+
+```ruby
+# Gemfile
+gem "informator"
+```
+
+Then execute:
+
+```
+bundle
+```
+
+Or add it manually:
+
+```
+gem install informator
+```
+
+Compatibility
+-------------
+
+Tested under rubies [compatible to MRI 2.1+](.travis.yml).
+
+Uses [RSpec] 3.0+ for testing and [hexx-suit] for dev/test tools collection.
+
+[RSpec]: http://rspec.org
+[hexx-suit]: https://github.com/nepalez/hexx-suit
+
+Contributing
+------------
+
+* Read the [STYLEGUIDE](config/metrics/STYLEGUIDE)
+* [Fork the project](https://github.com/nepalez/informator)
+* Create your feature branch (`git checkout -b my-new-feature`)
+* Add tests for it
+* Commit your changes (`git commit -am '[UPDATE] Add some feature'`)
+* Push to the branch (`git push origin my-new-feature`)
+* Create a new Pull Request
+
+License
+-------
+
+See the [MIT LICENSE](LICENSE).

data/Rakefile

@@ -0,0 +1,27 @@
+# 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::RSpec and its tasks
+begin
+  require "hexx-suit"
+  Hexx::Suit.install_tasks
+rescue LoadError
+  require "hexx-rspec"
+  Hexx::RSpec.install_tasks
+end
+
+# Sets the Hexx::RSpec :test task to default
+task default: "test:coverage:run"
+
+desc "Runs mutation metric for testing"
+task :mutant do
+  system "mutant -r informator --use rspec 'Informator*' --fail-fast"
+end

data/config/metrics/STYLEGUIDE

@@ -0,0 +1,226 @@
+= 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.1.
+
+* 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. The same is for procs and lambdas.
+
+* 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.
+
+* Prefer ENV.fetch to ENV[] syntax.
+  Prefer block syntax for ENV.fetch to the second argument.
+
+
+== Naming:
+
+* Use snake_case for methods. Add the __ affixes to private methods.
+
+* Use CamelCase for classes and modules. (Keep acronyms like HTTP,
+  RFC, XML, UUID 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.