erb_lint 0.0.13 → 0.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 86e60e8bfa31cd289e7ead368d8eff2832a6a8f8
-  data.tar.gz: cae30be744c94ed73048403a4c1d911d2a5b8c15
+  metadata.gz: 185ec9589ef4da649b5f073871c8e1977a2820f6
+  data.tar.gz: 7588eff7bf3e74f3f887a5e81c6eaa72839c953a
 SHA512:
-  metadata.gz: c5b8f374aecc1a4541bbaa363d65e8b8b38cf3d6ffb36f9f517b8057527205c48cb2225c190fcf35f2a2c0952b0aa5035439509d2c8e5b517905a18c848b2127
-  data.tar.gz: 3661165a60a0c6f6185957a6c61948e7d66c6cdaaa27c9e205ca39e340c75aa366094f1859e3ab4a9bd4d122744f73f4c66bd2e4086e060e89ec2f310ea7a4d9
+  metadata.gz: 5e1d78d903307c1433b0c56a9ce63993fbda5802ba671cc4288c96096d18617dbf69c85837026b6222e4c8779c3f44fb65af44cb54d29f6fdfb6664ad2369f26
+  data.tar.gz: fe70e6836ed54f517b79d73261ac2c7101bfa29b335a4e09cfce39177d7b2f9d63c497e30016099793dd236266fd4e58b12a5c09a3475e555cb15f00a7dbd7b4

data/lib/erb_lint.rb

@@ -1,13 +1,16 @@
 # frozen_string_literal: true
 
-require 'erb_lint/version'
-require 'erb_lint/offense'
+require 'erb_lint/corrector'
+require 'erb_lint/file_loader'
 require 'erb_lint/linter_config'
 require 'erb_lint/linter_registry'
 require 'erb_lint/linter'
+require 'erb_lint/offense'
+require 'erb_lint/offset_corrector'
+require 'erb_lint/processed_source'
 require 'erb_lint/runner_config'
 require 'erb_lint/runner'
-require 'erb_lint/file_loader'
+require 'erb_lint/version'
 
 # Load linters
 Dir[File.expand_path('erb_lint/linters/**/*.rb', File.dirname(__FILE__))].each do |file|

data/lib/erb_lint/cli.rb

@@ -16,10 +16,19 @@ module ERBLint
     class ExitWithFailure < RuntimeError; end
     class ExitWithSuccess < RuntimeError; end
 
+    class Stats
+      attr_accessor :found, :corrected
+      def initialize
+        @found = 0
+        @corrected = 0
+      end
+    end
+
     def initialize
       @options = {}
       @config = nil
       @files = []
+      @stats = Stats.new
     end
 
     def run(args = ARGV)
@@ -33,31 +42,40 @@ module ERBLint
       load_config
       ensure_files_exist(lint_files)
 
-      puts "Linting #{lint_files.size} files with #{enabled_linter_classes.size} linters..."
+      if enabled_linter_classes.empty?
+        failure!('no linter available with current configuration')
+      end
+
+      puts "Linting #{lint_files.size} files with "\
+        "#{enabled_linter_classes.size} #{'autocorrectable ' if autocorrect?}linters..."
       puts
 
-      errors_found = false
       runner_config = @config.merge(runner_config_override)
       runner = ERBLint::Runner.new(file_loader, runner_config)
       lint_files.each do |filename|
-        offenses = runner.run(filename, File.read(filename))
-        offenses.each do |offense|
-          puts <<~EOF
-            #{offense.message}
-            In file: #{relative_filename(filename)}:#{offense.line_range.begin}
-
-          EOF
-          errors_found = true
+        begin
+          run_with_corrections(runner, filename)
+        rescue => e
+          puts "Exception occured when processing: #{relative_filename(filename)}"
+          puts e.message
+          puts e.backtrace.join("\n").red
+          puts
         end
       end
 
-      if errors_found
-        warn "Errors were found in ERB files".red
+      if @stats.corrected > 0
+        if @stats.found > 0
+          warn "#{@stats.corrected} error(s) corrected and #{@stats.found} error(s) remaining in ERB files".red
+        else
+          puts "#{@stats.corrected} error(s) corrected in ERB files".green
+        end
+      elsif @stats.found > 0
+        warn "#{@stats.found} error(s) were found in ERB files".red
       else
         puts "No errors were found in ERB files".green
       end
 
