parser 2.0.0.pre1 → 2.0.0.pre2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7973cc0cb9684725de9513915f651e9a29f92f0d
-  data.tar.gz: 81a7f321cf682eef0e757d64caec77174bb6235f
+  metadata.gz: f4144b03e5cb0074bd4e6a62442b3954365d7ec8
+  data.tar.gz: 4276d7b16e60596143e0cc22b19ef0f048446af5
 SHA512:
-  metadata.gz: 74b994314eb82cbc91bd82447a44a845feec9b029e486adcd90e877997a8dfac9f7b73f08bb36729cd947e7c36d3d681e8f883e36cef7d977828f9519ba3131f
-  data.tar.gz: a0fb0601b946660f1f7eaac97d3b48bab9b1838f30e45eb7b10d4eb004949c90adc32a42f071d2dad7f8f2397cf4ea79ae605d6003cfc23dddc7f4d276a258c6
+  metadata.gz: 644d1bb91060042670f4602788785bec67c8cc594ffa44d78922e74ba8201d954789e9b8953632b8f2c13b11efe1a2588cdde7bed8b3718c40189dad766104c0
+  data.tar.gz: 75a5830a2a534f63663e83caf4333f5d462a2a591bc72adec2a09d61fc90a2f2d3ea106c26d37df225949beb6e6139c2b2033e76d1448ec0f365160bc28d6ba7

data/CHANGELOG.md

@@ -1,6 +1,16 @@
 Changelog
 =========
 
