ruumba 0.1.10 → 0.1.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fc25f940621b5d2f205b48a164660f2fc445c38b
-  data.tar.gz: 787c2558ba96d2bcef7b20ef62b6c4cf315215f5
+  metadata.gz: be806019ab1e49249c6c93f96fc6c3b0cc64133e
+  data.tar.gz: 23f5f794ec43878ffa895fca296c3635c765affc
 SHA512:
-  metadata.gz: bc95b256427ae32527bb9a1e08bbe0df50b2e499481d1719d47eda8bbe27e0c4a24e7afaf86dc8a537ba107be64e3794cfaa5f7268c2383f613caa0a221ba46e
-  data.tar.gz: 11c864be6842cbc0a119fee5b1d84bb0fdd6e58b8a0d6696a4be3a834a1761b886ac9a74597f276a485899ba79db271fa3f21121029a21e1925ef56fa5e6bbe9
+  metadata.gz: 98d98ef80a4604c9c4eeb61fc2e950ec029b6cc54f36af699f9051cb6c526bc20f6d6d6ee78e2946db3a358a30552c9928064445399584bf84d468136838958a
+  data.tar.gz: 1029541aa945f8611b1b8da61d7a4f9c53ccab0a6dc7b550e0de31ae4f24dce9f067a0c723ce341ebba77369ffd2e143bcbe1ac323b36fd1a938d92f3d1efbb4

data/bin/ruumba

@@ -96,6 +96,11 @@ opts_parser = OptionParser.new do |opts|
   opts.on('-L', '--list-target-files', 'List all files Ruumba will inspect.') do
     options[:arguments] << '--list-target-files'
   end
+
+  opts.on('-a', '--auto-correct', 'Auto-correct offenses.') do
+    options[:arguments] << '--auto-correct'
+    options[:auto_correct] = true
+  end
 end
 
 begin

data/lib/ruumba/analyzer.rb

@@ -1,12 +1,14 @@
 # @author Eric Weinstein <eric.q.weinstein@gmail.com>
 
 require 'securerandom'
+require 'digest'
 require 'pathname'
 require 'tmpdir'
 require 'open3'
 require 'English'
 
 require 'ruumba/iterators'
+require 'ruumba/correctors'
 require 'ruumba/parser'
 require 'ruumba/rubocop_runner'
 
@@ -38,24 +40,43 @@ module Ruumba
     def analyze(temp_dir, files_or_dirs)
       temp_dir_path = Pathname.new(temp_dir)
 
-      iterator =
+      iterator, corrector =
         if stdin?
-          Iterators::StdinIterator.new(stdin_filename)
+          [Iterators::StdinIterator.new(File.expand_path(stdin_filename)), Correctors::StdinCorrector.new(digestor, parser)]
         else
-          Iterators::DirectoryIterator.new(files_or_dirs)
+          [Iterators::DirectoryIterator.new(files_or_dirs), Correctors::FileCorrector.new(digestor, parser)]
         end
 
       iterator.each do |file, contents|
-        copy_erb_file(file, contents, temp_dir_path)
+        code, new_file_name = copy_erb_file(file, contents, temp_dir_path)
+
+        if stdin?
+          @stdin_contents = code
+          @new_stdin_filename = new_file_name
+        end
       end
 
-      RubocopRunner.new(arguments, pwd, temp_dir_path, !disable_rb_extension?).execute
+      stdout, stderr, exit_code = RubocopRunner.new(arguments, pwd, temp_dir_path, @stdin_contents, !disable_rb_extension?).execute
+
+      corrector.correct(stdout, stderr, file_mappings) if auto_correct?
+
+      [[STDOUT, stdout], [STDERR, stderr]].each do |output_stream, output|
+        next if output.nil? || output.empty?
+
+        output_stream.puts(output)
+      end
+
+      exit_code
     end
 
     def extension
       '.rb' unless disable_rb_extension?
     end
 