-      !errors_found
+      @stats.found == 0
     rescue OptionParser::InvalidOption, OptionParser::InvalidArgument, ExitWithFailure => e
       warn e.message.red
       false
@@ -71,6 +89,48 @@ module ERBLint
 
     private
 
+    def autocorrect?
+      @options[:autocorrect]
+    end
+
+    def run_with_corrections(runner, filename)
+      file_content = File.read(filename)
+      offenses = []
+
+      7.times do
+        processed_source = ERBLint::ProcessedSource.new(filename, file_content)
+        offenses = runner.run(processed_source)
+        break unless autocorrect? && offenses.any?
+
+        corrector = correct(processed_source, offenses)
+        break if corrector.corrections.empty?
+        break if processed_source.file_content == corrector.corrected_content
+
+        @stats.corrected += corrector.corrections.size
+
+        File.open(filename, "wb") do |file|
+          file.write(corrector.corrected_content)
+        end
+
+        file_content = corrector.corrected_content
+      end
+
+      @stats.found += offenses.size
+      offenses.each do |offense|
+        puts <<~EOF
+          #{offense.message}#{' (not autocorrected)'.red if autocorrect?}
+          In file: #{relative_filename(filename)}:#{offense.line_range.begin}
+
+        EOF
+      end
+    end
+
+    def correct(processed_source, offenses)
+      corrector = ERBLint::Corrector.new(processed_source, offenses)
+      failure!(corrector.diagnostics.join(', ')) if corrector.diagnostics.any?
+      corrector
+    end
+
     def config_filename
       @config_filename ||= @options[:config] || DEFAULT_CONFIG_FILENAME
     end
@@ -128,12 +188,17 @@ module ERBLint
     def enabled_linter_names
       @enabled_linter_names ||=
         @options[:enabled_linters] ||
-        known_linter_names.select { |name| @config.for_linter(name.camelize).enabled? }
+        known_linter_names
+          .select { |name| @config.for_linter(name.camelize).enabled? }
     end
 
     def enabled_linter_classes
       @enabled_linter_classes ||= ERBLint::LinterRegistry.linters
-        .select { |klass| enabled_linter_names.include?(klass.simple_name.underscore) }
+        .select { |klass| linter_can_run?(klass) && enabled_linter_names.include?(klass.simple_name.underscore) }
+    end
+
+    def linter_can_run?(klass)
+      !autocorrect? || klass.support_autocorrect?
     end
 
     def relative_filename(filename)
@@ -141,17 +206,13 @@ module ERBLint
     end
 
     def runner_config_override
-      if @options[:enabled_linters].present?
-        RunnerConfig.new(
-          linters: {}.tap do |linters|
-            ERBLint::LinterRegistry.linters.map do |klass|
-              linters[klass.simple_name] = { 'enabled' => enabled_linter_classes.include?(klass) }
-            end
+      RunnerConfig.new(
+        linters: {}.tap do |linters|
+          ERBLint::LinterRegistry.linters.map do |klass|
+            linters[klass.simple_name] = { 'enabled' => enabled_linter_classes.include?(klass) }
           end
-        )
-      else
-        RunnerConfig.new
-      end
+        end
+      )
     end
 
     def option_parser
@@ -184,6 +245,10 @@ module ERBLint
           @options[:enabled_linters] = linters
         end
 
+        opts.on("--autocorrect", "Correct offenses that can be corrected automatically (default: false)") do |config|
+          @options[:autocorrect] = config
+        end
+
         opts.on_tail("-h", "--help", "Show this message") do
           success!(opts)
         end

data/lib/erb_lint/corrector.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ERBLint
+  class Corrector
+    attr_reader :processed_source, :offenses, :corrected_content
+
+    def initialize(processed_source, offenses)
+      @processed_source = processed_source
+      @offenses = offenses
+      @corrected_content = corrector.rewrite
+    end
+
+    def corrections
+      @corrections ||= @offenses.map do |offense|
+        offense.linter.autocorrect(@processed_source, offense)
+      end.compact
+    end
+
+    def corrector
+      RuboCop::Cop::Corrector.new(@processed_source.source_buffer, corrections)
+    end
+
+    def diagnostics
+      corrector.diagnostics
+    end
+  end
+end

data/lib/erb_lint/linter.rb

@@ -23,6 +23,10 @@ module ERBLint
 
         linter.config_schema = LinterConfig
       end
