parser_tree_rewriter 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 775027865d822a480a3c13327d75ac655936ac2a
+  data.tar.gz: 38862b4c8b1e9c2a3394e7a01876581054724d28
+SHA512:
+  metadata.gz: 5f0cdc7a1c97b5854f1db0504dca706cfe248e915e5f38beb280c49aa06172d467e1ae2f9529c0dad810e34a8d690e198ae59f8bf4490f2ed2c0c0c7df483c4e
+  data.tar.gz: 5e9e55a9840c0406f4ef054239a52a6fc436c70aa63ef91987863e4b2977bbd779d5d0e1421d03f469cf270c83077876018c524b412e4fe6b32013f6aec8fca9

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.5
+before_install: gem install bundler -v 1.16.1

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in parser_tree_rewriter.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Marc-Andre Lafortune
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,39 @@
+# ParserTreeRewriter
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/parser_tree_rewriter`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'parser_tree_rewriter'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install parser_tree_rewriter
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/marcandre/parser_tree_rewriter.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+  t.warning    = false
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "parser_tree_rewriter"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/parser_tree_rewriter.rb

@@ -0,0 +1,11 @@
+require "parser_tree_rewriter/version"
+
+require 'parser'
+
+if Parser::VERSION <= '2.4.0.2'
+  require_relative 'parser_tree_rewriter/messages'
+  require_relative 'parser_tree_rewriter/source/buffer'
+  require_relative 'parser_tree_rewriter/source/range'
+  require_relative 'parser_tree_rewriter/source/tree_rewriter'
+  require_relative 'parser_tree_rewriter/source/tree_rewriter/action'
+end

data/lib/parser_tree_rewriter/messages.rb

@@ -0,0 +1,21 @@
+module Parser
+  ##
+  # Diagnostic messages (errors, warnings and notices) that can be generated.
+  #
+  # @see Diagnostic
+  #
+  # @api public
+  #
+  new_messages = MESSAGES.merge({
+    # Rewriter diagnostics
+    :different_replacements        => 'different replacements: %{replacement} vs %{other_replacement}',
+    :swallowed_insertions          => 'this replacement:',
+    :swallowed_insertions_conflict => 'swallows some inner rewriting actions:',
+    :crossing_deletions            => 'the deletion of:',
+    :crossing_deletions_conflict   => 'is crossing:',
+    :crossing_insertions           => 'the rewriting action on:',
+    :crossing_insertions_conflict  => 'is crossing that on:',
+  }).freeze
+  remove_const(:MESSAGES)
+  const_set(:MESSAGES, new_messages)
+end

data/lib/parser_tree_rewriter/source/buffer.rb

@@ -0,0 +1,9 @@
+module Parser
+  module Source
+    class Buffer
+      def source_range
+        @source_range ||= Range.new(self, 0, source.size)
+      end
+    end
+  end
+end

data/lib/parser_tree_rewriter/source/range.rb

@@ -0,0 +1,98 @@
+module Parser
+  module Source
+    class Range
+      include Comparable
+
+      ##
+      # @param [Hash] Endpoint(s) to change, any combination of :begin_pos or :end_pos
+      # @return [Range] the same range as this range but with the given end point(s) changed
+      # to the given value(s).
+      #
+      def with(begin_pos: @begin_pos, end_pos: @end_pos)
+        Range.new(@source_buffer, begin_pos, end_pos)
+      end
+
+      ##
+      # @param [Hash] Endpoint(s) to change, any combination of :begin_pos or :end_pos
+      # @return [Range] the same range as this range but with the given end point(s) adjusted
+      # by the given amount(s)
+      #
+      def adjust(begin_pos: 0, end_pos: 0)
+        Range.new(@source_buffer, @begin_pos + begin_pos, @end_pos + end_pos)
+      end
+
+      ##
+      # Return `true` iff this range and `other` are disjoint.
+      #
+      # Two ranges must be one and only one of ==, disjoint?, contains?, contained? or crossing?
+      #
+      # @param [Range] other
+      # @return [Boolean]
+      #
+      def disjoint?(other)
+        if empty? && other.empty?
+          @begin_pos != other.begin_pos
+        else
+          @begin_pos >= other.end_pos || other.begin_pos >= @end_pos
+        end
+      end
+
+      ##
+      # Return `true` iff this range is not disjoint from `other`.
+      #
+      # @param [Range] other
+      # @return [Boolean] `true` if this range and `other` overlap
+      #
+      def overlaps?(other)
+        !disjoint?(other)
+      end
+
+      ##
+      # Returns true iff this range contains (strictly) `other`.
+      #
+      # Two ranges must be one and only one of ==, disjoint?, contains?, contained? or crossing?
+      #
+      # @param [Range] other
+      # @return [Boolean]
+      #
+      def contains?(other)
+        (other.begin_pos <=> @begin_pos) + (@end_pos <=> other.end_pos) >= (other.empty? ? 2 : 1)
+      end
+
+      ##
+      # Return `other.contains?(self)`
+      #
+      # Two ranges must be one and only one of ==, disjoint?, contains?, contained? or crossing?
+      #
+      # @param [Range] other
+      # @return [Boolean]
+      #
+      def contained?(other)
+        other.contains?(self)
+      end
+
+      ##
+      # Returns true iff both ranges intersect and also have different elements from one another.
+      #
+      # Two ranges must be one and only one of ==, disjoint?, contains?, contained? or crossing?
+      #
+      # @param [Range] other
+      # @return [Boolean]
+      #
+      def crossing?(other)
+        return false unless overlaps?(other)
+        (@begin_pos <=> other.begin_pos) * (@end_pos <=> other.end_pos) == 1
+      end
+
+      ##
+      # Compare ranges, first by begin_pos, then by end_pos.
+      #
+      def <=>(other)
+        return nil unless other.is_a?(::Parser::Source::Range) &&
+          @source_buffer == other.source_buffer
+        (@begin_pos <=> other.begin_pos).nonzero? ||
+        (@end_pos <=> other.end_pos)
+      end
+    end
+  end
+end

data/lib/parser_tree_rewriter/source/tree_rewriter.rb

@@ -0,0 +1,274 @@
+module Parser
+  module Source
+
+    ##
+    # {TreeRewriter} performs the heavy lifting in the source rewriting process.
+    # It schedules code updates to be performed in the correct order.
+    #
+    # For simple cases, the resulting source will be obvious.
+    #
+    # Examples for more complex cases follow. Assume these examples are acting on
+    # the source `'puts(:hello, :world)`. The methods #wrap, #remove, etc.
+    # receive a Range as first argument; for clarity, examples below use english
+    # sentences and a string of raw code instead.
+    #
+    # ## Overlapping ranges:
+    #
+    # Any two rewriting actions on overlapping ranges will fail and raise
+    # a `ClobberingError`, unless they are both deletions (covered next).
+    #
+    # * wrap ':hello, ' with '(' and ')'
+    # * wrap ', :world' with '(' and ')'
+    #  => CloberringError
+    #
+    # ## Overlapping deletions:
+    #
+    # * remove ':hello, '
+    # * remove ', :world'
+    #
+    # The overlapping ranges are merged and `':hello, :world'` will be removed.
+    # This policy can be changed. `:crossing_deletions` defaults to `:accept`
+    # but can be set to `:warn` or `:raise`.
+    #
+    # ## Multiple actions at the same end points:
+    #
+    # Results will always be independent on the order they were given.
+    # Exception: rewriting actions done on exactly the same range (covered next).
+    #
+    # Example:
+    # * replace ', ' by ' => '
+    # * wrap ':hello, :world' with '{' and '}'
+    # * replace ':world' with ':everybody'
+    # * wrap ':world' with '[', ']'
+    #
+    # The resulting string will be `'puts({:hello => [:everybody]})'`
+    # and this result is independent on the order the instructions were given in.
+    #
+    # Note that if the two "replace" were given as a single replacement of ', :world'
+    # for ' => :everybody', the result would be a `ClobberingError` because of the wrap
+    # in square brackets.
+    #
+    # ## Multiple wraps on same range:
+    # * wrap ':hello' with '(' and ')'
+    # * wrap ':hello' with '[' and ']'
+    #
+    # The wraps are combined in order given and results would be `'puts([(:hello)], :world)'`.
+    #
+    # ## Multiple replacements on same range:
+    # * replace ':hello' by ':hi', then
+    # * replace ':hello' by ':hey'
+    #
+    # The replacements are made in the order given, so the latter replacement
+    # supersedes the former and ':hello' will be replaced by ':hey'.
+    #
+    # This policy can be changed. `:different_replacements` defaults to `:accept`
+    # but can be set to `:warn` or `:raise`.
+    #
+    # ## Swallowed insertions:
+    # wrap 'world' by '__', '__'
+    # replace ':hello, :world' with ':hi'
+    #
+    # A containing replacement will swallow the contained rewriting actions
+    # and `':hello, :world'` will be replaced by `':hi'`.
+    #
+    # This policy can be changed for swallowed insertions. `:swallowed_insertions`
+    # defaults to `:accept` but can be set to `:warn` or `:raise`
+    #
+    # ## Implementation
+    # The updates are organized in a tree, according to the ranges they act on
+    # (where children are strictly contained by their parent), hence the name.
+    #
+    # @!attribute [r] source_buffer
+    #  @return [Source::Buffer]
+    #
+    # @!attribute [r] diagnostics
+    #  @return [Diagnostic::Engine]
+    #
+    # @api public
+    #
+    class TreeRewriter
+      attr_reader :source_buffer
+      attr_reader :diagnostics
+
+      ##
+      # @param [Source::Buffer] source_buffer
+      #
+      def initialize(source_buffer,
+                     crossing_deletions: :accept,
+                     different_replacements: :accept,
+                     swallowed_insertions: :accept)
+        @diagnostics = Diagnostic::Engine.new
+        @diagnostics.consumer = -> diag { $stderr.puts diag.render }
+
+        @source_buffer = source_buffer
+        @in_transaction = false
+
+        @policy = {crossing_deletions: crossing_deletions,
+                   different_replacements: different_replacements,
+                   swallowed_insertions: swallowed_insertions}.freeze
+        check_policy_validity
+
+        @enforcer = method(:enforce_policy)
+        # We need a range that would be jugded as containing all other ranges,
+        # including 0...0 and size...size:
+        all_encompassing_range = @source_buffer.source_range.adjust(begin_pos: -1, end_pos: +1)
+        @action_root = TreeRewriter::Action.new(all_encompassing_range, @enforcer)
+      end
+
+      ##
+      # Replaces the code of the source range `range` with `content`.
+      #
+      # @param [Range] range
+      # @param [String] content
+      # @return [Rewriter] self
+      # @raise [ClobberingError] when clobbering is detected
+      #
+      def replace(range, content)
+        combine(range, replacement: content)
+      end
+
+      ##
+      # Inserts the given strings before and after the given range.
+      #
+      # @param [Range] range
+      # @param [String or nil] insert_before
+      # @param [String or nil] insert_after
+      # @return [Rewriter] self
+      # @raise [ClobberingError] when clobbering is detected
+      #
+      def wrap(range, insert_before, insert_after)
+        combine(range, insert_before: insert_before.to_s, insert_after: insert_after.to_s)
+      end
+
+      ##
+      # Shortcut for `replace(range, '')`
+      #
+      # @param [Range] range
+      # @return [Rewriter] self
+      # @raise [ClobberingError] when clobbering is detected
+      #
+      def remove(range)
+        replace(range, ''.freeze)
+      end
+
+
+      ##
+      # Shortcut for `wrap(range, content, nil)`
+      #
+      # @param [Range] range
+      # @param [String] content
+      # @return [Rewriter] self
+      # @raise [ClobberingError] when clobbering is detected
+      #
+      def insert_before(range, content)
+        wrap(range, content, nil)
+      end
+
+      ##
+      # Shortcut for `wrap(range, nil, content)`
+      #
+      # @param [Range] range
+      # @param [String] content
+      # @return [Rewriter] self
+      # @raise [ClobberingError] when clobbering is detected
+      #
+      def insert_after(range, content)
+        wrap(range, nil, content)
+      end
+
+      ##
+      # Applies all scheduled changes to the `source_buffer` and returns
+      # modified source as a new string.
+      #
+      # @return [String]
+      #
+      def process
+        source     = @source_buffer.source.dup
+        adjustment = 0
+
+        @action_root.ordered_replacements.each do |range, replacement|
+          begin_pos = range.begin_pos + adjustment
+          end_pos   = begin_pos + range.length
+
+          source[begin_pos...end_pos] = replacement
+
+          adjustment += replacement.length - range.length
+        end
+
+        source
+      end
+
+      ##
+      # Provides a protected block where a sequence of multiple rewrite actions
+      # are handled atomically. If any of the actions failed by clobbering,
+      # all the actions are rolled back.
+      #
+      # @raise [RuntimeError] when no block is passed
+      # @raise [RuntimeError] when already in a transaction
+      #
+      def transaction
+        unless block_given?
+          raise "#{self.class}##{__method__} requires block"
+        end
+
+        previous = @in_transaction
+        @in_transaction = true
+        restore_root = @action_root
+
+        yield
+
+        restore_root = nil
+
+        self
+      ensure
+        @action_root = restore_root if restore_root
+        @in_transaction = previous
+      end
+
+      def in_transaction?
+        @in_transaction
+      end
+
+      private
+
+      ACTIONS = %i[accept warn raise].freeze
+      def check_policy_validity
+        invalid = @policy.values - ACTIONS
+        raise ArgumentError, "Invalid policy: #{invalid.join(', ')}" unless invalid.empty?
+      end
+
+      def combine(range, attributes)
+        range = check_range_validity(range)
+        action = TreeRewriter::Action.new(range, @enforcer, attributes)
+        @action_root = @action_root.combine(action)
+        self
+      end
+
+      def check_range_validity(range)
+        if range.begin_pos < 0 || range.end_pos > @source_buffer.source.size
+          raise IndexError, "The range #{action.range} is outside the bounds of the source"
+        end
+        range
+      end
+
+      def enforce_policy(event)
+        return if @policy[event] == :accept
+        return unless (values = yield)
+        trigger_policy(event, values)
+      end
+
+      POLICY_TO_LEVEL = {warn: :warning, raise: :error}.freeze
+      def trigger_policy(event, range: raise, conflict: nil, **arguments)
+        action = @policy[event] || :raise
+        diag = Parser::Diagnostic.new(POLICY_TO_LEVEL[action], event, arguments, range)
+        @diagnostics.process(diag)
+        if conflict
+          range, *highlights = conflict
+          diag = Parser::Diagnostic.new(POLICY_TO_LEVEL[action], :"#{event}_conflict", arguments, range, highlights)
+          @diagnostics.process(diag)
+        end
+        raise Parser::ClobberingError, "Parser::Source::TreeRewriter detected clobbering" if action == :raise
+      end
+    end
+  end
+end