+    def auto_correct?
+      options[:auto_correct]
+    end
+
     def stdin?
       stdin_filename
     end
@@ -65,7 +86,11 @@ module Ruumba
     end
 
     def arguments
-      options[:arguments]
+      if stdin?
+        options[:arguments] + ['--stdin', @new_stdin_filename]
+      else
+        options[:arguments]
+      end
     end
 
     def disable_rb_extension?
@@ -76,19 +101,52 @@ module Ruumba
       @pwd ||= Pathname.new(ENV['PWD'])
     end
 
+    def auto_correct_marker
+      return @auto_correct_marker if defined?(@auto_correct_marker)
+
+      @auto_correct_marker = auto_correct? ? 'marker_' + SecureRandom.uuid.tr('-', '_') : nil
+    end
+
     def parser
-      @parser ||= Parser.new
+      @parser ||= Parser.new(auto_correct_marker)
+    end
+
+    def digestor
+      @digestor ||= ->(contents) { Digest::SHA256.base64digest(contents) }
+    end
+
+    def file_mappings
+      @file_mappings ||= {}
     end
 
     def copy_erb_file(file, contents, temp_dir)
       code = parser.extract(contents)
+      new_file = temp_filename_for(file, temp_dir)
 
-      n = temp_filename_for(file, temp_dir)
-      FileUtils.mkdir_p(File.dirname(n))
+      if auto_correct?
+        properties = []
+        properties << new_file
+        properties << digestor.call(code)
 
-      File.open(n, 'w+') do |tmp_file|
-        tmp_file.write(code)
+        properties <<
+          if stdin?
+            contents
+          else
+            -> { File.read(file) }
+          end
+
+        file_mappings[file] = properties
+      end
+
+      unless stdin?
+        FileUtils.mkdir_p(File.dirname(new_file))
+
+        File.open(new_file, 'w+') do |tmp_file|
+          tmp_file.write(code)
+        end
       end
+
+      [code, new_file]
     end
 
     def temp_filename_for(file, temp_dir)

data/lib/ruumba/correctors.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Ruumba
+  # Responsible for extracted auto corrected code and updating the original ERBs files
+  module Correctors
+    # Module to help replace code
+    module Replacer
+      def handle_corrected_output(old_digest, new_contents, original_contents)
+        new_digest = digestor.call(new_contents)
+
+        return if old_digest == new_digest
+
+        original_contents = original_contents.call if original_contents.respond_to?(:call)
+
+        replaced_output = parser.replace(original_contents, new_contents)
+
+        yield(replaced_output) if replaced_output
+      end
+    end
+
+    # Corrector for when the checked file was passed through stdin.
+    class StdinCorrector
+      include Replacer
+
+      def initialize(digestor, parser)
+        @digestor = digestor
+        @parser = parser
+      end
+
+      def correct(stdout, stderr, file_mappings)
+        _, old_ruumba_digest, original_contents = *file_mappings.values.first
+
+        [stdout, stderr].each do |output|
+          next if output.nil? || output.empty?
+
+          matches = output.scan(/\A(.*^====================)?$(.*)\z/m)
+
+          next if matches.empty?
+
+          prefix, new_contents = *matches.first
+
+          handle_corrected_output(old_ruumba_digest, new_contents, original_contents) do |corrected_output|
+            output.clear
+            output.concat("#{prefix}\n#{corrected_output}")
+          end
+        end
+      end
+
+      private
+
+      attr_reader :digestor, :parser
+    end
+
+    # Corrector for when normal file checking
+    class FileCorrector
+      include Replacer
+
+      def initialize(digestor, parser)
+        @digestor = digestor
+        @parser = parser
+      end
+
+      def correct(_stdout, _stderr, file_mappings)
+        file_mappings.each do |original_file, (ruumba_file, old_ruumba_digest, original_contents)|
+          new_contents = File.read(ruumba_file)
+
+          handle_corrected_output(old_ruumba_digest, new_contents, original_contents) do |corrected_output|
+            File.open(original_file, 'w+') do |file_handle|
+              file_handle.write(corrected_output)
+            end
+          end
+        end
+      end
+
+      private
+
+      attr_reader :digestor, :parser
+    end
+  end
+end