+
+      def support_autocorrect?
+        method_defined?(:autocorrect)
+      end
     end
 
     # Must be implemented by the concrete inheriting class.
@@ -41,16 +45,7 @@ module ERBLint
       @config.excludes_file?(filename)
     end
 
-    def lint_file(file_content)
-      lines = file_content.scan(/[^\n]*\n|[^\n]+/)
-      lint_lines(lines)
-    end
-
-    protected
-
-    # The lint_lines method that contains the logic for the linter and returns a list of errors.
-    # Must be implemented by the concrete inheriting class.
-    def lint_lines(_lines)
+    def offenses(_processed_source)
       raise NotImplementedError, "must implement ##{__method__}"
     end
   end

data/lib/erb_lint/linters/deprecated_classes.rb

@@ -28,27 +28,39 @@ module ERBLint
         @addendum = @config.addendum
       end
 
-      def lint_file(file_content)
-        errors = []
-        parser = build_parser(file_content)
-        class_name_with_loc(parser).each do |class_name, loc|
-          errors.push(*generate_errors(class_name, loc.line_range))
-        end
-        text_tags_content(parser).each do |content|
-          errors.push(*lint_file(content))
-        end
-        errors
+      def offenses(processed_source)
+        process_nested_offenses(
+          source: processed_source,
+          offset: 0,
+          parent_source: processed_source,
+        )
       end
 
       private
 
-      def build_parser(file_content)
-        BetterHtml::Parser.new(file_content, template_language: :html)
+      def process_nested_offenses(source:, offset:, parent_source:)
+        offenses = []
+        class_name_with_loc(source).each do |class_name, loc|
+          range = parent_source.to_source_range(
+            offset + loc.start,
+            offset + loc.stop
+          )
+          offenses += generate_errors(class_name, range)
+        end
+        text_tags_content(source).each do |content_node|
+          sub_source = ProcessedSource.new(source.filename, content_node.loc.source)
+          offenses += process_nested_offenses(
+            source: sub_source,
+            offset: offset + content_node.loc.start,
+            parent_source: parent_source
+          )
+        end
+        offenses
       end
 
-      def class_name_with_loc(parser)
+      def class_name_with_loc(processed_source)
         Enumerator.new do |yielder|
-          tags(parser).each do |tag|
+          tags(processed_source).each do |tag|
             class_value = tag.attributes['class']&.value
             next unless class_value
             class_value.split(' ').each do |class_name|
@@ -58,39 +70,39 @@ module ERBLint
         end
       end
 
-      def text_tags_content(parser)
+      def text_tags_content(processed_source)
         Enumerator.new do |yielder|
-          script_tags(parser)
+          script_tags(processed_source)
             .select { |tag| tag.attributes['type']&.value == 'text/html' }
             .each do |tag|
-              index = parser.ast.to_a.find_index(tag.node)
-              next_node = parser.ast.to_a[index + 1]
+              index = processed_source.ast.to_a.find_index(tag.node)
+              next_node = processed_source.ast.to_a[index + 1]
 
-              yielder.yield(next_node.loc.source) if next_node.type == :text
+              yielder.yield(next_node) if next_node.type == :text
             end
         end
       end
 
-      def script_tags(parser)
-        tags(parser).select { |tag| tag.name == 'script' }
+      def script_tags(processed_source)
+        tags(processed_source).select { |tag| tag.name == 'script' }
       end
 
-      def tags(parser)
-        tag_nodes(parser).map { |tag_node| BetterHtml::Tree::Tag.from_node(tag_node) }
+      def tags(processed_source)
+        tag_nodes(processed_source).map { |tag_node| BetterHtml::Tree::Tag.from_node(tag_node) }
       end
 
-      def tag_nodes(parser)
-        parser.nodes_with_type(:tag)
+      def tag_nodes(processed_source)
+        processed_source.parser.nodes_with_type(:tag)
       end
 
-      def generate_errors(class_name, line_range)
+      def generate_errors(class_name, range)
         violated_rules(class_name).map do |violated_rule|
           suggestion = " #{violated_rule[:suggestion]}".rstrip
           message = "Deprecated class `%s` detected matching the pattern `%s`.%s #{@addendum}".strip
 
           Offense.new(
             self,
-            line_range,
+            range,
             format(message, class_name, violated_rule[:class_expr], suggestion)
           )
         end

data/lib/erb_lint/linters/erb_safety.rb