data/lib/parser_tree_rewriter/source/tree_rewriter/action.rb

@@ -0,0 +1,131 @@
+module Parser
+  module Source
+    ##
+    # @api private
+    #
+    # Actions are arranged in a tree and get combined so that:
+    #   children are strictly contained by their parent
+    #   sibblings all disjoint from one another
+    #   only actions with replacement==nil may have children
+    #
+    class TreeRewriter::Action
+      attr_reader :range, :replacement, :insert_before, :insert_after
+
+      def initialize(range, enforcer,
+           insert_before: '',
+           replacement: nil,
+           insert_after: '',
+           children: []
+        )
+        @range, @enforcer, @children, @insert_before, @replacement, @insert_after =
+          range, enforcer, children.freeze, insert_before.freeze, replacement, insert_after.freeze
+
+        freeze
+      end
+
+      # Assumes action.children.empty?
+      def combine(action)
+        return self unless action.insertion? || action.replacement # Ignore empty action
+        do_combine(action)
+      end
+
+      def ordered_replacements
+        reps = []
+        reps << [@range.begin, @insert_before] unless @insert_before.empty?
+        reps << [@range, @replacement] if @replacement
+        reps.concat(@children.sort_by(&:range).flat_map(&:ordered_replacements))
+        reps << [@range.end, @insert_after] unless @insert_after.empty?
+        reps
+      end
+
+      def insertion?
+        !insert_before.empty? || !insert_after.empty? || (replacement && !replacement.empty?)
+      end
+
+      protected
+
+      def with(range: @range, children: @children, insert_before: @insert_before, replacement: @replacement, insert_after: @insert_after)
+        children = swallow(children) if replacement
+        self.class.new(range, @enforcer, children: children, insert_before: insert_before, replacement: replacement, insert_after: insert_after)
+      end
+
+      # Assumes range.contains?(action.range) && action.children.empty?
+      def do_combine(action)
+        if action.range == @range
+          merge(action)
+        else
+          place_in_hierachy(action)
+        end
+      end
+
+      def place_in_hierachy(action)
+        family = @children.group_by { |child| child.relationship_with(action) }
+
+        if family[:fusible]
+          fuse_deletions(action, family[:fusible], [*family[:sibbling], *family[:child]])
+        else
+          extra_sibbling = if family[:parent]  # action should be a descendant of one of the children
+            family[:parent][0].do_combine(action)
+          elsif family[:child]                 # or it should become the parent of some of the children,
+            action.with(children: family[:child])
+          else                                 # or else it should become an additional child
+            action
+          end
+          with(children: [*family[:sibbling], extra_sibbling])
+        end
+      end
+
+      def fuse_deletions(action, fusible, other_sibblings)
+        without_fusible = with(children: other_sibblings)
+        fused_range = [action, *fusible].map(&:range).inject(:join)
+        fused_deletion = action.with(range: fused_range)
+        without_fusible.do_combine(fused_deletion)
+      end
+
+      # Returns what relationship self should have with `action`; either of
+      #   :sibbling, :parent, :child, :fusible or raises a CloberingError
+      # In case of equal range, returns :parent
+      def relationship_with(action)
+        if action.range == @range || @range.contains?(action.range)
+          :parent
+        elsif @range.contained?(action.range)
+          :child
+        elsif @range.disjoint?(action.range)
+          :sibbling
+        elsif !action.insertion? && !insertion?
+          @enforcer.call(:crossing_deletions) { {range: action.range, conflict: @range} }
+          :fusible
+        else
+          @enforcer.call(:crossing_insertions) { {range: action.range, conflict: @range} }
+        end
+      end
+
+      # Assumes action.range == range && action.children.empty?
+      def merge(action)
+        call_enforcer_for_merge(action)
+        with(
+          insert_before: "#{action.insert_before}#{insert_before}",
+          replacement: action.replacement || @replacement,
+          insert_after: "#{insert_after}#{action.insert_after}",
+        )
+      end
+
+      def call_enforcer_for_merge(action)
+        @enforcer.call(:different_replacements) do
+          if @replacement && action.replacement && @replacement != action.replacement
+            {range: @range, replacement: action.replacement, other_replacement: @replacement}
+          end
+        end
+      end
+
+      def swallow(children)
+        @enforcer.call(:swallowed_insertions) do
+          insertions = children.select(&:insertion?)
+
+          {range: @range, conflict: insertions.map(&:range)} unless insertions.empty?
+        end
+        []
+      end
+    end
+  end
+end

