{"action":"created","comment":{"url":"https://api.github.com/repos/elastic/logstash/pulls/comments/32974845","id":32974845,"diff_hunk":"@@ -0,0 +1,3293 @@\n+# Prelude\n+\n+This guide is intended to become a reference for logstash developers, a central place where contributor can refer when in doubt about how to style their code. Nevertheless an style guide is also useful to make the code look similar, reducing complexities and especially when groups of contributors are growing.\n+\n+This style guide is based on the [guide][rails-style-guide] created by Bozhidar Batsov for [Rubocop][RuboCop], The Airbnb [guide][Airbnb], the Logstash team inputs, and others. There is also a rubocop file used to check this guide automatically.\n+\n+## Table of Contents\n+\n+* [Source Code Layout](#source-code-layout)\n+* [Syntax](#syntax)\n+* [Naming](#naming)\n+* [Comments](#comments)\n+  * [Comment Annotations](#comment-annotations)\n+* [Classes](#classes--modules)\n+* [Exceptions](#exceptions)\n+* [Collections](#collections)\n+* [Strings](#strings)\n+* [Regular Expressions](#regular-expressions)\n+* [Percent Literals](#percent-literals)\n+* [Metaprogramming](#metaprogramming)\n+\n+## Source Code Layout\n+\n+  * Use `UTF-8` as the source file encoding. If you're using a ruby version older than 2.0, adding ```# encoding: utf-8``` on top of a ruby file will tell the compiler to use this encoding by default. If using a ruby VM older than 2.0, `UTF-8` is the default encoding.\n+\n+ * Use two **spaces** per indentation level (aka soft tabs). No hard tabs.\n+\n+  ```Ruby\n+  # bad - four spaces\n+  def some_method\n+      do_something\n+  end\n+\n+  # good\n+  def some_method\n+    do_something\n+  end\n+  ```\n+\n+ *  Don't use `;` to separate statements and expressions. As a corollary - use one expression per line.\n+\n+  ```Ruby\n+  # bad\n+  puts 'foobar'; # superfluous semicolon\n+\n+  puts 'foo'; puts 'bar' # two expressions on the same line\n+\n+  # good\n+  puts 'foobar'\n+\n+  puts 'foo'\n+  puts 'bar'\n+\n+  puts 'foo', 'bar' # this applies to puts in particular\n+  ```\n+\n+  * Prefer a single-line format for class definitions with no body.\n+\n+  ```Ruby\n+  # bad\n+  class FooError < StandardError\n+  end\n+\n+  # okish\n+  class FooError < StandardError; end\n+\n+  # good\n+  FooError = Class.new(StandardError)\n+  ```\n+\n+  * Avoid single-line methods. Although they are somewhat popular in the wild, there are a few peculiarities about their definition syntax that make their use undesirable. At any rate - there should be no more than one expression in a single-line method.\n+\n+  ```Ruby\n+  # bad\n+  def too_much; something; something_else; end\n+\n+  # okish - notice that the first ; is required\n+  def no_braces_method; body end\n+\n+  # okish - notice that the second ; is optional\n+  def no_braces_method; body; end\n+\n+  # okish - valid syntax, but no ; makes it kind of hard to read\n+  def some_method() body end\n+\n+  # good\n+  def some_method\n+    body\n+  end\n+  ```\n+\n+  One exception to the rule are empty-body methods.\n+\n+  ```Ruby\n+  # good\n+  def no_op; end\n+  ```\n+\n+  * Use spaces around operators, after commas, colons and semicolons, around `{` and before `}`. Whitespace might be (mostly) irrelevant to the Ruby interpreter, but its proper use is the key to writing easily readable code.\n+\n+  ```Ruby\n+  sum = 1 + 2\n+  a, b = 1, 2\n+  [1, 2, 3].each { |e| puts e }\n+  class FooError < StandardError; end\n+  ```\n+\n+  The only exception, regarding operators, is the exponent operator:\n+\n+  ```Ruby\n+  # bad\n+  e = M * c ** 2\n+\n+  # good\n+  e = M * c**2\n+  ```\n+\n+  `{` and `}` deserve a bit of clarification, since they are used for block and hash literals, as well as string interpolation. For hash literals two styles are considered acceptable.\n+\n+  ```Ruby\n+  # good - space after { and before }\n+  { one: 1, two: 2 }\n+\n+  # good - no space after { and before }\n+  {one: 1, two: 2}\n+  ```\n+\n+  The first variant is slightly more readable (and arguably more popular in the Ruby community in general). The second variant has the advantage of adding visual difference between block and hash literals. Whichever one you pick - apply it consistently.\n+\n+  * No spaces after `(`, `[` or before `]`, `)`.\n+\n+  ```Ruby\n+  some(arg).other\n+  [1, 2, 3].size\n+  ```\n+\n+ *  No space after `!`.\n+\n+  ```Ruby\n+  # bad\n+  ! something\n+\n+  # good\n+  !something\n+  ```\n+\n+  * No space inside range literals.\n+\n+    ```Ruby\n+    # bad\n+    1 .. 3\n+    'a' ... 'z'\n+\n+    # good\n+    1..3\n+    'a'...'z'\n+    ```\n+\n+* Indent `when` as deep as `case`. I know that many would disagree with this one, but it's the style established in both \"The Ruby Programming Language\" and \"Programming Ruby\".\n+\n+  ```Ruby\n+  # bad\n+  case\n+    when song.name == 'Misty'\n+      puts 'Not again!'\n+    when song.duration > 120\n+      puts 'Too long!'\n+    when Time.now.hour > 21\n+      puts \"It's too late\"\n+    else\n+      song.play\n+  end\n+\n+  # good\n+  case\n+  when song.name == 'Misty'\n+    puts 'Not again!'\n+  when song.duration > 120\n+    puts 'Too long!'\n+  when Time.now.hour > 21\n+    puts \"It's too late\"\n+  else\n+    song.play\n+  end\n+  ```\n+\n+* When assigning the result of a conditional expression to a variable, preserve the usual alignment of its branches.\n+\n+  ```Ruby\n+  # bad - pretty convoluted\n+  kind = case year\n+  when 1850..1889 then 'Blues'\n+  when 1890..1909 then 'Ragtime'\n+  when 1910..1929 then 'New Orleans Jazz'\n+  when 1930..1939 then 'Swing'\n+  when 1940..1950 then 'Bebop'\n+  else 'Jazz'\n+  end\n+\n+  result = if some_cond\n+    calc_something\n+  else\n+    calc_something_else\n+  end\n+\n+  # good - it's apparent what's going on\n+  kind = case year\n+         when 1850..1889 then 'Blues'\n+         when 1890..1909 then 'Ragtime'\n+         when 1910..1929 then 'New Orleans Jazz'\n+         when 1930..1939 then 'Swing'\n+         when 1940..1950 then 'Bebop'\n+         else 'Jazz'\n+         end\n+\n+  result = if some_cond\n+             calc_something\n+           else\n+             calc_something_else\n+           end\n+\n+  # good (and a bit more width efficient)\n+  kind =\n+    case year\n+    when 1850..1889 then 'Blues'\n+    when 1890..1909 then 'Ragtime'\n+    when 1910..1929 then 'New Orleans Jazz'\n+    when 1930..1939 then 'Swing'\n+    when 1940..1950 then 'Bebop'\n+    else 'Jazz'\n+    end\n+\n+  result =\n+    if some_cond\n+      calc_something\n+    else\n+      calc_something_else\n+    end\n+  ```\n+\n+* Use empty lines between method definitions and also to break up a method into logical paragraphs internally.\n+\n+  ```Ruby\n+  def some_method\n+    data = initialize(options)\n+\n+    data.manipulate!\n+\n+    data.result\n+  end\n+\n+  def some_method\n+    result\n+  end\n+  ```\n+\n+* Avoid comma after the last parameter in a method call, especially when the parameters are not on separate lines.\n+\n+  ```Ruby\n+  # bad - easier to move/add/remove parameters, but still not preferred\n+  some_method(\n+               size,\n+               count,\n+               color,\n+             )\n+\n+  # bad\n+  some_method(size, count, color, )\n+\n+  # good\n+  some_method(size, count, color)\n+  ```\n+\n+* Avoid line continuation `\\` where not required. In practice, avoid using line continuations for anything but string concatenation.\n+\n+  ```Ruby\n+  # bad\n+  result = 1 - \\\n+           2\n+\n+  # good (but still ugly as hell)\n+  result = 1 \\\n+           - 2\n+\n+  long_string = 'First part of the long string' \\\n+                ' and second part of the long string'\n+  ```\n+\n+* Adopt a consistent multi-line method chaining style. There are two popular styles in the Ruby community, both of which are considered good - leading `.` (Option A) and trailing `.` (Option B).\n+\n+  * **(Option A)** When continuing a chained method invocation on\n+    another line keep the `.` on the second line.\n+\n+    ```Ruby\n+    # bad - need to consult first line to understand second line\n+    one.two.three.\n+      four\n+\n+    # good - it's immediately clear what's going on the second line\n+    one.two.three\n+      .four\n+    ```\n+\n+  * **(Option B)** When continuing a chained method invocation on another line,\n+    include the `.` on the first line to indicate that the\n+    expression continues.\n+\n+    ```Ruby\n+    # bad - need to read ahead to the second line to know that the chain continues\n+    one.two.three\n+      .four\n+\n+    # good - it's immediately clear that the expression continues beyond the first line\n+    one.two.three.\n+      four\n+    ```\n+\n+  A discussion on the merits of both alternative styles can be found\n+  [here](https://github.com/bbatsov/ruby-style-guide/pull/176).\n+\n+* Align the parameters of a method call if they span more than one line. When aligning parameters is not appropriate due to line-length constraints, single indent for the lines after the first is also acceptable.\n+\n+  ```Ruby\n+  # starting point (line is too long)\n+  def send_mail(source)\n+    Mailer.deliver(to: 'bob@example.com', from: 'us@example.com', subject: 'Important message', body: source.text)\n+  end\n+\n+  # bad (double indent)\n+  def send_mail(source)\n+    Mailer.deliver(\n+        to: 'bob@example.com',\n+        from: 'us@example.com',\n+        subject: 'Important message',\n+        body: source.text)\n+  end\n+\n+  # good\n+  def send_mail(source)\n+    Mailer.deliver(to: 'bob@example.com',\n+                   from: 'us@example.com',\n+                   subject: 'Important message',\n+                   body: source.text)\n+  end\n+\n+  # good (normal indent)\n+  def send_mail(source)\n+    Mailer.deliver(\n+      to: 'bob@example.com',\n+      from: 'us@example.com',\n+      subject: 'Important message',\n+      body: source.text\n+    )\n+  end\n+  ```\n+\n+* Align the elements of array literals spanning multiple lines.\n+\n+  ```Ruby\n+  # bad - single indent\n+  menu_item = ['Spam', 'Spam', 'Spam', 'Spam', 'Spam', 'Spam', 'Spam', 'Spam',\n+    'Baked beans', 'Spam', 'Spam', 'Spam', 'Spam', 'Spam']\n+\n+  # good\n+  menu_item = [\n+    'Spam', 'Spam', 'Spam', 'Spam', 'Spam', 'Spam', 'Spam', 'Spam',\n+    'Baked beans', 'Spam', 'Spam', 'Spam', 'Spam', 'Spam'\n+  ]\n+\n+  # good\n+  menu_item =\n+    ['Spam', 'Spam', 'Spam', 'Spam', 'Spam', 'Spam', 'Spam', 'Spam',\n+     'Baked beans', 'Spam', 'Spam', 'Spam', 'Spam', 'Spam']\n+  ```\n+\n+* Add underscores to large numeric literals to improve their readability.\n+\n+  ```Ruby\n+  # bad - how many 0s are there?\n+  num = 1000000\n+\n+  # good - much easier to parse for the human brain\n+  num = 1_000_000\n+  ```\n+\n+ * Use RDoc and its conventions for API documentation.  Don't put an empty line between the comment block and the `def`.\n+\n+  * Limit lines to 80 characters.\n+  * Avoid trailing whitespace.\n+  * End each file with a newline.\n+  * Don't use block comments. They cannot be preceded by whitespace and are not as easy to spot as regular comments.\n+\n+  ```Ruby\n+  # bad\n+  =begin\n+  comment line\n+  another comment line\n+  =end\n+\n+  # good\n+  # comment line\n+  # another comment line\n+  ```\n+\n+## Syntax\n+\n+* <a name=\"double-colons\"></a>\n+    Use `::` only to reference constants(this includes classes and\n+    modules) and constructors (like `Array()` or `Nokogiri::HTML()`).\n+    Do not use `::` for regular method invocation.\n+<sup>[[link](#double-colons)]</sup>\n+\n+  ```Ruby\n+  # bad\n+  SomeClass::some_method\n+  some_object::some_method\n+\n+  # good\n+  SomeClass.some_method\n+  some_object.some_method\n+  SomeModule::SomeClass::SOME_CONST\n+  SomeModule::SomeClass()\n+  ```\n+\n+* <a name=\"method-parens\"></a>\n+    Use `def` with parentheses when there are parameters. Omit the\n+    parentheses when the method doesn't accept any parameters.\n+<sup>[[link](#method-parens)]</sup>\n+\n+   ```Ruby\n+   # bad\n+   def some_method()\n+     # body omitted\n+   end\n+\n+   # good\n+   def some_method\n+     # body omitted\n+   end\n+\n+   # bad\n+   def some_method_with_parameters param1, param2\n+     # body omitted\n+   end\n+\n+   # good\n+   def some_method_with_parameters(param1, param2)\n+     # body omitted\n+   end\n+   ```\n+\n+* <a name=\"parallel-assignment\"></a>\n+    Avoid the use of parallel assignment for defining variables. Parallel\n+    assignment is allowed when it is the return of a method call, used with\n+    the splat operator, or when used to swap variable assignment. Parallel\n+    assignment is less readable than separate assignment. It is also slightly\n+    slower than separate assignment.\n+<sup>[[link](#parallel-assignment)]</sup>\n+\n+  ```Ruby\n+  # bad\n+  a, b, c, d = 'foo', 'bar', 'baz', 'foobar'\n+\n+  # good\n+  a = 'foo'\n+  b = 'bar'\n+  c = 'baz'\n+  d = 'foobar'\n+\n+  # good - swapping variable assignment\n+  # Swapping variable assignment is a special case because it will allow you to\n+  # swap the values that are assigned to each variable.\n+  a = 'foo'\n+  b = 'bar'\n+\n+  a, b = b, a\n+  puts a # => 'bar'\n+  puts b # => 'foo'\n+\n+  # good - method return\n+  def multi_return\n+    [1, 2]\n+  end\n+\n+  first, second = multi_return\n+\n+  # good - use with splat\n+  first, *list = [1,2,3,4]\n+\n+  hello_array = *\"Hello\"\n+\n+  a = *(1..3)\n+  ```\n+\n+* <a name=\"no-for-loops\"></a>\n+    Do not use `for`, unless you know exactly why. Most of the time iterators\n+    should be used instead. `for` is implemented in terms of `each` (so\n+    you're adding a level of indirection), but with a twist - `for`\n+    doesn't introduce a new scope (unlike `each`) and variables defined\n+    in its block will be visible outside it.\n+<sup>[[link](#no-for-loops)]</sup>\n+\n+  ```Ruby\n+  arr = [1, 2, 3]\n+\n+  # bad\n+  for elem in arr do\n+    puts elem\n+  end\n+\n+  # note that elem is accessible outside of the for loop\n+  elem # => 3\n+\n+  # good\n+  arr.each { |elem| puts elem }\n+\n+  # elem is not accessible outside each's block\n+  elem # => NameError: undefined local variable or method `elem'\n+  ```\n+\n+* <a name=\"no-then\"></a>\n+  Do not use `then` for multi-line `if/unless`.\n+<sup>[[link](#no-then)]</sup>\n+\n+  ```Ruby\n+  # bad\n+  if some_condition then\n+    # body omitted\n+  end\n+\n+  # good\n+  if some_condition\n+    # body omitted\n+  end\n+  ```\n+\n+* <a name=\"same-line-condition\"></a>\n+  Always put the condition on the same line as the `if`/`unless` in a\n+  multi-line conditional.\n+<sup>[[link](#same-line-condition)]</sup>\n+\n+  ```Ruby\n+  # bad\n+  if\n+    some_condition\n+    do_something\n+    do_something_else\n+  end\n+\n+  # good\n+  if some_condition\n+    do_something\n+    do_something_else\n+  end\n+  ```\n+\n+* <a name=\"ternary-operator\"></a>\n+  Favor the ternary operator(`?:`) over `if/then/else/end` constructs.\n+  It's more common and obviously more concise.\n+<sup>[[link](#ternary-operator)]</sup>\n+\n+  ```Ruby\n+  # bad\n+  result = if some_condition then something else something_else end\n+\n+  # good\n+  result = some_condition ? something : something_else\n+  ```\n+\n+* <a name=\"no-semicolon-ifs\"></a>\n+  Do not use `if x; ...`. Use the ternary operator instead.\n+<sup>[[link](#no-semicolon-ifs)]</sup>\n+\n+  ```Ruby\n+  # bad\n+  result = if some_condition; something else something_else end\n+\n+  # good\n+  result = some_condition ? something : something_else\n+  ```\n+\n+* <a name=\"bang-not-not\"></a>\n+  Use `!` instead of `not`.\n+<sup>[[link](#bang-not-not)]</sup>\n+\n+  ```Ruby\n+  # bad - braces are required because of op precedence\n+  x = (not something)\n+\n+  # good\n+  x = !something\n+  ```\n+\n+* <a name=\"no-bang-bang\"></a>\n+  Avoid the use of `!!`.\n+<sup>[[link](#no-bang-bang)]</sup>\n+\n+  ```Ruby\n+  # bad\n+  x = 'test'\n+  # obscure nil check\n+  if !!x\n+    # body omitted\n+  end\n+\n+  x = false\n+  # double negation is useless on booleans\n+  !!x # => false\n+\n+  # good\n+  x = 'test'\n+  unless x.nil?\n+    # body omitted\n+  end\n+  ```\n+\n+* <a name=\"no-and-or-or\"></a>\n+  No usage of the `and` and `or` keywords is accepted. Always use `&&` and `||` instead.\n+<sup>[[link](#no-and-or-or)]</sup>\n+\n+  ```Ruby\n+  # bad\n+  # boolean expression\n+  if some_condition and some_other_condition\n+    do_something\n+  end\n+\n+  # control flow\n+  document.saved? or document.save!\n+\n+  # good\n+  # boolean expression\n+  if some_condition && some_other_condition\n+    do_something\n+  end\n+\n+  # control flow\n+  document.saved? || document.save!\n+  ```\n+\n+* <a name=\"no-multiline-ternary\"></a>\n+  Avoid multi-line `?:` (the ternary operator); use `if/unless` instead.\n+<sup>[[link](#no-multiline-ternary)]</sup>\n+\n+* <a name=\"if-as-a-modifier\"></a>\n+  Favor modifier `if/unless` usage when you have a single-line body. Another\n+  good alternative is the usage of control flow `&&/||`.\n+<sup>[[link](#if-as-a-modifier)]</sup>\n+\n+  ```Ruby\n+  # bad\n+  if some_condition\n+    do_something\n+  end\n+\n+  # good\n+  do_something if some_condition\n+\n+  # another good option\n+  some_condition && do_something\n+  ```\n+\n+* <a name=\"no-multiline-if-modifiers\"></a>\n+  Avoid modifier `if/unless` usage at the end of a non-trivial multi-line\n+  block.\n+<sup>[[link](#no-multiline-if-modifiers)]</sup>\n+\n+  ```Ruby\n+  # bad\n+  10.times do\n+    # multi-line body omitted\n+  end if some_condition\n+\n+  # good\n+  if some_condition\n+    10.times do\n+      # multi-line body omitted\n+    end\n+  end\n+  ```\n+\n+* <a name=\"unless-for-negatives\"></a>\n+\n+Avoid usage of `unless` over negative conditions (or control flow), it\n+can cause issues when having multi term expressions.\n+<sup>[[link](#unless-for-negatives)]</sup>\n+\n+  ```Ruby\n+  # bad\n+  do_something unless some_condition\n+\n+  # good\n+  do_something if !some_condition","path":"CODE_STYLE.md","position":693,"original_position":693,"commit_id":"b7a3d5ce7dba3c5d1168753a8eac88c60f686f8c","original_commit_id":"b7a3d5ce7dba3c5d1168753a8eac88c60f686f8c","user":{"login":"colinsurprenant","id":2010,"avatar_url":"https://avatars.githubusercontent.com/u/2010?v=3","gravatar_id":"","url":"https://api.github.com/users/colinsurprenant","html_url":"https://github.com/colinsurprenant","followers_url":"https://api.github.com/users/colinsurprenant/followers","following_url":"https://api.github.com/users/colinsurprenant/following{/other_user}","gists_url":"https://api.github.com/users/colinsurprenant/gists{/gist_id}","starred_url":"https://api.github.com/users/colinsurprenant/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/colinsurprenant/subscriptions","organizations_url":"https://api.github.com/users/colinsurprenant/orgs","repos_url":"https://api.github.com/users/colinsurprenant/repos","events_url":"https://api.github.com/users/colinsurprenant/events{/privacy}","received_events_url":"https://api.github.com/users/colinsurprenant/received_events","type":"User","site_admin":false},"body":"+1 and I love unless ;)","created_at":"2015-06-22T19:43:39Z","updated_at":"2015-06-22T19:43:39Z","html_url":"https://github.com/elastic/logstash/pull/3485#discussion_r32974845","pull_request_url":"https://api.github.com/repos/elastic/logstash/pulls/3485","_links":{"self":{"href":"https://api.github.com/repos/elastic/logstash/pulls/comments/32974845"},"html":{"href":"https://github.com/elastic/logstash/pull/3485#discussion_r32974845"},"pull_request":{"href":"https://api.github.com/repos/elastic/logstash/pulls/3485"}}},"pull_request":{"url":"https://api.github.com/repos/elastic/logstash/pulls/3485","id":38251831,"html_url":"https://github.com/elastic/logstash/pull/3485","diff_url":"https://github.com/elastic/logstash/pull/3485.diff","patch_url":"https://github.com/elastic/logstash/pull/3485.patch","issue_url":"https://api.github.com/repos/elastic/logstash/issues/3485","number":3485,"state":"open","locked":false,"title":"Add a ruby style guide plus a matching rubocop file","user":{"login":"purbon","id":68540,"avatar_url":"https://avatars.githubusercontent.com/u/68540?v=3","gravatar_id":"","url":"https://api.github.com/users/purbon","html_url":"https://github.com/purbon","followers_url":"https://api.github.com/users/purbon/followers","following_url":"https://api.github.com/users/purbon/following{/other_user}","gists_url":"https://api.github.com/users/purbon/gists{/gist_id}","starred_url":"https://api.github.com/users/purbon/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/purbon/subscriptions","organizations_url":"https://api.github.com/users/purbon/orgs","repos_url":"https://api.github.com/users/purbon/repos","events_url":"https://api.github.com/users/purbon/events{/privacy}","received_events_url":"https://api.github.com/users/purbon/received_events","type":"User","site_admin":false},"body":"This PR is a working progress PR with an initial version of the style guide, only roughly edited the first two bullet points, and a matching rubocop file.\r\n\r\nFeel free to dump here your particular points of views about the style guide, as soon as we've an initial agreement over the style guide, we'll create matching rubocop checks for that.\r\n\r\nFixes #3462\r\n","created_at":"2015-06-22T16:46:33Z","updated_at":"2015-06-22T19:43:39Z","closed_at":null,"merged_at":null,"merge_commit_sha":"e3cc902404c0667624c1858dc83cdc7e42b51946","assignee":null,"milestone":null,"commits_url":"https://api.github.com/repos/elastic/logstash/pulls/3485/commits","review_comments_url":"https://api.github.com/repos/elastic/logstash/pulls/3485/comments","review_comment_url":"https://api.github.com/repos/elastic/logstash/pulls/comments{/number}","comments_url":"https://api.github.com/repos/elastic/logstash/issues/3485/comments","statuses_url":"https://api.github.com/repos/elastic/logstash/statuses/b7a3d5ce7dba3c5d1168753a8eac88c60f686f8c","head":{"label":"purbon:feature/style_guide","ref":"feature/style_guide","sha":"b7a3d5ce7dba3c5d1168753a8eac88c60f686f8c","user":{"login":"purbon","id":68540,"avatar_url":"https://avatars.githubusercontent.com/u/68540?v=3","gravatar_id":"","url":"https://api.github.com/users/purbon","html_url":"https://github.com/purbon","followers_url":"https://api.github.com/users/purbon/followers","following_url":"https://api.github.com/users/purbon/following{/other_user}","gists_url":"https://api.github.com/users/purbon/gists{/gist_id}","starred_url":"https://api.github.com/users/purbon/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/purbon/subscriptions","organizations_url":"https://api.github.com/users/purbon/orgs","repos_url":"https://api.github.com/users/purbon/repos","events_url":"https://api.github.com/users/purbon/events{/privacy}","received_events_url":"https://api.github.com/users/purbon/received_events","type":"User","site_admin":false},"repo":{"id":26748658,"name":"logstash","full_name":"purbon/logstash","owner":{"login":"purbon","id":68540,"avatar_url":"https://avatars.githubusercontent.com/u/68540?v=3","gravatar_id":"","url":"https://api.github.com/users/purbon","html_url":"https://github.com/purbon","followers_url":"https://api.github.com/users/purbon/followers","following_url":"https://api.github.com/users/purbon/following{/other_user}","gists_url":"https://api.github.com/users/purbon/gists{/gist_id}","starred_url":"https://api.github.com/users/purbon/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/purbon/subscriptions","organizations_url":"https://api.github.com/users/purbon/orgs","repos_url":"https://api.github.com/users/purbon/repos","events_url":"https://api.github.com/users/purbon/events{/privacy}","received_events_url":"https://api.github.com/users/purbon/received_events","type":"User","site_admin":false},"private":false,"html_url":"https://github.com/purbon/logstash","description":"logstash - logs/event transport, processing, management, search.","fork":true,"url":"https://api.github.com/repos/purbon/logstash","forks_url":"https://api.github.com/repos/purbon/logstash/forks","keys_url":"https://api.github.com/repos/purbon/logstash/keys{/key_id}","collaborators_url":"https://api.github.com/repos/purbon/logstash/collaborators{/collaborator}","teams_url":"https://api.github.com/repos/purbon/logstash/teams","hooks_url":"https://api.github.com/repos/purbon/logstash/hooks","issue_events_url":"https://api.github.com/repos/purbon/logstash/issues/events{/number}","events_url":"https://api.github.com/repos/purbon/logstash/events","assignees_url":"https://api.github.com/repos/purbon/logstash/assignees{/user}","branches_url":"https://api.github.com/repos/purbon/logstash/branches{/branch}","tags_url":"https://api.github.com/repos/purbon/logstash/tags","blobs_url":"https://api.github.com/repos/purbon/logstash/git/blobs{/sha}","git_tags_url":"https://api.github.com/repos/purbon/logstash/git/tags{/sha}","git_refs_url":"https://api.github.com/repos/purbon/logstash/git/refs{/sha}","trees_url":"https://api.github.com/repos/purbon/logstash/git/trees{/sha}","statuses_url":"https://api.github.com/repos/purbon/logstash/statuses/{sha}","languages_url":"https://api.github.com/repos/purbon/logstash/languages","stargazers_url":"https://api.github.com/repos/purbon/logstash/stargazers","contributors_url":"https://api.github.com/repos/purbon/logstash/contributors","subscribers_url":"https://api.github.com/repos/purbon/logstash/subscribers","subscription_url":"https://api.github.com/repos/purbon/logstash/subscription","commits_url":"https://api.github.com/repos/purbon/logstash/commits{/sha}","git_commits_url":"https://api.github.com/repos/purbon/logstash/git/commits{/sha}","comments_url":"https://api.github.com/repos/purbon/logstash/comments{/number}","issue_comment_url":"https://api.github.com/repos/purbon/logstash/issues/comments{/number}","contents_url":"https://api.github.com/repos/purbon/logstash/contents/{+path}","compare_url":"https://api.github.com/repos/purbon/logstash/compare/{base}...{head}","merges_url":"https://api.github.com/repos/purbon/logstash/merges","archive_url":"https://api.github.com/repos/purbon/logstash/{archive_format}{/ref}","downloads_url":"https://api.github.com/repos/purbon/logstash/downloads","issues_url":"https://api.github.com/repos/purbon/logstash/issues{/number}","pulls_url":"https://api.github.com/repos/purbon/logstash/pulls{/number}","milestones_url":"https://api.github.com/repos/purbon/logstash/milestones{/number}","notifications_url":"https://api.github.com/repos/purbon/logstash/notifications{?since,all,participating}","labels_url":"https://api.github.com/repos/purbon/logstash/labels{/name}","releases_url":"https://api.github.com/repos/purbon/logstash/releases{/id}","created_at":"2014-11-17T09:01:27Z","updated_at":"2015-05-08T13:53:55Z","pushed_at":"2015-06-22T18:50:41Z","git_url":"git://github.com/purbon/logstash.git","ssh_url":"git@github.com:purbon/logstash.git","clone_url":"https://github.com/purbon/logstash.git","svn_url":"https://github.com/purbon/logstash","homepage":"http://logstash.net/","size":72802,"stargazers_count":0,"watchers_count":0,"language":"Ruby","has_issues":false,"has_downloads":true,"has_wiki":true,"has_pages":false,"forks_count":0,"mirror_url":null,"open_issues_count":0,"forks":0,"open_issues":0,"watchers":0,"default_branch":"master"}},"base":{"label":"elastic:master","ref":"master","sha":"535027dfd9d280cfa18a14d2bf0257ffef4034fb","user":{"login":"elastic","id":6764390,"avatar_url":"https://avatars.githubusercontent.com/u/6764390?v=3","gravatar_id":"","url":"https://api.github.com/users/elastic","html_url":"https://github.com/elastic","followers_url":"https://api.github.com/users/elastic/followers","following_url":"https://api.github.com/users/elastic/following{/other_user}","gists_url":"https://api.github.com/users/elastic/gists{/gist_id}","starred_url":"https://api.github.com/users/elastic/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/elastic/subscriptions","organizations_url":"https://api.github.com/users/elastic/orgs","repos_url":"https://api.github.com/users/elastic/repos","events_url":"https://api.github.com/users/elastic/events{/privacy}","received_events_url":"https://api.github.com/users/elastic/received_events","type":"Organization","site_admin":false},"repo":{"id":1090311,"name":"logstash","full_name":"elastic/logstash","owner":{"login":"elastic","id":6764390,"avatar_url":"https://avatars.githubusercontent.com/u/6764390?v=3","gravatar_id":"","url":"https://api.github.com/users/elastic","html_url":"https://github.com/elastic","followers_url":"https://api.github.com/users/elastic/followers","following_url":"https://api.github.com/users/elastic/following{/other_user}","gists_url":"https://api.github.com/users/elastic/gists{/gist_id}","starred_url":"https://api.github.com/users/elastic/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/elastic/subscriptions","organizations_url":"https://api.github.com/users/elastic/orgs","repos_url":"https://api.github.com/users/elastic/repos","events_url":"https://api.github.com/users/elastic/events{/privacy}","received_events_url":"https://api.github.com/users/elastic/received_events","type":"Organization","site_admin":false},"private":false,"html_url":"https://github.com/elastic/logstash","description":"logstash - transport and process your logs, events, or other data","fork":false,"url":"https://api.github.com/repos/elastic/logstash","forks_url":"https://api.github.com/repos/elastic/logstash/forks","keys_url":"https://api.github.com/repos/elastic/logstash/keys{/key_id}","collaborators_url":"https://api.github.com/repos/elastic/logstash/collaborators{/collaborator}","teams_url":"https://api.github.com/repos/elastic/logstash/teams","hooks_url":"https://api.github.com/repos/elastic/logstash/hooks","issue_events_url":"https://api.github.com/repos/elastic/logstash/issues/events{/number}","events_url":"https://api.github.com/repos/elastic/logstash/events","assignees_url":"https://api.github.com/repos/elastic/logstash/assignees{/user}","branches_url":"https://api.github.com/repos/elastic/logstash/branches{/branch}","tags_url":"https://api.github.com/repos/elastic/logstash/tags","blobs_url":"https://api.github.com/repos/elastic/logstash/git/blobs{/sha}","git_tags_url":"https://api.github.com/repos/elastic/logstash/git/tags{/sha}","git_refs_url":"https://api.github.com/repos/elastic/logstash/git/refs{/sha}","trees_url":"https://api.github.com/repos/elastic/logstash/git/trees{/sha}","statuses_url":"https://api.github.com/repos/elastic/logstash/statuses/{sha}","languages_url":"https://api.github.com/repos/elastic/logstash/languages","stargazers_url":"https://api.github.com/repos/elastic/logstash/stargazers","contributors_url":"https://api.github.com/repos/elastic/logstash/contributors","subscribers_url":"https://api.github.com/repos/elastic/logstash/subscribers","subscription_url":"https://api.github.com/repos/elastic/logstash/subscription","commits_url":"https://api.github.com/repos/elastic/logstash/commits{/sha}","git_commits_url":"https://api.github.com/repos/elastic/logstash/git/commits{/sha}","comments_url":"https://api.github.com/repos/elastic/logstash/comments{/number}","issue_comment_url":"https://api.github.com/repos/elastic/logstash/issues/comments{/number}","contents_url":"https://api.github.com/repos/elastic/logstash/contents/{+path}","compare_url":"https://api.github.com/repos/elastic/logstash/compare/{base}...{head}","merges_url":"https://api.github.com/repos/elastic/logstash/merges","archive_url":"https://api.github.com/repos/elastic/logstash/{archive_format}{/ref}","downloads_url":"https://api.github.com/repos/elastic/logstash/downloads","issues_url":"https://api.github.com/repos/elastic/logstash/issues{/number}","pulls_url":"https://api.github.com/repos/elastic/logstash/pulls{/number}","milestones_url":"https://api.github.com/repos/elastic/logstash/milestones{/number}","notifications_url":"https://api.github.com/repos/elastic/logstash/notifications{?since,all,participating}","labels_url":"https://api.github.com/repos/elastic/logstash/labels{/name}","releases_url":"https://api.github.com/repos/elastic/logstash/releases{/id}","created_at":"2010-11-18T01:31:50Z","updated_at":"2015-06-22T06:33:44Z","pushed_at":"2015-06-22T18:50:45Z","git_url":"git://github.com/elastic/logstash.git","ssh_url":"git@github.com:elastic/logstash.git","clone_url":"https://github.com/elastic/logstash.git","svn_url":"https://github.com/elastic/logstash","homepage":"https://www.elastic.co/products/logstash","size":92569,"stargazers_count":4382,"watchers_count":4382,"language":"Ruby","has_issues":true,"has_downloads":true,"has_wiki":true,"has_pages":false,"forks_count":1469,"mirror_url":null,"open_issues_count":494,"forks":1469,"open_issues":494,"watchers":4382,"default_branch":"master"}},"_links":{"self":{"href":"https://api.github.com/repos/elastic/logstash/pulls/3485"},"html":{"href":"https://github.com/elastic/logstash/pull/3485"},"issue":{"href":"https://api.github.com/repos/elastic/logstash/issues/3485"},"comments":{"href":"https://api.github.com/repos/elastic/logstash/issues/3485/comments"},"review_comments":{"href":"https://api.github.com/repos/elastic/logstash/pulls/3485/comments"},"review_comment":{"href":"https://api.github.com/repos/elastic/logstash/pulls/comments{/number}"},"commits":{"href":"https://api.github.com/repos/elastic/logstash/pulls/3485/commits"},"statuses":{"href":"https://api.github.com/repos/elastic/logstash/statuses/b7a3d5ce7dba3c5d1168753a8eac88c60f686f8c"}}}}