@@ -21,13 +21,17 @@ module ERBLint
         @config_filename = @config.better_html_config
       end
 
-      def lint_file(file_content)
-        errors = []
-        tester = Tester.new(file_content, config: better_html_config)
+      def offenses(processed_source)
+        offenses = []
+        tester = Tester.new(processed_source.file_content, config: better_html_config)
         tester.errors.each do |error|
-          errors << format_offense(error)
+          offenses << Offense.new(
+            self,
+            processed_source.to_source_range(error.location.start, error.location.stop),
+            error.message
+          )
         end
-        errors
+        offenses
       end
 
       private
@@ -43,14 +47,6 @@ module ERBLint
           BetterHtml::Config.new(**config_hash)
         end
       end
-
-      def format_offense(error)
-        Offense.new(
-          self,
-          error.location.line_range,
-          error.message
-        )
-      end
     end
   end
 end

data/lib/erb_lint/linters/final_newline.rb

@@ -16,28 +16,39 @@ module ERBLint
         @new_lines_should_be_present = @config.present?
       end
 
-      protected
+      def offenses(processed_source)
+        file_content = processed_source.file_content
 
-      def lint_lines(lines)
-        errors = []
-        return errors if lines.empty?
+        offenses = []
+        return offenses if file_content.empty?
 
-        ends_with_newline = lines.last.chars[-1] == "\n"
+        match = file_content.match(/(\n+)\z/)
+        ends_with_newline = match.present?
 
         if @new_lines_should_be_present && !ends_with_newline