data/lib/parser_tree_rewriter/version.rb

@@ -0,0 +1,3 @@
+module ParserTreeRewriter
+  VERSION = "1.0.0"
+end

data/parser_tree_rewriter.gemspec

@@ -0,0 +1,28 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "parser_tree_rewriter/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "parser_tree_rewriter"
+  spec.version       = ParserTreeRewriter::VERSION
+  spec.authors       = ["Marc-Andre Lafortune"]
+  spec.email         = ["github@marc-andre.ca"]
+
+  spec.summary       = %q{Adds Parser::Source::TreeRewriter to parser, until next release}
+  spec.description   = %q{Adds Parser::Source::TreeRewriter to parser, until next release}
+  spec.homepage      = "https://github.com/marcandre/parser_tree_rewriter"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.add_dependency "parser", ">= 2.4.0.2"
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: parser_tree_rewriter
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Marc-Andre Lafortune
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-02-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.4.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.4.0.2
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: Adds Parser::Source::TreeRewriter to parser, until next release
+email:
+- github@marc-andre.ca
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/parser_tree_rewriter.rb
+- lib/parser_tree_rewriter/messages.rb
+- lib/parser_tree_rewriter/source/buffer.rb
+- lib/parser_tree_rewriter/source/range.rb
+- lib/parser_tree_rewriter/source/tree_rewriter.rb
+- lib/parser_tree_rewriter/source/tree_rewriter/action.rb
+- lib/parser_tree_rewriter/version.rb
+- parser_tree_rewriter.gemspec
+homepage: https://github.com/marcandre/parser_tree_rewriter
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14
+signing_key: 
+specification_version: 4
+summary: Adds Parser::Source::TreeRewriter to parser, until next release
+test_files: []