rubyjobbuilderdsl 0.0.0 → 0.0.1

data/vendor/bundle/ruby/2.1.0/gems/rubocop-0.26.0/README.md

@@ -0,0 +1,807 @@
+[![Gem Version](https://badge.fury.io/rb/rubocop.svg)](http://badge.fury.io/rb/rubocop)
+[![Dependency Status](https://gemnasium.com/bbatsov/rubocop.svg)](https://gemnasium.com/bbatsov/rubocop)
+[![Build Status](https://travis-ci.org/bbatsov/rubocop.svg?branch=master)](https://travis-ci.org/bbatsov/rubocop)
+[![Coverage Status](http://img.shields.io/coveralls/bbatsov/rubocop/master.svg)](https://coveralls.io/r/bbatsov/rubocop)
+[![Code Climate](https://codeclimate.com/github/bbatsov/rubocop/badges/gpa.svg)](https://codeclimate.com/github/bbatsov/rubocop)
+[![Inline docs](http://inch-ci.org/github/bbatsov/rubocop.svg)](http://inch-ci.org/github/bbatsov/rubocop)
+
+# RuboCop
+
+> Role models are important. <br/>
+> -- Officer Alex J. Murphy / RoboCop
+
+**RuboCop** is a Ruby static code analyzer. Out of the box it will
+enforce many of the guidelines outlined in the community
+[Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide).
+
+Most aspects of its behavior can be tweaked via various
+[configuration options](https://github.com/bbatsov/rubocop/blob/master/config/default.yml).
+
+Apart from reporting problems in your code, RuboCop can also
+automatically fix some of the problems for you.
+
+**This documentation tracks the `master` branch of RuboCop. Some of
+the features and settings discussed here might not be available in
+older releases (including the current stable release). Please, consult
+the relevant git repo branch if you need documentation for a specific RuboCop
+release.**
+
+- [Installation](#installation)
+- [Basic Usage](#basic-usage)
+    - [Cops](#cops)
+        - [Style](#style)
+        - [Lint](#lint)
+        - [Metrics](#metrics)
+        - [Rails](#rails)
+- [Configuration](#configuration)
+    - [Inheritance](#inheritance)
+    - [Defaults](#defaults)
+    - [Including/Excluding files](#includingexcluding-files)
+    - [Automatically Generated Configuration](#automatically-generated-configuration)
+- [Disabling Cops within Source Code](#disabling-cops-within-source-code)
+- [Formatters](#formatters)
+    - [Progress Formatter (default)](#progress-formatter-default)
+    - [Clang Style Formatter](#clang-style-formatter)
+    - [Fuubar Style Formatter](#fuubar-style-formatter)
+    - [Emacs Style Formatter](#emacs-style-formatter)
+    - [Simple Formatter](#simple-formatter)
+    - [File List Formatter](#file-list-formatter)
+    - [JSON Formatter](#json-formatter)
+    - [Offense Count Formatter](#offense-count-formatter)
+- [Compatibility](#compatibility)
+- [Editor integration](#editor-integration)
+    - [Emacs](#emacs)
+    - [Vim](#vim)
+    - [Sublime Text](#sublime-text)
+    - [Brackets](#brackets)
+    - [TextMate2](#textmate2)
+    - [Atom](#atom)
+    - [LightTable](#lighttable)
+    - [Other Editors](#other-editors)
+- [Guard integration](#guard-integration)
+- [Rake integration](#rake-integration)
+- [Extensions](#extensions)
+  - [Loading Extensions](#loading-extensions)
+  - [Custom Cops](#custom-cops)
+    - [Known Custom Cops](#known-custom-cops)
+  - [Custom Formatters](#custom-formatters)
+    - [Creating Custom Formatter](#creating-custom-formatter)
+    - [Using Custom Formatter in Command Line](#using-custom-formatter-in-command-line)
+- [Team](#team)
+- [Contributors](#contributors)
+- [Mailing List](#mailing-list)
+- [Changelog](#changelog)
+- [Copyright](#copyright)
+
+## Installation
+
+**RuboCop**'s installation is pretty standard:
+
+```
+$ gem install rubocop
+```
+
+If you'd rather install RuboCop using `bundler`, don't require it in your `Gemfile`:
+
+```
+gem 'rubocop', require: false
+```
+
+## Basic Usage
+
+Running `rubocop` with no arguments will check all Ruby source files
+in the current directory:
+
+```
+$ rubocop
+```
+
+Alternatively you can pass `rubocop` a list of files and directories to check:
+
+```
+$ rubocop app spec lib/something.rb
+```
+
+Here's RuboCop in action. Consider the following Ruby source code:
+
+```ruby
+def badName
+  if something
+    test
+    end
+end
+```
+
+Running RuboCop on it (assuming it's in a file named `test.rb`) would produce the following report:
+
+```
+Offenses:
+
+test.rb:1:5: C: Use snake_case for methods and variables.
+def badName
+    ^^^^^^^
+test.rb:2:3: C: Favor modifier if/unless usage when you have a single-line body. Another good alternative is the usage of control flow &&/||.
+  if something
+  ^^
+test.rb:4:5: W: end at 4, 4 is not aligned with if at 2, 2
+    end
+    ^^^
+
+1 file inspected, 3 offenses detected
+```
+
+For more details check the available command-line options:
+
+```
+$ rubocop -h
+```
+
+Command flag              | Description
+--------------------------|------------------------------------------------------------
+`-v/--version`            | Displays the current version and exits
+`-V/--verbose-version`    | Displays the current version plus the version of Parser and Ruby
+`-F/--fail-fast`          | Inspects in modification time order and stops after first file with offenses
+`-d/--debug`              | Displays some extra debug output
+`-D/--display-cop-names`  | Displays cop names in offense messages.
+`-c/--config`             | Run with specified config file
+`-f/--format`             | Choose a formatter
+`-o/--out`                | Write output to a file instead of STDOUT
+`-r/--require`            | Require Ruby file (see [Loading Extensions](#loading-extensions))
+`-R/--rails`              | Run extra Rails cops
+`-l/--lint`               | Run only lint cops
+`-a/--auto-correct`       | Auto-correct certain offenses *Note:* Experimental - use with caution
+`--only`                  | Run only the specified cop(s)
+`--auto-gen-config`       | Generate a configuration file acting as a TODO list
+`--show-cops`             | Shows available cops and their configuration
+`--fail-level`            | Minimum severity for exit with error code
+
+### Cops
+
+In RuboCop lingo the various checks performed on the code are called cops. There are several cop departments.
+
+You can also load [custom cops](#custom-cops).
+
+#### Style
+
+Most of the cops in RuboCop are so called style cops that check for
+stylistics problems in your code. Almost all of the them are based on
+the Ruby Style Guide. Many of the style cops have configurations
+options allowing them to support different popular coding
+conventions.
+
+#### Lint
+
+Lint cops check for possible errors and very bad practices in your
+code. RuboCop implements in a portable way all built-in MRI lint
+checks (`ruby -wc`) and adds a lot of extra lint checks of its
+own. You can run only the lint cops like this:
+
+```
+$ rubocop -l
+```
+
+The `-l`/`--lint` option can be used together with `--only` to run all the
+enabled lint cops plus a selection of other cops.
+
+Disabling any of the lint cops is generally a bad idea.
+
+#### Metrics
+
+Metrics cops deal with properties of the source code that can be measured,
+such as class length, method length, etc. Generally speaking, they have a
+configuration parameter called `Max` and when running
+`rubocop --auto-gen-config`, this parameter will be set to the highest value
+found for the inspected code.
+
+#### Rails
+
+Rails cops are specific to the Ruby on Rails framework. Unlike style
+and lint cops they are not used by default and you have to request them
+specifically:
+
+```
+$ rubocop -R
+```
+
+or add the following directive to your `.rubocop.yml`:
+
+```yaml
+AllCops:
+  RunRailsCops: true
+```
+
+## Configuration
+
+The behavior of RuboCop can be controlled via the
+[.rubocop.yml](https://github.com/bbatsov/rubocop/blob/master/.rubocop.yml)
+configuration file. It makes it possible to enable/disable certain cops
+(checks) and to alter their behavior if they accept any parameters. The file
+can be placed either in your home directory or in some project directory.
+
+RuboCop will start looking for the configuration file in the directory
+where the inspected file is and continue its way up to the root directory.
+
+The file has the following format:
+
+```yaml
+inherit_from: ../.rubocop.yml
+
+Style/Encoding:
+  Enabled: false
+
+Metrics/LineLength:
+  Max: 99
+```
+
+**Note**: Qualifying cop name with its type, e.g., `Style`, is recommended,
+  but not necessary as long as the cop name is unique across all types.
+
+### Inheritance
+
+The optional `inherit_from` directive is used to include configuration
+from one or more files. This makes it possible to have the common
+project settings in the `.rubocop.yml` file at the project root, and
+then only the deviations from those rules in the subdirectories. The
+files can be given with absolute paths or paths relative to the file
+where they are referenced. The settings after an `inherit_from`
+directive override any settings in the file(s) inherited from. When
+multiple files are included, the first file in the list has the lowest
+precedence and the last one has the highest. The format for multiple
+inheritance is:
+
+```yaml
+inherit_from:
+  - ../.rubocop.yml
+  - ../conf/.rubocop.yml
+```
+
+### Defaults
+
+The file
+[config/default.yml](https://github.com/bbatsov/rubocop/blob/master/config/default.yml)
+under the RuboCop home directory contains the default settings that
+all configurations inherit from. Project and personal `.rubocop.yml`
+files need only make settings that are different from the default
+ones. If there is no `.rubocop.yml` file in the project or home
+directory, `config/default.yml` will be used.
+
+### Including/Excluding files
+
+RuboCop checks all files recursively within the directory it is run
+on.  However, it only recognizes files ending with `.rb` or
+extensionless files with a `#!.*ruby` declaration as Ruby files. If
+you'd like it to check other files you'll need to manually pass them
+in, or to add entries for them under `AllCops`/`Include`.  Files and
+directories can also be ignored through `AllCops`/`Exclude`.
+
+Here is an example that might be used for a Rails project:
+
+```yaml
+AllCops:
+  Include:
+    - '**/Rakefile'
+    - '**/config.ru'
+  Exclude:
+    - 'db/**/*'
+    - 'config/**/*'
+    - 'script/**/*'
+    - !ruby/regexp /old_and_unused\.rb$/
+
+# other configuration
+# ...
+```
+
+Files and directories are specified relative to the `.rubocop.yml` file.
+
+**Note**: Patterns that are just a file name, e.g. `Rakefile`, will match
+that file name in any directory, but this pattern style deprecated. The
+correct way to match the file in any directory, including the current, is
+`**/Rakefile`.
+
+**Note**: The pattern `config/**` will match any file recursively under
+`config`, but this pattern style is deprecated and should be replaced by
+`config/**/*`.
+
+**Note**: The `Exclude` parameter is special. It is valid for the
+directory tree starting where it is defined. It is not shadowed by the
+setting of `Exclude` in other `.rubocop.yml` files in
+subdirectories. This is different from all other parameters, who
+follow RuboCop's general principle that configuration for an inspected
+file is taken from the nearest `.rubocop.yml`, searching upwards.
+
+Cops can be run only on specific sets of files when that's needed (for
+instance you might want to run some Rails model checks only on files whose
+paths match `app/models/*.rb`). All cops support the
+`Include` param.
+
+```yaml
+Rails/DefaultScope:
+  Include:
+    - app/models/*.rb
+```
+
+Cops can also exclude only specific sets of files when that's needed (for
+instance you might want to run some cop only on a specific file). All cops support the
+`Exclude` param.
+
+```yaml
+Rails/DefaultScope:
+  Exclude:
+    - app/models/problematic.rb
+```
+
+Specific cops can be disabled by setting `Enabled` to `false` for that specific cop.
+
+```yaml
+Metrics/LineLength:
+  Enabled: false
+```
+
+Cops can customize their severity level. All cops support the `Severity` param.
+Allowed params are `refactor`, `convention`, `warning`, `error` and `fatal`.
+
+```yaml
+Metrics/CyclomaticComplexity:
+  Severity: warning
+```
+
+### Automatically Generated Configuration
+
+If you have a code base with an overwhelming amount of offenses, it can
+be a good idea to use `rubocop --auto-gen-config` and add an
+`inherit_from: .rubocop_todo.yml` in your `.rubocop.yml`. The generated
+file `.rubocop_todo.yml` contains configuration to disable all cops that
+currently detect an offense in the code. Then you can start removing the
+entries in the generated file one by one as you work through all the
+offenses in the code.
+
+## Disabling Cops within Source Code
+
+One or more individual cops can be disabled locally in a section of a
+file by adding a comment such as
+
+```ruby
+# rubocop:disable Metrics/LineLength, Style/StringLiterals
+[...]
+# rubocop:enable Metrics/LineLength, Style/StringLiterals
+```
+
+You can also disable *all* cops with
+
+```ruby
+# rubocop:disable all
+[...]
+# rubocop:enable all
+```
+
+One or more cops can be disabled on a single line with an end-of-line
+comment.
+
+```ruby
+for x in (0..19) # rubocop:disable Style/AvoidFor
+```
+
+## Formatters
+
+You can change the output format of RuboCop by specifying formatters with the `-f/--format` option.
+RuboCop ships with several built-in formatters, and also you can create your custom formatter.
+
+Additionaly the output can be redirected to a file instead of `$stdout` with the `-o/--out` option.
+
+Some of the built-in formatters produce **machine-parsable** output
+and they are considered public APIs.
+The rest of the formatters are for humans, so parsing their outputs is discouraged.
+
+You can enable multiple formatters at the same time by specifying `-f/--format` multiple times.
+The `-o/--out` option applies to the previously specified `-f/--format`,
+or the default `progress` format if no `-f/--format` is specified before the `-o/--out` option.
+
+```bash
+# Simple format to $stdout.
+$ rubocop --format simple
+
+# Progress (default) format to the file result.txt.
+$ rubocop --out result.txt
+
+# Both progress and offense count formats to $stdout.
+# The offense count formatter outputs only the final summary,
+# so you'll mostly see the outputs from the progress formatter,
+# and at the end the offense count summary will be outputted.
+$ rubocop --format progress --format offenses
+
+# Progress format to $stdout, and JSON format to the file rubocop.json.
+$ rubocop --format progress --format json --out rubocop.json
+#         ~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~
+#                 |               |_______________|
+#              $stdout
+
+# Progress format to result.txt, and simple format to $stdout.
+$ rubocop --output result.txt --format simple
+#         ~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~
+#                  |                 |
+#           default format        $stdout
+```
+
+You can also load [custom formatters](#custom-formatters).
+
+### Progress Formatter (default)
+
+The default `progress` formatter outputs a character for each inspected file,
+and at the end it displays all detected offenses in the `clang` format.
+A `.` represents a clean file, and each of the capital letters means
+the severest offense (convention, warning, error or fatal) found in a file.
+
+```
+$ rubocop
+Inspecting 26 files
+..W.C....C..CWCW.C...WC.CC
+
+Offenses:
+
+lib/foo.rb:6:5: C: Missing top-level class documentation comment.
+    class Foo
+    ^^^^^
+
+...
+
+26 files inspected, 46 offenses detected
+```
+
+### Clang Style Formatter
+
+The `clang` formatter displays the offenses in a manner similar to `clang`:
+
+```
+$ rubocop test.rb
+test.rb:1:1: C: Use snake_case for methods and variables.
+def badName
+    ^^^^^^^
+test.rb:2:3: C: Favor modifier if/unless usage when you have a single-line body. Another good alternative is the usage of control flow &&/||.
+  if something
+  ^^
+test.rb:4:5: W: end at 4, 4 is not aligned with if at 2, 2
+    end
+    ^^^
+
+1 file inspected, 3 offenses detected
+```
+
+### Fuubar Style Formatter
+
+The `fuubar` style formatter displays a progress bar
+and shows details of offenses in the `clang` format as soon as they are detected.
+This is inspired by the [Fuubar](https://github.com/jeffkreeftmeijer/fuubar) formatter for RSpec.
+
+```
+$ rubocop --format fuubar
+lib/foo.rb.rb:1:1: C: Use snake_case for methods and variables.
+def badName
+    ^^^^^^^
+lib/bar.rb:13:14: W: File.exists? is deprecated in favor of File.exist?.
+        File.exists?(path)
+             ^^^^^^^
+ 22/53 files |======== 43 ========>                           |  ETA: 00:00:02
+```
+
+### Emacs Style Formatter
+
+**Machine-parsable**
+
+The `emacs` formatter displays the offenses in a format suitable for consumption by `Emacs` (and possibly other tools).
+
+```
+$ rubocop --format emacs test.rb
+/Users/bozhidar/projects/test.rb:1:1: C: Use snake_case for methods and variables.
+/Users/bozhidar/projects/test.rb:2:3: C: Favor modifier if/unless usage when you have a single-line body. Another good alternative is the usage of control flow &&/||.
+/Users/bozhidar/projects/test.rb:4:5: W: end at 4, 4 is not aligned with if at 2, 2
+```
+
+### Simple Formatter
+
+The name of the formatter says it all :-)
+
+```
+$ rubocop --format simple test.rb
+== test.rb ==
+C:  1:  1: Use snake_case for methods and variables.
+C:  2:  3: Favor modifier if/unless usage when you have a single-line body. Another good alternative is the usage of control flow &&/||.
+W:  4:  5: end at 4, 4 is not aligned with if at 2, 2
+
+1 file inspected, 3 offenses detected
+```
+
+### File List Formatter
+
+ **Machine-parsable**
+
+Sometimes you might want to just open all files with offenses in your
+favorite editor. This formatter outputs just the names of the files
+with offenses in them and makes it possible to do something like:
+
+```
+$ rubocop --format files | xargs vim
+```
+
+### JSON Formatter
+
+**Machine-parsable**
+
+You can get RuboCop's inspection result in JSON format by passing `--format json` option in command line.
+The JSON structure is like the following example:
+
+```javascript
+{
+  "metadata": {
+    "rubocop_version": "0.9.0",
+    "ruby_engine": "ruby",
+    "ruby_version": "2.0.0",
+    "ruby_patchlevel": "195",
+    "ruby_platform": "x86_64-darwin12.3.0"
+  },
+  "files": [{
+      "path": "lib/foo.rb",
+      "offenses": []
+    }, {
+      "path": "lib/bar.rb",
+      "offenses": [{
+          "severity": "convention",
+          "message": "Line is too long. [81/80]",
+          "cop_name": "LineLength",
+          "corrected": true,
+          "location": {
+            "line": 546,
+            "column": 80,
+            "length": 4
+          }
+        }, {
+          "severity": "warning",
+          "message": "Unreachable code detected.",
+          "cop_name": "UnreachableCode",
+          "corrected": false,
+          "location": {
+            "line": 15,
+            "column": 9,
+            "length": 10
+          }
+        }
+      ]
+    }
+  ],
+  "summary": {
+    "offense_count": 2,
+    "target_file_count": 2,
+    "inspected_file_count": 2
+  }
+}
+```
+
+### Offense Count Formatter
+
+Sometimes when first applying RuboCop to a codebase, it's nice to be able to
+see where most of your style cleanup is going to be spent.
+
+With this in mind, you can use the offense count formatter to outline the offended
+cops and the number of offenses found for each by running:
+
+```
+$ rubocop --format offenses
+
+87   Documentation
+12   DotPosition
+8    AvoidGlobalVars
+7    EmptyLines
+6    AssignmentInCondition
+4    Blocks
+4    CommentAnnotation
+3    BlockAlignment
+1    IndentationWidth
+1    AvoidPerlBackrefs
+1    ColonMethodCall
+--
+134  Total
+```
+
+## Compatibility
+
+RuboCop supports the following Ruby implementations:
+
+* MRI 1.9.3
+* MRI 2.0
+* MRI 2.1
+* JRuby in 1.9 mode
+* Rubinius 2.0+
+
+## Editor integration
+
+### Emacs
+
+[rubocop.el](https://github.com/bbatsov/rubocop-emacs) is a simple
+Emacs interface for RuboCop. It allows you to run RuboCop inside Emacs
+and quickly jump between problems in your code.
+
+[flycheck](https://github.com/lunaryorn/flycheck) > 0.9 also supports
+RuboCop and uses it by default when available.
+
+### Vim
+
+The [vim-rubocop](https://github.com/ngmy/vim-rubocop) plugin runs
+RuboCop and displays the results in Vim.
+
+There's also a RuboCop checker in
+[syntastic](https://github.com/scrooloose/syntastic).
+
+### Sublime Text
+
+If you're a ST user you might find the
+[Sublime RuboCop plugin](https://github.com/pderichs/sublime_rubocop)
+useful.
+
+### Brackets
+
+The [brackets-rubocop](https://github.com/smockle/brackets-rubocop)
+extension displays RuboCop results in Brackets.
+It can be installed via the extension manager in Brackets.
+
+### TextMate2
+
+The [textmate2-rubocop](https://github.com/mrdougal/textmate2-rubocop)
+bundle displays formatted RuboCop results in a new window.
+Installation instructions can be found [here](https://github.com/mrdougal/textmate2-rubocop#installation).
+
+### Atom
+
+The [atom-lint](https://github.com/yujinakayama/atom-lint) package
+runs RuboCop and highlights the offenses in Atom.
+
+You can also use the [linter-rubocop](https://github.com/AtomLinter/linter-rubocop)
+plugin for Atom's [linter](https://github.com/AtomLinter/Linter).
+
+### LightTable
+
+The [lt-rubocop](https://github.com/seancaffery/lt-rubocop) plugin
+provides LightTable integration.
+
+### Other Editors
+
+Here's one great opportunity to contribute to RuboCop - implement
+RuboCop integration for your favorite editor.
+
+## Guard integration
+
+If you're fond of [Guard](https://github.com/guard/guard) you might
+like
+[guard-rubocop](https://github.com/yujinakayama/guard-rubocop). It
+allows you to automatically check Ruby code style with RuboCop when
+files are modified.
+
+
+## Rake integration
+
+To use RuboCop in your `Rakefile` add the following:
+
+```ruby
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+```
+
+The above will use default values
+
+```ruby
+require 'rubocop/rake_task'
+
+desc 'Run RuboCop on the lib directory'
+RuboCop::RakeTask.new(:rubocop) do |task|
+  task.patterns = ['lib/**/*.rb']
+  # only show the files with failures
+  task.formatters = ['files']
+  # don't abort rake on failure
+  task.fail_on_error = false
+end
+```
+
+## Extensions
+
+It's possible to extend RuboCop with custom cops and formatters.
+
+### Loading Extensions
+
+Besides the `--require` command line option you can also specify ruby
+files that should be loaded with the optional `require` directive in the
+`.rubocop.yml` file:
+
+```yaml
+require:
+ - ../my/custom/file.rb
+ - rubocop-extension
+```
+
+Note: The pathes are directly passed to `Kernel.require`.  If your
+extension file is not in `$LOAD_PATH`, you need to specify the path as
+relative path prefixed with `./` explicitly, or absolute path.
+
+### Custom Cops
+
+You can configure the custom cops in your `.rubocop.yml` just like any
+other cop.
+
+#### Known Custom Cops
+
+* [rubocop-rspec](https://github.com/nevir/rubocop-rspec) -
+  RSpec-specific analysis
+
+### Custom Formatters
+
+You can customize RuboCop's output format with custom formatters.
+
+#### Creating Custom Formatter
+
+To implement a custom formatter, you need to subclass
+`RuboCop::Formatter::BaseFormatter` and override some methods,
+or implement all formatter API methods by duck typing.
+
+Please see the documents below for more formatter API details.
+
+* [RuboCop::Formatter::BaseFormatter](http://rubydoc.info/gems/rubocop/RuboCop/Formatter/BaseFormatter)
+* [RuboCop::Cop::Offense](http://rubydoc.info/gems/rubocop/RuboCop/Cop/Offense)
+* [Parser::Source::Range](http://rubydoc.info/github/whitequark/parser/Parser/Source/Range)
+
+#### Using Custom Formatter in Command Line
+
+You can tell RuboCop to use your custom formatter with a combination of
+`--format` and `--require` option.
+For example, when you have defined `MyCustomFormatter` in
+`./path/to/my_custom_formatter.rb`, you would type this command:
+
+```
+$ rubocop --require ./path/to/my_custom_formatter --format MyCustomFormatter
+```
+
+## Team
+
+Here's a list of RuboCop's core developers:
+
+* [Bozhidar Batsov](https://github.com/bbatsov)
+* [Jonas Arvidsson](https://github.com/jonas054)
+* [Yuji Nakayama](https://github.com/yujinakayama)
+* [Evgeni Dzhelyov](https://github.com/edzhelyov)
+
+## Contributors
+
+Here's a [list](https://github.com/bbatsov/rubocop/contributors) of
+all the people who have contributed to the development of RuboCop.
+
+I'm extremely grateful to each and every one of them!
+
+If you'd like to contribute to RuboCop, please take the time to go
+through our short
+[contribution guidelines](CONTRIBUTING.md).
+
+Converting more of the Ruby Style Guide into RuboCop cops is our top
+priority right now. Writing a new cop is a great way to dive into RuboCop!
+
+Of course, bug reports and suggestions for improvements are always
+welcome. GitHub pull requests are even better! :-)
+
+I'm also accepting financial contributions via [gittip](https://www.gittip.com/bbatsov).
+
+[![Support via Gittip](https://rawgithub.com/twolfson/gittip-badge/0.2.0/dist/gittip.png)](https://www.gittip.com/bbatsov)
+
+## Mailing List
+
+If you're interested in everything regarding RuboCop's development,
+consider joining its
+[Google Group](https://groups.google.com/forum/?fromgroups#!forum/rubocop).
+
+## Freenode
+
+If you're into IRC you can visit the `#rubocop` channel on Freenode.
+
+## Changelog
+
+RuboCop's changelog is available [here](CHANGELOG.md).
+
+## Copyright
+
+Copyright (c) 2012-2014 Bozhidar Batsov. See [LICENSE.txt](LICENSE.txt) for
+further details.