-          errors << Offense.new(
+          offenses << Offense.new(
             self,
-            Range.new(lines.length, lines.length),
+            processed_source.to_source_range(file_content.size, file_content.size - 1),
             'Missing a trailing newline at the end of the file.'
           )
         elsif !@new_lines_should_be_present && ends_with_newline
-          errors << Offense.new(
+          offenses << Offense.new(
             self,
-            Range.new(lines.length, lines.length),
-            'Remove the trailing newline at the end of the file.'
+            processed_source.to_source_range(match.begin(0), match.end(0) - 1),
+            "Remove #{match[0].size} trailing newline at the end of the file."
           )
         end
-        errors
+        offenses
+      end
+
+      def autocorrect(_processed_source, offense)
+        lambda do |corrector|
+          if @new_lines_should_be_present
+            corrector.insert_after(offense.source_range, "\n")
+          else
+            corrector.remove_trailing(offense.source_range, offense.source_range.size)
+          end
+        end
       end
     end
   end

data/lib/erb_lint/linters/rubocop.rb

@@ -17,6 +17,7 @@ module ERBLint
 
       self.config_schema = ConfigSchema
 
+      SUFFIX_EXPR = /[[:blank:]]*\Z/
       # copied from Rails: action_view/template/handlers/erb/erubi.rb
       BLOCK_EXPR = /\s*((\s+|\))do|\{)(\s*\|[^|]*\|)?\s*\Z/
 
@@ -27,24 +28,83 @@ module ERBLint
         @rubocop_config = RuboCop::ConfigLoader.merge_with_default(custom_config, '')
       end
 
-      def lint_file(file_content)
-        errors = []
-        parser = BetterHtml::Parser.new(file_content, template_language: :html)
-        parser.ast.descendants(:erb).each do |erb_node|
-          _, _, code_node, = *erb_node
-          code = code_node.loc.source.sub(/\A[[:blank:]]*/, '')
-          code = "#{' ' * erb_node.loc.column}#{code}"
-          code = code.sub(BLOCK_EXPR, '')
-          offenses = inspect_content(code)
-          offenses&.each do |offense|
-            errors << format_offense(file_content, code_node, offense)
-          end
+      def offenses(processed_source)
+        offenses = []
+        processed_source.ast.descendants(:erb).each do |erb_node|
+          offenses.push(*inspect_content(processed_source, erb_node))
+        end
+        offenses
+      end
+
+      def autocorrect(processed_source, offense)
+        return unless offense.correction
+        lambda do |corrector|
+          passthrough = OffsetCorrector.new(
+            processed_source,
+            corrector,
+            offense.offset,
+            offense.bound_range,
+          )
+          offense.correction.call(passthrough)
         end
-        errors
       end
 
       private
 
+      class OffenseWithCorrection < Offense
+        attr_reader :correction, :offset, :bound_range
+        def initialize(linter, source_range, message, correction:, offset:, bound_range:)
+          super(linter, source_range, message)
+          @correction = correction
+          @offset = offset
+          @bound_range = bound_range
+        end
+      end
+
+      def inspect_content(processed_source, erb_node)
+        indicator, _, code_node, = *erb_node
+        return if indicator == '#'
+
+        original_source = code_node.loc.source
+        trimmed_source = original_source.sub(BLOCK_EXPR, '').sub(SUFFIX_EXPR, '')
+        alignment_column = code_node.loc.column
+        aligned_source = "#{' ' * alignment_column}#{trimmed_source}"
+
+        source = rubocop_processed_source(aligned_source)
+        return unless source.valid_syntax?
+
+        offenses = []
+        team = build_team
+        team.inspect_file(source)
+        team.cops.each do |cop|
+          cop.offenses.reject(&:disabled?).each_with_index do |rubocop_offense, index|
+            correction = cop.corrections[index] if rubocop_offense.corrected?
+
+            offset = code_node.loc.start - alignment_column
+            offense_range = processed_source.to_source_range(
+              offset + rubocop_offense.location.begin_pos,
+              offset + rubocop_offense.location.end_pos - 1,
+            )
+
+            bound_range = processed_source.to_source_range(
+              code_node.loc.start,
+              code_node.loc.stop
+            )
+
+            offenses <<
+              OffenseWithCorrection.new(
+                self,
+                offense_range,
+                rubocop_offense.message.strip,
+                correction: correction,
+                offset: offset,
+                bound_range: bound_range,
+              )
+          end
+        end
+        offenses
+      end
+
       def tempfile_from(filename, content)
         Tempfile.create(File.basename(filename), Dir.pwd) do |tempfile|
           tempfile.write(content)
@@ -54,14 +114,7 @@ module ERBLint
         end
       end
 
-      def inspect_content(content)
-        source = processed_source(content)
-        return unless source.valid_syntax?
-        offenses = team.inspect_file(source)
-        offenses.reject(&:disabled?)
-      end
-
-      def processed_source(content)
+      def rubocop_processed_source(content)
         RuboCop::ProcessedSource.new(
           content,
           @rubocop_config.target_ruby_version,
@@ -69,29 +122,25 @@ module ERBLint
         )
       end
 
-      def team
-        cop_classes =
-          if @only_cops.present?
-            selected_cops = RuboCop::Cop::Cop.all.select { |cop| cop.match?(@only_cops) }
-            RuboCop::Cop::Registry.new(selected_cops)
-          elsif @rubocop_config['Rails']['Enabled']
-            RuboCop::Cop::Registry.new(RuboCop::Cop::Cop.all)
-          else
-            RuboCop::Cop::Cop.non_rails
-          end
-        RuboCop::Cop::Team.new(cop_classes, @rubocop_config, extra_details: true, display_cop_names: true)
+      def cop_classes
+        if @only_cops.present?
+          selected_cops = RuboCop::Cop::Cop.all.select { |cop| cop.match?(@only_cops) }
+          RuboCop::Cop::Registry.new(selected_cops)
+        elsif @rubocop_config['Rails']['Enabled']
+          RuboCop::Cop::Registry.new(RuboCop::Cop::Cop.all)
+        else
+          RuboCop::Cop::Cop.non_rails
+        end
       end
 
-      def format_offense(file_content, code_node, offense)
-        loc = BetterHtml::Tokenizer::Location.new(
-          file_content,
-          code_node.loc.start + offense.location.begin_pos,
-          code_node.loc.start + offense.location.end_pos - 1,
-        )
-        Offense.new(
-          self,
-          loc.line_range,
-          offense.message.strip
+      def build_team
+        RuboCop::Cop::Team.new(
+          cop_classes,
+          @rubocop_config,
+          extra_details: true,
+          display_cop_names: true,
+          auto_correct: true,
+          stdin: "",
         )
       end
 

data/lib/erb_lint/offense.rb

@@ -3,25 +3,32 @@
 module ERBLint
   # Defines common functionality available to all linters.
   class Offense
-    attr_reader :linter, :line_range, :message
+    attr_reader :linter, :source_range, :message
 
-    def initialize(linter, line_range, message)
+    def initialize(linter, source_range, message)
+      unless source_range.is_a?(Parser::Source::Range)
+        raise ArgumentError, "expected Parser::Source::Range for arg 2"
+      end
       @linter = linter
-      @line_range = line_range
+      @source_range = source_range
       @message = message
     end
 
     def inspect
       "#<#{self.class.name} linter=#{linter.class.name} "\
-        "line_range=#{line_range} "\
+        "source_range=#{source_range.begin_pos}..#{source_range.end_pos - 1} "\
         "message=#{message}>"
     end
 
     def ==(other)
-      other.class == self.class &&
+      other.class <= ERBLint::Offense &&
         other.linter == linter &&
-        other.line_range == line_range &&
+        other.source_range == source_range &&
         other.message == message
     end
+
+    def line_range
+      Range.new(source_range.line, source_range.last_line)
+    end
   end
 end

data/lib/erb_lint/offset_corrector.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module ERBLint
+  class OffsetCorrector
+    def initialize(processed_source, corrector, offset, bound_range)
+      @processed_source = processed_source
+      @corrector = corrector
+      @offset = offset
+      @bound_range = bound_range
+    end
+
+    def remove(range)
+      @corrector.remove(range_with_offset(range))
+    end
+
+    def insert_before(range, content)
+      @corrector.insert_before(range_with_offset(range), content)
+    end
+
+    def insert_after(range, content)
+      @corrector.insert_after(range_with_offset(range), content)
+    end
+
+    def replace(range, content)
+      @corrector.replace(range_with_offset(range), content)
+    end
+
+    def remove_preceding(range, size)
+      @corrector.remove_preceding(range_with_offset(range), size)
+    end
+
+    def remove_leading(range, size)
+      @corrector.remove_leading(range_with_offset(range), size)
+    end
+
+    def remove_trailing(range, size)
+      @corrector.remove_trailing(range_with_offset(range), size)
+    end
+
+    def range_with_offset(range)
+      @processed_source.to_source_range(
+        bound(@offset + range.begin_pos),
+        bound(@offset + range.end_pos - 1),
+      )
+    end
+
+    def bound(pos)
+      [
+        [pos, @bound_range.begin_pos].max,
+        @bound_range.end_pos - 1
+      ].min
+    end
+  end
+end

data/lib/erb_lint/processed_source.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ERBLint
+  class ProcessedSource
+    attr_reader :filename, :file_content, :parser
+
+    def initialize(filename, file_content)
+      @filename = filename
+      @file_content = file_content
+      @parser = BetterHtml::Parser.new(file_content, template_language: :html)
+    end
+
+    def ast
+      @parser.ast
+    end
+
+    def source_buffer
+      @source_buffer ||= begin
+        buffer = Parser::Source::Buffer.new(filename)
+        buffer.source = file_content
+        buffer
+      end
+    end
+
+    def to_source_range(begin_pos, end_pos)
+      Parser::Source::Range.new(source_buffer, begin_pos, end_pos + 1)
+    end
+  end
+end

data/lib/erb_lint/runner.rb

@@ -15,12 +15,12 @@ module ERBLint
       end
     end
 
-    def run(filename, file_content)
+    def run(processed_source)
       offenses = []
       @linters
-        .reject { |linter| linter.excludes_file?(filename) }
+        .reject { |linter| linter.excludes_file?(processed_source.filename) }
         .each do |linter|
-        offenses += linter.lint_file(file_content)
+        offenses += linter.offenses(processed_source)
       end
       offenses
     end

data/lib/erb_lint/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ERBLint
-  VERSION = '0.0.13'
+  VERSION = '0.0.14'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: erb_lint
 version: !ruby/object:Gem::Version
-  version: 0.0.13
+  version: 0.0.14
 platform: ruby
 authors:
 - Justin Chan
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-01-10 00:00:00.000000000 Z
+date: 2018-01-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: better_html
@@ -133,6 +133,7 @@ files:
 - exe/erblint
 - lib/erb_lint.rb
 - lib/erb_lint/cli.rb
+- lib/erb_lint/corrector.rb
 - lib/erb_lint/file_loader.rb
 - lib/erb_lint/linter.rb
 - lib/erb_lint/linter_config.rb
@@ -142,6 +143,8 @@ files:
 - lib/erb_lint/linters/final_newline.rb
 - lib/erb_lint/linters/rubocop.rb
 - lib/erb_lint/offense.rb
+- lib/erb_lint/offset_corrector.rb
+- lib/erb_lint/processed_source.rb
 - lib/erb_lint/runner.rb
 - lib/erb_lint/runner_config.rb
 - lib/erb_lint/version.rb