data/lib/ruumba/parser.rb

@@ -8,6 +8,10 @@ module Ruumba
     # The regular expression to capture interpolated Ruby.
     ERB_REGEX = /<%[-=]?(.*?)-?%>/m
 
+    def initialize(region_start_marker = nil)
+      @region_start_marker = region_start_marker
+    end
+
     # Extracts Ruby code from an ERB template.
     # @return [String] The extracted ruby code
     def extract(contents)
@@ -16,16 +20,16 @@ module Ruumba
       extracted_ruby = +''
 
       last_match = [0, 0]
-      matches.each do |start_index, end_index|
+      matches.each_with_index do |(start_index, end_index), index|
         handle_region_before(start_index, last_match.last, file_text, extracted_ruby)
 
-        extracted_ruby << extract_match(file_text, start_index, end_index)
+        match_marker = "#{region_start_marker}_#{format('%010d', index + 1)}" if region_start_marker
+        extracted_ruby << extract_match(file_text, start_index, end_index, match_marker)
 
         last_match = [start_index, end_index]
       end
 
       extracted_ruby << file_text[last_match.last..-1].gsub(/./, ' ')
-      extracted_ruby.gsub!(/[^\S\r\n]+$/, '')
 
       # if we replaced <%== with <%= raw, try to shift the columns back to the
       # left so they match the original again
@@ -34,8 +38,44 @@ module Ruumba
       extracted_ruby
     end
 