+v2.0.0.pre2 (2013-07-11)
+------------------------
+
+Features implemented:
+ * Allow to differentiate between __FILE__/__LINE__ and literals (closes #89). (Peter Zotov)
+ * Add attribute `diagnostic' to Parser::SyntaxError (closes #88). (Peter Zotov)
+
+Bugs fixed:
+ * Don't treat byte order mark as an identifier (closes #91). (Peter Zotov)
+
 v2.0.0.beta10 (2013-07-02)
 --------------------------
 

data/README.md

@@ -5,143 +5,194 @@
 [![Code Climate](https://codeclimate.com/github/whitequark/parser.png)](https://codeclimate.com/github/whitequark/parser)
 [![Coverage Status](https://coveralls.io/repos/whitequark/parser/badge.png?branch=master)](https://coveralls.io/r/whitequark/parser)
 
-_Parser_ is a production-ready Ruby parser written in pure Ruby. It
-performs on par or better than Ripper, Melbourne, JRubyParser or
-ruby_parser.
+_Parser_ is a production-ready Ruby parser written in pure Ruby. It performs on
+par or better than Ripper, Melbourne, JRubyParser or ruby\_parser.
 
-You can also use [unparser](https://github.com/mbj/unparser) to produce equivalent source code from Parser's ASTs.
+You can also use [unparser](https://github.com/mbj/unparser) to produce
+equivalent source code from Parser's ASTs.
 
 ## Installation
 
-Most recent version of Parser is 2.0; however, per [release schedule](https://github.com/whitequark/parser/issues/51), it stays in the beta status for a while. However, it handles much more input than stable 1.x branch, and for new work it is advisable to use the beta versions.
+Most recent version of Parser is 2.0; however, per
+[release schedule](https://github.com/whitequark/parser/issues/51), it stays in
+the beta status for a while. However, it handles much more input than stable
+1.x branch, and for new work it is advisable to use the beta versions.
 
-~~~
-$ gem install parser --pre
-~~~
+    $ gem install parser --pre
 
 ## Usage
 
 Parse a chunk of code:
 
-~~~ ruby
-require 'parser/current'
+    require 'parser/current'
 
-p Parser::CurrentRuby.parse("2 + 2")
-# (send
-#   (int 2) :+
-#   (int 2))
-~~~
+    p Parser::CurrentRuby.parse("2 + 2")
+    # (send
+    #   (int 2) :+
+    #   (int 2))
 
 Access the AST's source map:
 
-~~~ ruby
-p Parser::CurrentRuby.parse("2 + 2").loc
-# #<Parser::Source::Map::Send:0x007fe0ca8a69b8
-#   @begin=nil,
-#   @end=nil,
-#   @expression=#<Source::Range (string) 0...5>,
-#   @selector=#<Source::Range (string) 2...3>>
+    p Parser::CurrentRuby.parse("2 + 2").loc
+    # #<Parser::Source::Map::Send:0x007fe0ca8a69b8
+    #   @begin=nil,
+    #   @end=nil,
+    #   @expression=#<Source::Range (string) 0...5>,
+    #   @selector=#<Source::Range (string) 2...3>>
 
-p Parser::CurrentRuby.parse("2 + 2").loc.selector.to_source
-# "+"
-~~~
+    p Parser::CurrentRuby.parse("2 + 2").loc.selector.to_source
+    # "+"
 
 Parse a chunk of code and display all diagnostics:
 
-~~~ ruby
-parser = Parser::CurrentRuby.new
-parser.diagnostics.consumer = lambda do |diag|
-  puts diag.render
-end
-
-buffer = Parser::Source::Buffer.new('(string)')
-buffer.source = "foo *bar"
-
-p parser.parse(buffer)
-# (string):1:5: warning: `*' interpreted as argument prefix
-# foo *bar
-#     ^
-# (send nil :foo
-#   (splat
-#     (send nil :bar)))
-~~~
-
-If you reuse the same parser object for multiple `#parse` runs, you need to `#reset` it.
-
-You can also use the `ruby-parse` utility (it's bundled with the gem) to play with Parser:
-
-~~~
-$ ruby-parse -L -e "2+2"
-(send
-  (int 2) :+
-  (int 2))
-2+2
- ~ selector
-~~~ expression
-(int 2)
-2+2
-~ expression
-(int 2)
-2+2
-
-$ ruby-parse -E -e "2+2"
-2+2
-^ tINTEGER 2                                    expr_end     [0 <= cond] [0 <= cmdarg]
-2+2
- ^ tPLUS "+"                                    expr_beg     [0 <= cond] [0 <= cmdarg]
-2+2
-  ^ tINTEGER 2                                  expr_end     [0 <= cond] [0 <= cmdarg]
-2+2
-  ^ false "$eof"                                expr_end     [0 <= cond] [0 <= cmdarg]
-(send
-  (int 2) :+
-  (int 2))
-~~~
+    parser = Parser::CurrentRuby.new
+    parser.diagnostics.consumer = lambda do |diag|
+      puts diag.render
+    end
+
+    buffer = Parser::Source::Buffer.new('(string)')
+    buffer.source = "foo *bar"
+
+    p parser.parse(buffer)
+    # (string):1:5: warning: `*' interpreted as argument prefix
+    # foo *bar
+    #     ^
+    # (send nil :foo
+    #   (splat
+    #     (send nil :bar)))
+
+If you reuse the same parser object for multiple `#parse` runs, you need to
+`#reset` it.
+
+You can also use the `ruby-parse` utility (it's bundled with the gem) to play
+with Parser:
+
+    $ ruby-parse -L -e "2+2"
+    (send
+      (int 2) :+
+      (int 2))
+    2+2
+     ~ selector
+    ~~~ expression
+    (int 2)
+    2+2
+    ~ expression
+    (int 2)
+    2+2
+
+    $ ruby-parse -E -e "2+2"
+    2+2
+    ^ tINTEGER 2                                    expr_end     [0 <= cond] [0 <= cmdarg]
+    2+2
+     ^ tPLUS "+"                                    expr_beg     [0 <= cond] [0 <= cmdarg]
+    2+2
+      ^ tINTEGER 2                                  expr_end     [0 <= cond] [0 <= cmdarg]
+    2+2
+      ^ false "$eof"                                expr_end     [0 <= cond] [0 <= cmdarg]
+    (send
+      (int 2) :+
+      (int 2))
 
 ## Features
 
- * Precise source location reporting.
- * [Documented](doc/AST_FORMAT.md) AST format which is convenient to work with.
- * A simple interface and a powerful, tweakable one.
- * Parses 1.8, 1.9, 2.0 and 2.1 (preliminary) syntax with backwards-compatible AST formats.
- * Parsing error recovery.
- * Improved [clang-like][] diagnostic messages with location information.
- * Written in pure Ruby, runs on MRI 1.8.7 or >=1.9.2, JRuby and Rubinius in 1.8 and 1.9 mode.
- * Only two runtime dependencies: the gems [ast][] and [slop][].
- * [Insane][insane-lexer] Ruby lexer rewritten from scratch in Ragel.
- * 100% test coverage for Bison grammars (except error recovery).
- * Readable, commented source code.
-
-  [clang-like]: http://clang.llvm.org/diagnostics.html
-  [ast]: http://rubygems.org/gems/ast
-  [slop]: http://rubygems.org/gems/slop
-  [insane-lexer]: http://whitequark.org/blog/2013/04/01/ruby-hacking-guide-ch-11-finite-state-lexer/
+* Precise source location reporting.
+* [Documented](doc/AST_FORMAT.md) AST format which is convenient to work with.
+* A simple interface and a powerful, tweakable one.
+* Parses 1.8, 1.9, 2.0 and 2.1 (preliminary) syntax with backwards-compatible
+  AST formats.
+* Parsing error recovery.
+* Improved [clang-like][] diagnostic messages with location information.
+* Written in pure Ruby, runs on MRI 1.8.7 or >=1.9.2, JRuby and Rubinius in 1.8
+  and 1.9 mode.
+* Only two runtime dependencies: the gems [ast][] and [slop][].
+* [Insane][insane-lexer] Ruby lexer rewritten from scratch in Ragel.
+* 100% test coverage for Bison grammars (except error recovery).
+* Readable, commented source code.
+
+[clang-like]: http://clang.llvm.org/diagnostics.html
+[ast]: http://rubygems.org/gems/ast
+[slop]: http://rubygems.org/gems/slop
+[insane-lexer]: http://whitequark.org/blog/2013/04/01/ruby-hacking-guide-ch-11-finite-state-lexer/
 
 ## Documentation
 
-Documentation for parser is available online on [rdoc.info](http://rdoc.info/github/whitequark/parser).
+Documentation for parser is available online on
+[rdoc.info](http://rdoc.info/github/whitequark/parser).
+
+### Node names
+
+Several Parser nodes seem to be confusing enough to warrant a dedicated README section.
+
+#### (block)
+
+The `(block)` node passes a Ruby block, that is, a closure, to a method call represented by its first child, a `send` node. To demonstrate:
+
+```
+$ ruby-parse -e 'foo { |x| x + 2 }'
+(block
+  (send nil :foo)
+  (args
+    (arg :x))
+  (send
+    (lvar :x) :+
+    (int 2)))
+```
+
+#### (begin) and (kwbegin)
+
+**TL;DR: Unless you perform rewriting, treat `(begin)` and `(kwbegin)` as the same node type.**
+
+Both `(begin)` and `(kwbegin)` nodes represent compound statements, that is, several expressions which are executed sequentally and the value of the last one is the value of entire compound statement. They may take several forms in the source code:
+
+  * `foo; bar`: without delimiters
+  * `(foo; bar)`: parenthesized
+  * `begin foo; bar; end`: grouped with `begin` keyword
+  * `def x; foo; bar; end`: grouped inside a method definition
+
+and so on.
+
+Note that, despite its name, `kwbegin` node only has tangential relation to the `begin` keyword. Normally, Parser AST is semantic, that is, if two constructs look differently but behave identically, they get parsed to the same node. However, there exists a peculiar construct called post-loop in Ruby:
+
+```
+begin
+  body
+end while condition
+```
+
+This specific syntactic construct, that is, keyword `begin..end` block followed by a postfix `while`, [behaves][postloop] very unlike other similar constructs, e.g. `(body) while condition`. While the body itself is wrapped into a `while-post` node, Parser also supports rewriting, and in that context it is important to not accidentally convert one kind of loop into another.
+
+  [postloop]: http://rosettacode.org/wiki/Loops/Do-while#Ruby
+
+(Parser also needs the `(kwbegin)` node type internally, and it is highly problematic to map it back to `(begin)`.)
 
 ## Known issues
 
 ### Void value expressions
 
-So-called "void value expressions" are not handled by Parser. For a description of what a void value expression is, see [this gist](https://gist.github.com/JoshCheek/5625007) and [this Parser issue](https://github.com/whitequark/parser/issues/72).
+So-called "void value expressions" are not handled by Parser. For a description
+of what a void value expression is, see [this
+gist](https://gist.github.com/JoshCheek/5625007) and [this Parser
+issue](https://github.com/whitequark/parser/issues/72).
 
-It is not clear which rules this piece of static analysis follows, or which problem does it solve. It is not implemented because there is no clear specification allowing us to verify the behavior.
+It is not clear which rules this piece of static analysis follows, or which
+problem does it solve. It is not implemented because there is no clear
+specification allowing us to verify the behavior.
 
 ## Contributors
 
- * Peter Zotov ([whitequark][])
- * Magnus Holm ([judofyr][])
+* Peter Zotov ([whitequark][])
+* Magnus Holm ([judofyr][])
 
- [whitequark]: https://github.com/whitequark
- [judofyr]:    https://github.com/judofyr
+[whitequark]: https://github.com/whitequark
+[judofyr]:    https://github.com/judofyr
 
 ## Acknowledgements
 
-The lexer testsuite is derived from [ruby_parser](http://github.com/seattlerb/ruby_parser).
+The lexer testsuite is derived from
+[ruby\_parser](http://github.com/seattlerb/ruby_parser).
 
-The Bison parser rules are derived from [Ruby MRI](http://github.com/ruby/ruby) parse.y.
+The Bison parser rules are derived from [Ruby MRI](http://github.com/ruby/ruby)
+parse.y.
 
 ## Contributing
 

data/lib/parser.rb

@@ -74,7 +74,7 @@ module Parser
     :no_dot_digit_literal    => 'no .<digit> floating literal anymore; put 0 before dot',
     :bare_backslash          => 'bare backslash only allowed before newline',
     :unexpected              => "unexpected `%{character}'",
-    :embedded_document       => 'embedded document meats end of file (and they embark on a romantic journey)',
+    :embedded_document       => 'embedded document meets end of file (and they embark on a romantic journey)',
 
     # Lexer warnings
     :invalid_escape_use      => 'invalid character syntax; use ?%{escape}',

data/lib/parser/ast/node.rb

@@ -1,11 +1,28 @@
 module Parser
   module AST
 
+    ##
+    # {Parser::AST::Node} contains information about a single AST node and its
+    # child nodes, it extends the basic `AST::Node` class provided by the "ast"
+    # Gem.
+    #
+    # @!attribute [r] location
+    #  @return [Parser::Source::Map]
+    #
     class Node < ::AST::Node
       attr_reader :location
 
       alias loc location
 
+      ##
+      # Assigns various properties to the current AST node. Currently only the
+      # location can be set.
+      #
+      # @param [Hash] properties
+      #
+      # @option properties [Parser::Source::Map] :location Location information
+      #  of the node.
+      #
       def assign_properties(properties)
         if (location = properties[:location])
           @location = location

data/lib/parser/base.rb

@@ -49,9 +49,19 @@ module Parser
     end
 
     attr_reader :diagnostics
+
+    attr_reader :builder
+
+    ##
+    # @api internal
+    #
     attr_reader :static_env
 
+    ##
     # The source file currently being parsed.
+    #
+    # @api internal
+    #
     attr_reader :source_buffer
 
     ##

data/lib/parser/builders/default.rb

@@ -2,6 +2,11 @@ module Parser
 
   class Builders::Default
     attr_accessor :parser
+    attr_accessor :emit_file_line_as_literals
+
+    def initialize
+      @emit_file_line_as_literals = true
+    end
 
     #
     # Literals
@@ -257,12 +262,20 @@ module Parser
     def accessible(node)
       case node.type
       when :__FILE__
-        n(:str, [ node.loc.expression.source_buffer.name ],
-          node.loc)
+        if @emit_file_line_as_literals
+          n(:str, [ node.loc.expression.source_buffer.name ],
+            node.loc)
+        else
+          node
+        end
 
       when :__LINE__
-        n(:int, [ node.loc.expression.line ],
-          node.loc)
+        if @emit_file_line_as_literals
+          n(:int, [ node.loc.expression.line ],
+            node.loc)
+        else
+          node
+        end
 
       when :__ENCODING__
         n(:const, [ n(:const, [ nil, :Encoding], nil), :UTF_8 ],

data/lib/parser/diagnostic/engine.rb

@@ -1,11 +1,44 @@
 module Parser
 
+  ##
+  # {Parser::Diagnostic::Engine} provides a basic API for dealing with
+  # diagnostics by delegating them to registered consumers.
+  #
+  # Basic usage is as following:
+  #
+  #     buffer      = Parser::Source::Buffer.new(__FILE__)
+  #     buffer.code = 'foobar'
+  #
+  #     consumer = lambda do |diagnostic|
+  #       puts diagnostic.message
+  #     end
+  #
+  #     engine     = Parser::Diagnostic::Engine.new(consumer)
+  #     diagnostic = Parser::Diagnostic.new(:warning, 'warning!', buffer, 1..2)
+  #
+  #     engine.process(diagnostic) # => "warning!"
+  #
+  # @!attribute [rw] consumer
+  #  @return [#call]
+  #
+  # @!attribute [rw] all_errors_are_fatal
+  #  When set to `true` any error that is encountered will result in
+  #  {Parser::SyntaxError} being raised.
+  #  @return [TrueClass|FalseClass]
+  #
+  # @!attribute [rw] ignore_warnings
+  #  When set to `true` warnings will be ignored.
+  #  @return [TrueClass|FalseClass]
+  #
   class Diagnostic::Engine
     attr_accessor :consumer
 
     attr_accessor :all_errors_are_fatal
     attr_accessor :ignore_warnings
 
+    ##
+    # @param [#call] consumer
+    #
     def initialize(consumer=nil)
       @consumer             = consumer
 
@@ -13,6 +46,13 @@ module Parser
       @ignore_warnings      = false
     end
 
+    ##
+    # Processes a diagnostic and optionally raises {Parser::SyntaxError} when
+    # `all_errors_are_fatal` is set to true.
+    #
+    # @param [Parser::Diagnostic] diagnostic
+    # @return [Parser::Diagnostic::Engine]
+    #
     def process(diagnostic)
       if ignore?(diagnostic)
         # do nothing
@@ -21,7 +61,7 @@ module Parser
       end
 
       if raise?(diagnostic)
-        raise Parser::SyntaxError, diagnostic.message
+        raise Parser::SyntaxError, diagnostic
       end
 
       self
@@ -29,11 +69,19 @@ module Parser
 
     protected
 
+    ##
+    # @param [Parser::Diagnostic] diagnostic
+    # @return [TrueClass|FalseClass]
+    #
     def ignore?(diagnostic)
       @ignore_warnings &&
             diagnostic.level == :warning
     end
 
+    ##
+    # @param [Parser::Diagnostic] diagnostic
+    # @return [TrueClass|FalseClass]
+    #
     def raise?(diagnostic)
       (@all_errors_are_fatal &&
           diagnostic.level == :error) ||

data/lib/parser/lexer.rl

@@ -155,6 +155,11 @@ class Parser::Lexer
       # Patches accepted.
       #
       @source = @source_buffer.source + "\0\0\0"
+
+      if @source.length > 0 && @source[0].ord == 0xfeff
+        # Skip byte order mark.
+        @p = 1
+      end
     else
       @source = nil
     end

data/lib/parser/rewriter.rb

@@ -1,5 +1,54 @@
 module Parser
+  ##
+  # {Parser::Rewriter} offers a basic API that makes it easy to rewrite
+  # existing ASTs. It's built on top of {Parser::AST::Processor} and
+  # {Parser::Source::Rewriter}.
+  #
+  # For example, assume you want to remove `do` tokens from a while statement.
+  # You can do this as following:
+  #
+  #     class RemoveDo < Parser::Rewriter
+  #       def on_while(node)
+  #         # Check if the statement starts with "do"
+  #         if node.location.begin.is?('do')
+  #           remove(node.location.begin)
+  #         end
+  #       end
+  #     end
+  #
+  #     code = <<-EOF
+  #     while true do
+  #       puts 'hello'
+  #     end
+  #     EOF
+  #
+  #     buffer      = Parser::Source::Buffer.new('(example)')
+  #     buffer.code = code
+  #     parser      = Parser::CurrentRuby.new
+  #     ast         = parser.parse(buffer)
+  #     rewriter    = RemoveDo.new
+  #
+  #     # Rewrite the AST, returns a String with the new form.
+  #     puts rewriter.rewrite(buffer, ast)
+  #
+  # This would result in the following Ruby code:
+  #
+  #     while true
+  #       puts 'hello'
+  #     end
+  #
+  # Keep in mind that {Parser::Rewriter} does not take care of indentation when
+  # inserting/replacing code so you'll have to do this yourself.
+  #
   class Rewriter < Parser::AST::Processor
+    ##
+    # Rewrites the AST/source buffer and returns a String containing the new
+    # version.
+    #
+    # @param [Parser::Source::Buffer] source_buffer
+    # @param [Parser::AST::Node] ast
+    # @return [String]
+    #
     def rewrite(source_buffer, ast)
       @source_rewriter = Source::Rewriter.new(source_buffer)
 
@@ -10,22 +59,52 @@ module Parser
 
     private
 
+    ##
+    # Returns `true` if the specified node is an assignment node, returns false
+    # otherwise.
+    #
+    # @param [Parser::AST::Node] node
+    # @return [TrueClass|FalseClass]
+    #
     def assignment?(node)
       [:lvasgn, :ivasgn, :gvasgn, :cvasgn, :casgn].include?(node.type)
     end
 
+    ##
+    # Removes the source range.
+    #
+    # @param [Parser::Source::Range] range
+    #
     def remove(range)
       @source_rewriter.remove(range)
     end
 
+    ##
+    # Inserts new code before the given source range.
+    #
+    # @param [Parser::Source::Range] range
+    # @param [String] content
+    #
     def insert_before(range, content)
       @source_rewriter.insert_before(range, content)
     end
 
+    ##
+    # Inserts new code after the given source range.
+    #
+    # @param [Parser::Source::Range] range
+    # @param [String] content
+    #
     def insert_after(range, content)
       @source_rewriter.insert_after(range, content)
     end
 
+    ##
+    # Replaces the code of the source range `range` with `content`.
+    #
+    # @param [Parser::Source::Range] range
+    # @param [String] content
+    #
     def replace(range, content)
       @source_rewriter.replace(range, content)
     end

data/lib/parser/syntax_error.rb

@@ -1,3 +1,14 @@
 module Parser
-  class SyntaxError < StandardError; end
+  ##
+  # {Parser::SyntaxError} is raised whenever parser detects a syntax error
+  # (what a surprise!) similar to the standard SyntaxError class.
+  #
+  class SyntaxError < StandardError
+    attr_reader :diagnostic
+
+    def initialize(diagnostic)
+      @diagnostic = diagnostic
+      super(diagnostic.message)
+    end
+  end
 end

data/lib/parser/version.rb

@@ -1,3 +1,3 @@
 module Parser
-  VERSION = '2.0.0.pre1'
+  VERSION = '2.0.0.pre2'
 end

data/test/test_diagnostic_engine.rb

@@ -32,10 +32,12 @@ class TestDiagnosticEngine < Minitest::Test
 
     error = Parser::Diagnostic.new(:error, 'foo', @buffer, 1..2)
 
-    assert_raises Parser::SyntaxError do
+    err = assert_raises Parser::SyntaxError, "foo" do
       @engine.process(error)
     end
 
+    assert_equal error, err.diagnostic
+
     assert_equal [error], @queue
   end
 

data/test/test_parser.rb

@@ -4315,7 +4315,28 @@ class TestParser < Minitest::Test
       ALL_VERSIONS - %w(1.8 1.9))
   end
 
+  def test_file_line_non_literals
+    with_versions(ALL_VERSIONS) do |_ver, parser|
+      parser.builder.emit_file_line_as_literals = false
+
+      source_file = Parser::Source::Buffer.new('(comments)')
+      source_file.source = "[__FILE__, __LINE__]"
+
+      ast = parser.parse(source_file)
+
+      assert_equal s(:array, s(:__FILE__), s(:__LINE__)), ast
+    end
+  end
+
   if defined?(Encoding)
+    def test_bom
+      assert_parses(
+        s(:int, 1),
+        %Q{\xef\xbb\xbf1}.force_encoding(Encoding::BINARY),
+        %q{},
+        %w(1.9 2.0 2.1))
+    end
+
     def test_magic_encoding_comment
       assert_parses(
         s(:begin,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parser
 version: !ruby/object:Gem::Version
-  version: 2.0.0.pre1
+  version: 2.0.0.pre2
 platform: ruby
 authors:
 - Peter Zotov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-04 00:00:00.000000000 Z
+date: 2013-07-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ast