service_objects 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e743a38993231e20c909e567e8f743b43527ea3f
-  data.tar.gz: 491a38180eccf6a4b8b884d23c6a9d9b84064ab4
+  metadata.gz: 5ba370e1aeac72b78228f84baf4d3e14e34111df
+  data.tar.gz: 5368bc9082efd433c6c76e522182c91f6c41f8b5
 SHA512:
-  metadata.gz: fed24fa452deb99ef88a2a8325cc01fea50b91169578b1189c1634a8abcaab984f9d0594caa803feed6fbfb727a59028431b13d8d38791ad0a3d4e1c10154567
-  data.tar.gz: 20c5f8aa9fbca82761bd42df214cb95404c336f16dc3fce588b3d4396c589241b1444b5519d6b82e3280f62c211ab5f49785d7113c8a89a61bc38a4b2a3a83e5
+  metadata.gz: 069ac046cf072437fa8d340b0b5a91d39b8d73fd5ab5aed179946d7351400856269e361b49a41a19501a37278903527662731e39c5d42b1bea7d281b12c25b42
+  data.tar.gz: 747521693e08a5644fee7862c4cb076c31d08a0dd967a8abfabbbc900f390b9b979eebf2fd961fc1ac32e6db0ae1d26bcda7477c8a1294a8f08a09cfab6c4631

data/.coveralls.yml

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

data/.metrics

@@ -5,4 +5,5 @@ begin
   require "hexx-suit"
   Hexx::Suit::Metrics::MetricFu.load
 rescue LoadError
+  puts "The 'hexx-suit' gem is not installed"
 end

data/.travis.yml

@@ -1,9 +1,17 @@
 ---
 language: ruby
-bundler_args: --without metrics
+bundler_args: --without=metrics
 script: rake test:coverage:run
 rvm:
   - '2.0'
   - '2.1'
   - '2.2'
   - ruby-head
+  - rbx-2 --2.0
+  - rbx-head
+  - jruby-9.0.0.0.pre1
+  - jruby-head
+allow_failures:
+  - rvm: ruby-head
+  - rvm: rbx-head
+  - rvm: jruby-head

data/.yardopts

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

data/Gemfile

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

data/Guardfile

@@ -2,17 +2,38 @@
 
 guard :rspec, cmd: "bundle exec rspec" do
 
-  watch("lib/service_objects.rb") { "spec" }
+  # runs current spec
+  watch(%r{^spec/.+_spec\.rb$})
+
+  # runs a bin's spec
+  watch(%r{^bin/(.+)$}) do |m|
+    "spec/bin/#{ m[1] }_spec.rb"
+  end
+
+  # runs a lib's spec
+  watch(%r{^lib/service_objects/(\w+)\.rb$}) do |m|
+    "spec/lib/#{ m[1] }_spec.rb"
+  end
 
-  watch("lib/service_objects/cli/*.*") { "spec/tests/cli_spec.rb" }
+  # runs a generator's spec when the generator or its template changed
+  watch(%r{^lib/service_objects/generators/(\w+)}) do |m|
+    "spec/lib/generators/#{ m[1] }_spec.rb"
+  end
 
-  watch(%r{^lib/service_objects/(.+)\.rb$}) do |m|
-    "spec/tests/#{ m[1] }_spec.rb"
+  # runs all the generators' specs
+  watch("lib/service_objects/generators.rb") do
+    "spec/lib/generators"
   end
 
-  watch(%r{^spec/support/(.+)\.rb$})  { "spec" }
+  # runs all the generators' specs
+  watch(%r{^lib/service_objects/generators}) do
+    "spec/bin"
+  end
 
-  watch(/^spec\/spec_helper\w*\.rb$/) { "spec" }
+  # runs all specs when core files changed
+  watch("lib/service_objects.rb") { "spec" }
+  watch("spec/spec_helper.rb")    { "spec" }
+  watch(%r{^spec/support})        { "spec" }
+  watch(/^\w+$/)                  { "spec" }
 
-  watch(%r{^spec/tests/.+_spec\.rb$})
-end
+end # guard :rspec

data/LICENSE

@@ -1,6 +1,6 @@
 The MIT License
 
-Copyright (c) 2014 Andrew Kozin, https://github.com/nepalez
+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