+    def replace(old_contents, new_contents)
+      file_text, matches = parse(old_contents)
+
+      auto_corrected_erb = +''
+
+      last_match = [0, 0]
+      matches.each_with_index do |(start_index, end_index), index|
+        match_start = start_index
+        prev_end_index = last_match.last
+
+        if start_index > prev_end_index
+          region_before = file_text[prev_end_index..match_start - 1]
+
+          auto_corrected_erb << region_before
+        end
+
+        suffix = format('%010d', index + 1)
+        match_marker = "#{region_start_marker}_#{suffix}"
+
+        match_without_markers = new_contents[/\n#{match_marker}$\n(.*)\n#{match_marker}\n/m, 1]
+
+        # auto-correct is still experimental and can cause invalid ruby to be generated when extracting ruby from ERBs
+        return nil unless match_without_markers
+
+        auto_corrected_erb << match_without_markers
+
+        last_match = [start_index, end_index]
+      end
+
+      auto_corrected_erb << file_text[last_match.last..-1]
+
+      auto_corrected_erb
+    end
+
     private
 
+    attr_reader :region_start_marker
+
     def parse(contents)
       # http://edgeguides.rubyonrails.org/active_support_core_extensions.html#output-safety
       # replace '<%==' with '<%= raw' to avoid generating invalid ruby code
@@ -50,20 +90,24 @@ module Ruumba
     def handle_region_before(match_start, prev_end_index, file_text, extracted_ruby)
       return unless match_start > prev_end_index
 
+      last_position = extracted_ruby.length
+
       region_before = file_text[prev_end_index..match_start - 1]
 
-      extracted_ruby << region_before.gsub(/./, ' ')
+      region_before.gsub!(/./, ' ')
 
       # if the last match was on the same line, we need to use a semicolon to
       # separate statements
-      extracted_ruby[prev_end_index] = ';' if needs_stmt_delimiter?(prev_end_index, region_before)
+      extracted_ruby[last_position] = ';' if needs_stmt_delimiter?(prev_end_index, region_before)
+
+      extracted_ruby << region_before
     end
 
     def needs_stmt_delimiter?(last_match, region_before)
       last_match.positive? && region_before.index("\n").nil?
     end
 
-    def extract_match(file_text, start_index, end_index)
+    def extract_match(file_text, start_index, end_index, match_marker)
       file_text[start_index...end_index].tap do |region|
         # if there is a ruby comment inside, replace the beginning of each line
         # with the '#' so we end up with valid ruby
@@ -71,6 +115,9 @@ module Ruumba
         if region[0] == '#'
           region.gsub!(/^ /, '#')
           region.gsub!(/^(?!#)/, '#')
+        elsif match_marker
+          region.prepend("\n", match_marker, "\n")
+          region.concat("\n", match_marker, "\n")
         end
       end
     end

data/lib/ruumba/rubocop_runner.rb

@@ -5,11 +5,17 @@ require 'open3'
 module Ruumba
   # Runs rubocop on the files in the given target_directory
   class RubocopRunner
-    def initialize(arguments, current_directory, target_directory, rb_extension_enabled)
+    def initialize(arguments, current_directory, target_directory, stdin, rb_extension_enabled)
       @arguments = Array(arguments)
       @current_directory = current_directory
       @rb_extension_enabled = rb_extension_enabled
+      @stdin = stdin
       @target_directory = target_directory
+      @replacements = []
+
+      # if adding the .rb extension is enabled, remove the extension again from
+      # any output so it matches the actual files names we are linting
+      @replacements << [/\.erb\.rb/, '.erb'] if rb_extension_enabled
     end
 
     # Executes rubocop, updating filenames in the output if needed.
@@ -18,41 +24,32 @@ module Ruumba
       args = ['rubocop'] + arguments
       todo = target_directory.join('.rubocop_todo.yml')
 
-      replacements = []
-
-      # if adding the .rb extension is enabled, remove the extension again from
-      # any output so it matches the actual files names we are linting
-      replacements << [/\.erb\.rb/, '.erb'] if rb_extension_enabled
-
-      result = Dir.chdir(target_directory) do
+      results = Dir.chdir(target_directory) do
         replacements.unshift([/^#{Regexp.quote(Dir.pwd)}/, current_directory.to_s])
-        stdout, stderr, status = Open3.capture3(*args)
 
-        munge_output(stdout, stderr, replacements)
+        stdout, stderr, status = Open3.capture3(*args, stdin_data: stdin)
 
-        status.exitstatus
+        [munge_output(stdout), munge_output(stderr), status.exitstatus]
       end
 
       # copy the todo file back for the case where we've used --auto-gen-config
       FileUtils.cp(todo, current_directory) if todo.exist?
 
-      result
+      results
     end
 
     private
 
-    attr_reader :arguments, :current_directory, :rb_extension_enabled, :target_directory
+    attr_reader :arguments, :current_directory, :rb_extension_enabled, :replacements, :stdin, :target_directory
 
-    def munge_output(stdout, stderr, replacements)
-      [[STDOUT, stdout], [STDERR, stderr]].each do |output_stream, output|
-        next if output.nil? || output.empty?
+    def munge_output(output)
+      return output if output.nil? || output.empty?
 
-        replacements.each do |pattern, replacement|
-          output.gsub!(pattern, replacement)
-        end
-
-        output_stream.puts(output)
+      replacements.each do |pattern, replacement|
+        output = output.gsub(pattern, replacement)
       end
+
+      output
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruumba
 version: !ruby/object:Gem::Version
-  version: 0.1.10
+  version: 0.1.12
 platform: ruby
 authors:
 - Eric Weinstein
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-03 00:00:00.000000000 Z
+date: 2019-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -39,6 +39,7 @@ files:
 - bin/ruumba
 - lib/ruumba.rb
 - lib/ruumba/analyzer.rb
+- lib/ruumba/correctors.rb
 - lib/ruumba/iterators.rb
 - lib/ruumba/parser.rb
 - lib/ruumba/rake_task.rb
@@ -63,7 +64,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2.3
+rubygems_version: 2.6.14.3
 signing_key: 
 specification_version: 4
 summary: Allows users to lint Ruby code in ERB templates the same way they lint source