data/README.md

@@ -1,467 +1,303 @@
-# ServiceObjects
+Service Objects
+===============
+
+**The version 1.0 has been re-written from scratch without ActiveModel dependency.**
+
+**See v0.0.1 at the [legacy] git branch**
+
+[legacy]: https://github.com/nepalez/service_objects/tree/legacy
 
 [![Gem Version](https://img.shields.io/gem/v/service_objects.svg?style=flat)][gem]
 [![Build Status](https://img.shields.io/travis/nepalez/service_objects/master.svg?style=flat)][travis]
 [![Dependency Status](https://img.shields.io/gemnasium/nepalez/service_objects.svg?style=flat)][gemnasium]
 [![Code Climate](https://img.shields.io/codeclimate/github/nepalez/service_objects.svg?style=flat)][codeclimate]
 [![Coverage](https://img.shields.io/coveralls/nepalez/service_objects.svg?style=flat)][coveralls]
-[![License](https://img.shields.io/badge/license-MIT-blue.svg?style=flat)][license]
+[![Inline docs](http://inch-ci.org/github/nepalez/service_objects.svg)][inch]
 
-[gem]: https://rubygems.org/gems/service_objects
-[travis]: https://travis-ci.org/nepalez/service_objects
-[gemnasium]: https://gemnasium.com/nepalez/service_objects
 [codeclimate]: https://codeclimate.com/github/nepalez/service_objects
 [coveralls]: https://coveralls.io/r/nepalez/service_objects
-[license]: file:LICENSE
-
-The module implements two design patterns:
-
-* The [Interactor pattern] to decouple business logics from both models and delivery mechanisms, such as [Rails].
-* The [Observer pattern] to follow the [Tell, don't Ask] design princible.
-  The pattern is implemented with the help of [wisper] gem by [Kris Leech].
-
-[Rails]: http://rubyonrails.org/
-[Interactor pattern]: http://blog.codeclimate.com/blog/2012/10/17/7-ways-to-decompose-fat-activerecord-models/
-[Observer pattern]: http://reefpoints.dockyard.com/2013/08/20/design-patterns-observer-pattern.html
-[Tell, don't Ask]: http://martinfowler.com/bliki/TellDontAsk.html
-[wisper]: http://www.github.com/krisleech/wisper
-[Kris Leech]: http://www.github.com/krisleech
+[gem]: https://rubygems.org/gems/service_objects
+[gemnasium]: https://gemnasium.com/nepalez/service_objects
+[travis]: https://travis-ci.org/nepalez/service_objects
+[inch]: https://inch-ci.org/github/nepalez/service_objects
 
-The module API provides 3 classes:
+Base classes for [services] and their listeners following [Publish/Subscribe] design pattern.
 
-* `ServiceObjects::Base` - for service objects.
-* `ServiceObjects::Listener` - for decorating objects with methods called by service notificiations.
-* `ServiceObjects::Message` - for messages published by service objects.
+[services]: http://blog.codeclimate.com/blog/2012/10/17/7-ways-to-decompose-fat-activerecord-models/
+[Publish/Subscribe]: http://reefpoints.dockyard.com/2013/08/20/design-patterns-observer-pattern.html
 
-## Installation
+Installation
+------------
 
 Add this line to your application's Gemfile:
 
 ```ruby
-    gem "service_objects"
+# Gemfile
+gem "service_objects"
 ```
 
-And then execute:
+Then execute:
 
 ```
-    bundle
+bundle
 ```
 
-Or install it yourself as:
+Or add it manually:
 
 ```
-    gem install service_objects
+gem install service_objects
 ```
 
-## Usage
+Introduction
+------------
 
-The basic usage of the services by example of Rails controller:
+The API contains 3 classes:
 
-```ruby
-# lib/my_gem.rb
-require "service_objects"
-
-# app/services/add_foo.rb
-class AddFoo < ServiceObjects::Base
-
-  # whitelists parameters and defines #params, #bar and #baz
-  allows_params :bar, :baz
-
-  # declares external dependencies
-  depends_on :find_foo, default: FindFoo
-
-  # calls the service, sorts out and reports its results
-  def run
-    run!
-  rescue Invalid => err
-    publish :error, err.messages
-  else
-    publish :created, @foo, messages
-  ensure
-    self
-  end
-
-  private
-
-  # business logic lives here
-  def run!
-    # ... usage of the external service find_foo postponed
-    add_foo
-  end
-
-  # rescues errors and re-raises them as Invalid with list of #messages
-  def add_foo
-    escape { @foo ||= Foo.create! bar: bar, baz: baz }
-  end
-end
-```
-
-```ruby
-# app/controllers/foos_controller.rb
-class FoosController < ApplicationController
-  
-  def create
-    # Create the service object with necessary parameters.
-    # All the business logic is encapsulated inside the service,
-    # and the controller knows nothing what the service will do.
-    service  = AddFoo.new params.allow(:bar, :baz)
-    # Subscribe the listener for the service's notifications
-    service.subscribe listener, prefix: :on
-    # Run the service
-    service.run
-    # If the service doesn't call any listener method,
-    # then a listener provides some default actions
-    listener.finalize
-  end
+* `ServiceObjects::Base` - for service objects.
+* `ServiceObjects::Listener` - for service objects' listeners.
+* `ServiceObjects::Message` - for messages published by service objects.
 
-  private
+The module is backed on 3 gems:
 
-  # The listener decorates the controller with methods
-  # to listen the service object's notifications
-  # (see FoosListener#otherwise method below).
-  def listener
-    @listener ||= FoosListener.new self
-  end
+* [wisper] that provides [Publish/Subscribe] features of the service;
+* [virtus] for service object's attributes and dependencies declaration;
+* [attestor] for object's validation.
 
-  # The class to work out service object notifications
-  # The #render method is delegated to the controller
-  class FoosListener < ServiceObjects::Listener
+[wisper]: https://github.com/krisleech/wisper
+[virtus]: https://github.com/solnic/virtus
+[attestor]: https://github.com/nepalez/attestor
+[attr_coerced]: https://github.com/nepalez/attr_coerced
 
-    # The method to be called when a service publishes
-    # the 'added' notification.
-    def on_added(foo, *, messages)
-      render "created", locals: { foo: foo, messages: messages }
-    end
+Basic Use
+---------
 
-    # The method to be called when a service publishes
-    # the 'error' notification.
-    def on_error(*, messages)
-      render "error", locals: { messages: messages }
-    end
+Define the service object and describe its attributes (via [virtus]).
 
-    # The method is called by the #finalize in case no methods has been called
-    # by the service object.
-    #
-    # This allows to focuse only on a subset of service notifications above.
-    def otherwise
-      render "no_result"
-    end
-  end
+```ruby
+class DeleteFoo < ServiceObjects::Base
+  attribute :id, Integer
 end
 ```
 
-The service can notify several listeners (controller itself, mailer etc.).
-
-## Base
-
-The `ServiceObjects::Base` provides base class for services.
+You can also use another coersion mechanism (via [attr_coerced]).
 
 ```ruby
-require "service_objects"
-
-class AddFoo < ServiceObjects::Base
+class DeleteFoo < ServiceObjects::Base
+  attribute :id
+  attr_coerced :id, Integer
 end
 ```
 
-### Parameters declaration
-
-Define allowed parameters for objects:
+Declare dependencies from other service objects. This allows [setter injection] of dependencies in a runtime (for example, in unit tests).
 
 ```ruby
-class AddFoo < ServiceObjects::Base
-  allows_params :bar, :baz
+class DeleteFoo < ServiceObjects::Base
+  # ...
+  dependency :get_foo, default: GetFoo # another service objects class
 end
-```
-
-Parameters are whitelisted and assigned to `#params` hash (all keys are *symbolized*).
-
-Attributes are also defined as aliases for corresponding params, so that `#bar` and `#bar=` are equivalent to `#params[:bar]`, `#params[:bar]=`.
 
-**Note**:
-The service ignores parameters except for explicitly declared. The client can give relevant data to the service, and leave the latter to figure them out by itself.
+# This defines an attribute of Class type
+service = DeleteFoo.new
+service.get_foo # => GetFoo
+service.get_foo = FindFoo
+service.get_foo # => FindFoo
+```
 
-### Validation
+Notice, the dependency is not an attribute. You cannot set it via hash arguments of the service object constructor.
 
-The `ServiceObject::Base` includes [ActiveModel::Validations] with methods `.validates`, `.validate`, `#errors`, `#valid?` and `#invalid?`. Use them to add action context - specific validations.
+[setter injection]: @todo
 
-The method `#validate!` raises the `ServiceObject::Invalid` if validation fails.
+Declare validations for attributes and dependencies using the `validate` and `validates` [attestor] methods.
 
 ```ruby
-class AddFoo < ServiceObjects::Base
-  allows_params :bar, :baz
-
-  validates :bar, presence: true
-  validates :baz, numericality: { greater_than: 1 }, allow_nil: true
-
+class DeleteFoo < ServiceObjects::Base
   # ...
-
-  def run!
-    # ...
-    validate!
-    # ...
-  end
+  validate { invalid :blank_id unless id }
+  validate { invalid :get_foo  unless get_foo.is_a? ServiceObjects::Base }
 end
 ```
 
-**Note:** You aren't restricted in selecting time for validation. Prepare attributes (either "real" or [virtual]) and run `#validate!` when necessary.
+Define the `#run!` **private** method.
 
-[ActiveModel::Validations]: http://api.rubyonrails.org/classes/ActiveModel/Validations.html
-[virtual]: http://railscasts.com/episodes/16-virtual-attributes?view=asciicast
+It is expected the method to publish notifications to listeners (via [wisper]). The [wisper] `#publish` method is reloaded so that after publication it throws `:published` to be caught by public `#run` method. That's how `#publish` stops running the service.
 
-### Dependencies declaration
-
-As a rule, services uses each other to keep the code DRY. For example, the service that *adds* a new foo (whatever it means) can use another service to *find* an existing foo.
-
-To made all that dependencies injectable via [setter injection], define them explicitly:
+If you need to publish something and keep running, use the [wisper] `#broadcast` method instead of the `#publish`.
 
 ```ruby
-class AddFoo < ServiceObjects::Base
+class DeleteFoo < ServiceObjects::Base
   # ...
+  private
+
+  def run!
+    validate
+    find_foo
+    delete_foo
+  end
 
-  # Providing the FindFoo is available at the moment AddFoo being defined:
-  depends_on :find_foo, default: FindFoo
 end
 ```
 
-Default value can be either assigned or skipped. In the last case the [Null Object] will be assigned by default.
+Notice the `#validate` method (via [attestor]). It publishes `:error` notification when a validation fails.
 
-The class method is public to postpone the default implementation until it is defined:
+Call the external service and listen to its notifications with a `#run_service` helper:
 
 ```ruby
-class AddFoo < ServiceObjects::Base
+class DeleteFoo < ServiceObjects::Base
   # ...
-  depends_on :find_foo
+  def find_foo
+    run_service get_foo.new(id: id), Listener.new(self)
+  end
 end
-
-# later
-FindFoo = Class.new
-AddFoo.depends_on :find_foo, default: FindFoo
 ```
 
-This provides the instance attribute `#find_foo`. You can inject the dependency to the via setter:
+You should provide a listener for the service. The `ServiceObjects::Listener` method decorates its argument (`self`) with necessary callbacks.
 
-```ruby
-service = AddFoo.new bar: "bar", baz: "baz"
-service.find_foo = GetFoo
-```
-
-[setter injection]: http://brandonhilkert.com/blog/a-ruby-refactor-exploring-dependency-injection-options/
-[Null Object]: https://robots.thoughtbot.com/rails-refactoring-example-introduce-null-object
-
-### Run method
-
-It is expected the `run` method to provide all the necessary staff and notify listeners via `#publish` method.
+It should also define the `#otherwise` callback for the case when an external service publishes no expected notifications.
 
-See [wisper] for details on `#publish` and `#subscribe` methods.
+All undefined methods are forwarded to the listener argument, so you can modify attributes of mutable services from their listeners.
 
 ```ruby
-class AddFoo < ServiceObjects::Base
+class DeleteFoo < ServiceObjects::Base
   # ...
+  private
 
-  # The method contains the reporting logic only
-  def run
-    run!
-  rescue Found
-    publish :found, @foo, messages
-  rescue Invalid => err
-    publish :error, err.messages
-  else
-    publish :added, @foo, messages
-  ensure
-    self
-  end
+  attr_accessor :foo
 
-  # ...
+  class Listener < ServiceObjects::Listener
+    def on_found(foo)
+      self.foo = foo
+    end
 
-  private
+    # the method will be called by #run_service
+    # unless #on_found received
+    def otherwise
+      publish :not_found, message(:error, :not_found, id: id)
+    end
+  end
+end
+```
 
-  Found = Class.new(RuntimeError) # the internal message
+The `#message` helper returns a translated message with 2 attributes: `type` and `text`. When the text is set as a `Symbol`, it is translated by `I18n` with given options.
 
-  # Business logic lives here
-  def run!
-    get_foo
-    create_foo
-  end
+```yaml
+# config/locales/en.yml
+---
+en:
+  service_objects:
+    delete_foo: # the service class name like ActiveModule's one
+      error:    # the type of the message
+        not_found: "The foo with id %{id} hasn't been found"
+      success:
+        deleted: "The foo with id %{id} has been deleted"
+```
 
-  def get_foo
-    # ... finds and assigns @foo somehow
-    fail Found if @foo
-  end
+It is also recommended to publish successful message for the service not to end up silently:
 
-  def add_foo
-    # ...
+```ruby
+class DeleteFoo < ServiceObjects::Base
+  # ...
+  def delete_foo
+    # do something to delete foo
+    publish :deleted, foo, message(:success, :deleted, id: id)
   end
 end
 ```
 
-There are some helper available:
-* `messages` - an array of collected service messages
-* `add_message` - adds the new message to the array
-* `escape` - rescues from `StandardErrors` and re-raises them as `ServiceObject::Invalid` with collection of `#messages`.
+Full Example
+----------------
 
-**Note** Following [command-query separation] the `#run` method (being a command) returns `self`.
+```ruby
+class DeleteFoo < ServiceObjects::Base
 
-[command-query separation]: http://en.wikipedia.org/wiki/Command-query_separation
+  attribute :id, Integer
 
-### External services
+  dependency :get_foo, GetFoo # another service objects class
 
-External services should be used in just the same way as in the controller example.
+  validate { invalid :blank_id unless id }
+  validate { invalid :get_foo  unless get_foo.is_a? ServiceObjects::Base }
 
-```ruby
-class AddFoo < ServiceObjects::Base
-  depends_on :find_foo, default: FindFoo
+  private
 
-  # ...
+  def run!
+    validate   # publishes :error
+    find_foo   # publishes :not_found
+    delete_foo # publishes :deleted
+  end
 
-  def get_foo
-    service = find_foo.new params
-    service.subscribe listener, prefix: :on
-    service.run
+  attr_accessor :foo
 
-    # the method runs #otherwise callback in case
-    # no other notificaton has been received
-    listener.finalize
+  def find_foo
+    run_service get_foo.new(id: id), Listener.new(self)
   end
 
-  # decorates the service with methods to listen to external service
-  def listener
-    @listener ||= FindListener.new self
+  def delete_foo
+    #... do something
+    publish :deleted, message(:error, :not_found, id: id)
   end
 
-  class FindListener < ServiceObjects::Listener
-    def on_found(foo, *)
-      __getobj__.foo = foo
-    end
-
-    def on_error(*, messages)
-      __getobj__.messages = messages
+  # @private
+  class Listener < ServiceObjects::Listener
+    def on_found(foo)
+      self.foo = foo
     end
 
     def otherwise
-      add_message "complain", "haven't been informed"
+      publish :not_found, message(:error, :not_found, id: id)
     end
   end
 end
 ```
 
-Here the `#get_foo` runs the external service and listens to its notifications. Instead of the long syntax above, you can use a shortcut:
 
-```ruby
-# ...
-def get_foo
-  run_service find_foo.new(params), listener, prefix: :on
-end
-```
-
-## Listener
+Calling the Service
+-------------------
 
-The listener is a [decorator] that:
-
-* defines callbacks to listen to service notifications.
-* delegates all undefined methods to the encapsulated object (available via [__getobj__] instance method).
-* defines the `#finalize` method to run `#otherwise` callback in case no other methods has been checked (via `#respond_to?` method).
+The service can be called like any other [wisper] publisher. For example, from the Rails controller:
 
 ```ruby
-class FooListener < ServiceObjects::Listener
-  def on_success(*)
-    "Notified on success"
-  end
-  
-  def otherwise
-    "Hasn't been notified"
+class FooController < ActionController::Base
+  def delete
+    listener = DeleteListener.new(self)
+    service  = DeleteFoo.new(id: params[:id])
+    service.subscribe(listener, prefix: :on)
+    service.run
   end
-end
-
-listener = FooListener.new
-listener.finalize
-# => "Hasn't been notified"
-
-listener.respond_to? :on_error
-# => false
-listener.finalize
-# => "Hasn't been notified"
 
-listener.respond_to? :on_success
-# => true
-listener.finalize
-# => nil
-```
-
-[decorator]: http://nithinbekal.com/posts/ruby-decorators/
-[__getobj__]: http://ruby-doc.org//stdlib-2.1.0/libdoc/delegate/rdoc/SimpleDelegator.html#method-i-__getobj__
-
-## Message
-
-The `ServiceObjects::Base#messages` collects messages with text, type and optional priority:
-
-```ruby
-message = ServiceObjects::Message.new priority: 0, type: "bar", text: "foo"
-message.priority    # => 0.0
-message.type        # => "info"
-message.text        # => "some text"
-message.to_h        # => { type: "bar", type: "foo" }
-message.to_json     # => "{\"type\":\"bar\",\"text\":"\foo\"}"
-```
-
-When a priority hasn't been defined explicitly, it is set to `-1.0` for errors, and to `0.0` otherwise. Messages are sorted by priority, type and text in a "natural" order.
-
-Use the `#add_message` helper to add a message to the collection:
-
-```ruby
-service = ServiceObjects::Base.new
-service.send :add_message type: "info", text: "some text"
-service.send :messages
-# => [<Message type="info" text="some text" priority=0.0>]
-```
-
-When a `text:` value is a symbol, it is translated in the scope of current service class:
-
-```yaml
-# config/locales/en.yml
----
-en:
-  activemodel:
-    messages:
-      models:
-        foo:
-          excuse: # the type of the message
-            not_informed: "I haven't been informed on the %{subject}"
-```
-
-```ruby
-service.send :add_message type: "excuse", text: :not_informed, subject: "issue"
-# => [<Message text="I haven't been informed on the issue" ...>]
-```
-
-## Scaffolding
-
-Use CLI command to scaffold a service object with its specification and translations:
-
-```
-service new my_service
-```
+  class DeleteListener < ServiceObjects::Listener
+    def on_deleted
+      redirect_to :home
+    end
 
-To see available options run the command with `-h` option:
+    def on_not_found
+      #...
+    end
 
-```
-service new -h
+    def otherwise
+      #...
+    end
+  end
+end
 ```
 
-## Compatibility
+Compatibility
+-------------
 
-Tested under MRI rubies >= 2.1
+Tested under rubies compatible to rubies compatible to API 2.0+:
 
-RSpec 3.0+ used for testing
+* MRI 2.0+
+* Rubinius (mode 2.0+)
+* JRuby 9.0.0.0 (mode 2.0+)
 
-Collection of testing, debugging and code metrics is defined
-in the [hexx-suit](https://github.com/nepalez/hexx-suit) gem.
+Uses [RSpec] 3.0+ for testing and [hexx-suit] for dev/test tools collection.
 
-To run tests use `rake test`, to run code metrics use `rake check`. All the metric settings are collected in the `config/metrics` folder.
+[RSpec]: http://rspec.info/
+[hexx-suit]: http://github.com/nepalez/hexx-suit
 
-## Contributing
+Contributing
+------------
 
 * Fork the project.
-* Read the [Styleguide](file:config/metrics/STYLEGUIDE).
+* 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.
@@ -470,6 +306,7 @@ To run tests use `rake test`, to run code metrics use `rake check`. All the metr
   in a commit by itself I can ignore when I pull)
 * Send me a pull request. Bonus points for topic branches.
 
-## License
+License
+-------
 
-See [MIT LICENSE][license]
+See the [MIT LICENSE](LICENSE).