erb_lint 0.0.21 → 0.0.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7c5c19ac1eafb41b42b89239504fccaf8f1f52a0
-  data.tar.gz: 3afb969caac48e9c7960cddbec2f55630322580d
+  metadata.gz: 1ec3e8e2ac9c73109d17f77b2e93a43e12f8c89e
+  data.tar.gz: 116d80b17dcf0ff05f356dd21fbc34f3f3af4da6
 SHA512:
-  metadata.gz: 3716dfb6a37ffe9f3c4b27804cccc597f3da89a46c2075c0bdbb54c9b7840c952f391ff8d8a78bcc2bd07ee56d2baa5972084455671c79cd87a7f588080f1372
-  data.tar.gz: 7582a2c11435135fa681c27b5e7bcc904a3a1e67d01c8dad930e1d89b8d8d7e9959e4b632701971f14eac3374dd2789f1b68f8c9ebaf05bd7c988f536a57dc10
+  metadata.gz: 300e58e388b3d6904b750bfeb2ea2576490204191a5160cd3e8929421ca47804b114f706c8cd3be96b2e22a27d8cef0a3d1970de18c4b54ed9611b16f2052874
+  data.tar.gz: 9a02fefe7fecd0af7cba69ba7c3777a20c51af7c0621c6b3471538fad81a510806935e8a142b4233cafe96772add6960f8d7935668a7800c88db40da5c1b518a

data/lib/erb_lint/cli.rb

@@ -51,10 +51,9 @@ module ERBLint
         "#{enabled_linter_classes.size} #{'autocorrectable ' if autocorrect?}linters..."
       puts
 
-      runner = ERBLint::Runner.new(file_loader, @config)
       lint_files.each do |filename|
         begin
-          run_with_corrections(runner, filename)
+          run_with_corrections(filename)
         rescue => e
           puts "Exception occured when processing: #{relative_filename(filename)}"
           puts e.message
@@ -64,8 +63,9 @@ module ERBLint
       end
 
       if @stats.corrected > 0
-        if @stats.found > 0
-          warn "#{@stats.corrected} error(s) corrected and #{@stats.found} error(s) remaining in ERB files".red
+        corrected_found_diff = @stats.found - @stats.corrected
+        if corrected_found_diff > 0
+          warn "#{@stats.corrected} error(s) corrected and #{corrected_found_diff} error(s) remaining in ERB files".red
         else
           puts "#{@stats.corrected} error(s) corrected in ERB files".green
         end
@@ -93,16 +93,17 @@ module ERBLint
       @options[:autocorrect]
     end
 
-    def run_with_corrections(runner, filename)
+    def run_with_corrections(filename)
       file_content = File.read(filename)
-      offenses = []
+
+      runner = ERBLint::Runner.new(file_loader, @config)
 
       7.times do
         processed_source = ERBLint::ProcessedSource.new(filename, file_content)
-        offenses = runner.run(processed_source)
-        break unless autocorrect? && offenses.any?
+        runner.run(processed_source)
+        break unless autocorrect? && runner.offenses.any?
 
-        corrector = correct(processed_source, offenses)
+        corrector = correct(processed_source, runner.offenses)
         break if corrector.corrections.empty?
         break if processed_source.file_content == corrector.corrected_content
 
@@ -113,10 +114,11 @@ module ERBLint
         end
 
         file_content = corrector.corrected_content
+        runner.clear_offenses
       end
 
-      @stats.found += offenses.size
-      offenses.each do |offense|
+      @stats.found += runner.offenses.size
+      runner.offenses.each do |offense|
         puts <<~EOF
           #{offense.message}#{' (not autocorrected)'.red if autocorrect?}
           In file: #{relative_filename(filename)}:#{offense.line_range.begin}

data/lib/erb_lint/linter.rb

@@ -29,12 +29,15 @@ module ERBLint
       end
     end
 
+    attr_reader :offenses
+
     # Must be implemented by the concrete inheriting class.
     def initialize(file_loader, config)
       @file_loader = file_loader
       @config = config
       raise ArgumentError, "expect `config` to be #{self.class.config_schema} instance, "\
         "not #{config.class}" unless config.is_a?(self.class.config_schema)
+      @offenses = []
     end
 
     def enabled?
@@ -45,8 +48,16 @@ module ERBLint
       @config.excludes_file?(filename)
     end
 
-    def offenses(_processed_source)
+    def run(_processed_source)
       raise NotImplementedError, "must implement ##{__method__}"
     end
+
+    def add_offense(source_range, message, context = nil)
+      @offenses << Offense.new(self, source_range, message, context)
+    end
+
+    def clear_offenses
+      @offenses = []
+    end
   end
 end

data/lib/erb_lint/linters/allowed_script_type.rb

@@ -19,58 +19,52 @@ module ERBLint
       end
       self.config_schema = ConfigSchema
 
-      def offenses(processed_source)
+      def run(processed_source)
         parser = processed_source.parser
-        [].tap do |offenses|
-          parser.nodes_with_type(:tag).each do |tag_node|
-            tag = BetterHtml::Tree::Tag.from_node(tag_node)
-            next if tag.closing?
-            next unless tag.name == 'script'
+        parser.nodes_with_type(:tag).each do |tag_node|
+          tag = BetterHtml::Tree::Tag.from_node(tag_node)
+          next if tag.closing?
+          next unless tag.name == 'script'
 
-            if @config.disallow_inline_scripts?
-              name_node = tag_node.to_a[1]
-              offenses << Offense.new(
-                self,
-                processed_source.to_source_range(name_node.loc.start, name_node.loc.stop),
-                "Avoid using inline `<script>` tags altogether. "\
-                "Instead, move javascript code into a static file."
-              )
-              next
-            end
+          if @config.disallow_inline_scripts?
+            name_node = tag_node.to_a[1]
+            add_offense(
+              name_node.loc,
+              "Avoid using inline `<script>` tags altogether. "\
+              "Instead, move javascript code into a static file."
+            )
+            next
+          end
 
-            type_attribute = tag.attributes['type']
-            type_present = type_attribute.present? && type_attribute.value_node.present?
+          type_attribute = tag.attributes['type']
+          type_present = type_attribute.present? && type_attribute.value_node.present?
 
-            if !type_present && !@config.allow_blank?
-              name_node = tag_node.to_a[1]
-              offenses << Offense.new(
-                self,
-                processed_source.to_source_range(name_node.loc.start, name_node.loc.stop),
-                "Missing a `type=\"text/javascript\"` attribute to `<script>` tag.",
-                [type_attribute]
-              )
-            elsif type_present && !@config.allowed_types.include?(type_attribute.value)
-              offenses << Offense.new(
-                self,
-                processed_source.to_source_range(type_attribute.loc.start, tag_node.loc.stop),
-                "Avoid using #{type_attribute.value.inspect} as type for `<script>` tag. "\
-                "Must be one of: #{@config.allowed_types.join(', ')}"\
-                "#{' (or no type attribute)' if @config.allow_blank?}."
-              )
-            end
+          if !type_present && !@config.allow_blank?
+            name_node = tag_node.to_a[1]
+            add_offense(
+              name_node.loc,
+              "Missing a `type=\"text/javascript\"` attribute to `<script>` tag.",
+              [type_attribute]
+            )
+          elsif type_present && !@config.allowed_types.include?(type_attribute.value)
+            add_offense(
+              type_attribute.loc,
+              "Avoid using #{type_attribute.value.inspect} as type for `<script>` tag. "\
+              "Must be one of: #{@config.allowed_types.join(', ')}"\
+              "#{' (or no type attribute)' if @config.allow_blank?}."
+            )
           end
         end
       end
 
-      def autocorrect(processed_source, offense)
+      def autocorrect(_processed_source, offense)
         return unless offense.context
         lambda do |corrector|
           type_attribute, = *offense.context
           if type_attribute.nil?
             corrector.insert_after(offense.source_range, ' type="text/javascript"')
           elsif !type_attribute.value.present?
-            range = processed_source.to_source_range(type_attribute.node.loc.start, type_attribute.node.loc.stop)
-            corrector.replace(range, 'type="text/javascript"')
+            corrector.replace(type_attribute.node.loc, 'type="text/javascript"')
           end
         end
       end

data/lib/erb_lint/linters/closing_erb_tag_indent.rb

@@ -10,8 +10,8 @@ module ERBLint
       START_SPACES = /\A([[:space:]]*)/m
       END_SPACES = /([[:space:]]*)\z/m
 
-      def offenses(processed_source)
-        processed_source.ast.descendants(:erb).each_with_object([]) do |erb_node, offenses|
+      def run(processed_source)
+        processed_source.ast.descendants(:erb).each do |erb_node|
           _, _, code_node, = *erb_node
           code = code_node.children.first
 
@@ -22,25 +22,22 @@ module ERBLint
           end_with_newline = end_spaces.include?("\n")
 
           if !start_with_newline && end_with_newline
-            offenses << Offense.new(
-              self,
-              processed_source.to_source_range(code_node.loc.stop - end_spaces.size + 1, code_node.loc.stop),
+            add_offense(
+              code_node.loc.end.adjust(begin_pos: -end_spaces.size),
               "Remove newline before `%>` to match start of tag.",
               ' '
             )
           elsif start_with_newline && !end_with_newline
-            offenses << Offense.new(
-              self,
-              processed_source.to_source_range(code_node.loc.stop, code_node.loc.stop),
+            add_offense(
+              code_node.loc.end.adjust(begin_pos: -end_spaces.size),
               "Insert newline before `%>` to match start of tag.",
               "\n"
             )
           elsif start_with_newline && end_with_newline
             current_indent = end_spaces.split("\n", -1).last
             if erb_node.loc.column != current_indent.size
-              offenses << Offense.new(
-                self,
-                processed_source.to_source_range(code_node.loc.stop - current_indent.size + 1, code_node.loc.stop),
+              add_offense(
+                code_node.loc.end.adjust(begin_pos: -current_indent.size),
                 "Indent `%>` on column #{erb_node.loc.column} to match start of tag.",
                 ' ' * erb_node.loc.column
               )

data/lib/erb_lint/linters/deprecated_classes.rb

@@ -29,7 +29,7 @@ module ERBLint
         @addendum = @config.addendum
       end
 
-      def offenses(processed_source)
+      def run(processed_source)
         process_nested_offenses(
           source: processed_source,
           offset: 0,
@@ -40,23 +40,18 @@ module ERBLint
       private
 
       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)
+          range = parent_source.to_source_range(loc).offset(offset)
+          generate_offenses(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(
+          process_nested_offenses(
             source: sub_source,
-            offset: offset + content_node.loc.start,
+            offset: offset + content_node.loc.begin_pos,
             parent_source: parent_source
           )
         end
-        offenses
       end
 
       def class_name_with_loc(processed_source)
@@ -96,13 +91,12 @@ module ERBLint
         processed_source.parser.nodes_with_type(:tag)
       end
 
-      def generate_errors(class_name, range)
-        violated_rules(class_name).map do |violated_rule|
+      def generate_offenses(class_name, range)
+        violated_rules(class_name).each do |violated_rule|
           suggestion = " #{violated_rule[:suggestion]}".rstrip
           message = "Deprecated class `%s` detected matching the pattern `%s`.%s #{@addendum}".strip
 
-          Offense.new(
-            self,
+          add_offense(
             range,
             format(message, class_name, violated_rule[:class_expr], suggestion)
           )

data/lib/erb_lint/linters/erb_safety.rb

@@ -20,21 +20,16 @@ module ERBLint
         @config_filename = @config.better_html_config
       end
 
-      def offenses(processed_source)
-        offenses = []
-
-        parser = BetterHtml::Parser.new(processed_source.file_content, template_language: :html)
-        testers_for(parser).each do |tester|
+      def run(processed_source)
+        testers_for(processed_source.parser).each do |tester|
           tester.validate
           tester.errors.each do |error|
-            offenses << Offense.new(
-              self,
-              processed_source.to_source_range(error.location.start, error.location.stop),
+            add_offense(
+              error.location,
               error.message
             )
           end
         end
-        offenses
       end
 
       private

data/lib/erb_lint/linters/extra_newline.rb

@@ -8,22 +8,16 @@ module ERBLint
 
       EXTRA_NEWLINES = /(\n{3,})/m
 
-      def offenses(processed_source)
-        matches = processed_source.file_content.match(EXTRA_NEWLINES)
-        return [] unless matches
+      def run(processed_source)
+        return unless (matches = processed_source.file_content.match(EXTRA_NEWLINES))
 
-        offenses = []
         matches.captures.each_index do |index|
-          offenses << Offense.new(
-            self,
-            processed_source.to_source_range(
-              matches.begin(index) + 2,
-              matches.end(index) - 1
-            ),
+          add_offense(
+            processed_source
+              .to_source_range((matches.begin(index) + 2)...matches.end(index)),
             "Extra blank line detected."
           )
         end
-        offenses
       end
 
       def autocorrect(_processed_source, offense)

data/lib/erb_lint/linters/final_newline.rb

@@ -16,40 +16,37 @@ module ERBLint
         @new_lines_should_be_present = @config.present?
       end
 
-      def offenses(processed_source)
+      def run(processed_source)
         file_content = processed_source.file_content
 
-        offenses = []
-        return offenses if file_content.empty?
+        return if file_content.empty?
 
         match = file_content.match(/(\n+)\z/)
         final_newline = match&.captures&.first || ""
 
         if @new_lines_should_be_present && final_newline.size != 1
           if final_newline.empty?
-            offenses << Offense.new(
-              self,
-              processed_source.to_source_range(file_content.size, file_content.size - 1),
+            add_offense(
+              processed_source.to_source_range(file_content.size...file_content.size),
               'Missing a trailing newline at the end of the file.',
               :insert
             )
           else
-            offenses << Offense.new(
-              self,
-              processed_source.to_source_range(file_content.size - final_newline.size + 1, file_content.size - 1),
+            add_offense(
+              processed_source.to_source_range(
+                (file_content.size - final_newline.size + 1)...file_content.size
+              ),
               'Remove multiple trailing newline at the end of the file.',
               :remove
             )
           end
         elsif !@new_lines_should_be_present && !final_newline.empty?
-          offenses << Offense.new(
-            self,
-            processed_source.to_source_range(match.begin(0), match.end(0) - 1),
+          add_offense(
+            processed_source.to_source_range(match.begin(0)...match.end(0)),
             "Remove #{final_newline.size} trailing newline at the end of the file.",
             :remove
           )
         end
-        offenses
       end
 
       def autocorrect(_processed_source, offense)

data/lib/erb_lint/linters/hard_coded_string.rb

@@ -22,24 +22,23 @@ module ERBLint
       end
       self.config_schema = ConfigSchema
 
-      def offenses(processed_source)
+      def run(processed_source)
         hardcoded_strings = processed_source.ast.descendants(:text).each_with_object([]) do |text_node, to_check|
           next if javascript?(processed_source, text_node)
 
           offended_strings = text_node.to_a.select { |node| relevant_node(node) }
           offended_strings.each do |offended_string|
             offended_string.split("\n").each do |str|
-              to_check << [text_node, str] if str.length > 1
+              to_check << [text_node, str] if check_string?(str)
             end
           end
         end
 
-        hardcoded_strings.compact.map do |text_node, offended_str|
-          range_begin, range_stop = find_range(text_node, offended_str)
-          source_range = processed_source.to_source_range(range_begin, range_stop)
+        hardcoded_strings.compact.each do |text_node, offended_str|
+          range = find_range(text_node, offended_str)
+          source_range = processed_source.to_source_range(range)
 
-          Offense.new(
-            self,
+          add_offense(
             source_range,
             message(source_range.source)
           )
@@ -50,9 +49,9 @@ module ERBLint
         match = node.loc.source.match(Regexp.new(Regexp.quote(str.strip)))
         return unless match
 
-        range_begin = match.begin(0) + node.loc.start
-        range_end   = match.end(0) + node.loc.start - 1
-        [range_begin, range_end]
+        range_begin = match.begin(0) + node.loc.begin_pos
+        range_end   = match.end(0) + node.loc.begin_pos
+        (range_begin...range_end)
       end
 
       def autocorrect(processed_source, offense)
@@ -69,6 +68,11 @@ module ERBLint
 
       private
 
+      def check_string?(str)
+        string = str.gsub(/\s*/, '')
+        string.length > 1 && !%w(&nbsp;).include?(string)
+      end
+
       def load_corrector
         corrector_name = @config['corrector'].fetch('name') { raise MissingCorrector }
         raise ForbiddenCorrector unless ALLOWED_CORRECTORS.include?(corrector_name)

data/lib/erb_lint/linters/no_javascript_tag_helper.rb

@@ -15,9 +15,7 @@ module ERBLint
       end
       self.config_schema = ConfigSchema
 
-      def offenses(processed_source)
-        offenses = []
-
+      def run(processed_source)
         parser = processed_source.parser
         parser.ast.descendants(:erb).each do |erb_node|
           indicator_node, _, code_node, _ = *erb_node
@@ -29,16 +27,13 @@ module ERBLint
           send_node = ruby_node.descendants(:send).first
           next unless send_node&.method_name?(:javascript_tag)
 
-          offenses << Offense.new(
-            self,
-            processed_source.to_source_range(erb_node.loc.start, erb_node.loc.stop),
+          add_offense(
+            erb_node.loc,
             "Avoid using 'javascript_tag do' as it confuses tests "\
             "that validate html, use inline <script> instead",
             [erb_node, send_node]
           )
         end
-
-        offenses
       end
 
       def autocorrect(processed_source, offense)
@@ -56,10 +51,6 @@ module ERBLint
         return unless (1..2).cover?(nodes.size)
 
         begin_node, end_node = nodes
-        begin_range = processed_source
-          .to_source_range(begin_node.loc.start, begin_node.loc.stop)
-        end_range = processed_source
-          .to_source_range(end_node.loc.start, end_node.loc.stop) if end_node
 
         argument_nodes = send_node.arguments
         return unless (0..2).cover?(argument_nodes.size)
@@ -76,13 +67,13 @@ module ERBLint
         if end_node
           begin_content = "<script#{arguments}>"
           begin_content += "\n//<![CDATA[\n" if @config.correction_style == :cdata
-          corrector.replace(begin_range, begin_content)
+          corrector.replace(begin_node.loc, begin_content)
           end_content = "</script>"
           end_content = "\n//]]>\n" + end_content if @config.correction_style == :cdata
-          corrector.replace(end_range, end_content)
+          corrector.replace(end_node.loc, end_content)
         elsif script_content
           script_content = "\n//<![CDATA[\n#{script_content}\n//]]>\n" if @config.correction_style == :cdata
-          corrector.replace(begin_range,
+          corrector.replace(begin_node.loc,
             "<script#{arguments}>#{script_content}</script>")
         end
       rescue Utils::RubyToERB::Error, Utils::BlockMap::ParseError

data/lib/erb_lint/linters/parser_errors.rb

@@ -5,11 +5,10 @@ module ERBLint
     class ParserErrors < Linter
       include LinterRegistry
 
-      def offenses(processed_source)
-        processed_source.parser.parser_errors.map do |error|
-          Offense.new(
-            self,
-            processed_source.to_source_range(error.loc.start, error.loc.stop - 1),
+      def run(processed_source)
+        processed_source.parser.parser_errors.each do |error|
+          add_offense(
+            error.loc,
             "#{error.message} (at #{error.loc.source})"
           )
         end

data/lib/erb_lint/linters/right_trim.rb

@@ -12,18 +12,15 @@ module ERBLint
       end
       self.config_schema = ConfigSchema
 
-      def offenses(processed_source)
-        [].tap do |offenses|
-          processed_source.ast.descendants(:erb).each do |erb_node|
-            _, _, _, trim_node = *erb_node
-            next if trim_node.nil? || trim_node.loc.source == @config.enforced_style
+      def run(processed_source)
+        processed_source.ast.descendants(:erb).each do |erb_node|
+          _, _, _, trim_node = *erb_node
+          next if trim_node.nil? || trim_node.loc.source == @config.enforced_style
 
-            offenses << Offense.new(
-              self,
-              processed_source.to_source_range(trim_node.loc.start, trim_node.loc.stop),
-              "Prefer #{@config.enforced_style}%> instead of #{trim_node.loc.source}%> for trimming on the right."
-            )
-          end
+          add_offense(
+            trim_node.loc,
+            "Prefer #{@config.enforced_style}%> instead of #{trim_node.loc.source}%> for trimming on the right."
+          )
         end
       end
 

data/lib/erb_lint/linters/rubocop.rb

@@ -29,23 +29,23 @@ module ERBLint
         @rubocop_config = RuboCop::ConfigLoader.merge_with_default(custom_config, '')
       end
 
-      def offenses(processed_source)
-        descendant_nodes(processed_source).each_with_object([]) do |erb_node, offenses|
-          offenses.push(*inspect_content(processed_source, erb_node))
+      def run(processed_source)
+        descendant_nodes(processed_source).each do |erb_node|
+          inspect_content(processed_source, erb_node)
         end
       end
 
       def autocorrect(processed_source, offense)
-        return unless offense.is_a?(OffenseWithCorrection)
+        return unless offense.context
 
         lambda do |corrector|
           passthrough = Utils::OffsetCorrector.new(
             processed_source,
             corrector,
-            offense.offset,
-            offense.bound_range,
+            offense.context[:offset],
+            offense.context[:bound_range],
           )
-          offense.correction.call(passthrough)
+          offense.context[:rubocop_correction].call(passthrough)
         end
       end
 
@@ -55,16 +55,6 @@ module ERBLint
         processed_source.ast.descendants(:erb)
       end
 
-      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&.children&.first == '#'
@@ -79,7 +69,7 @@ module ERBLint
 
         team = build_team
         team.inspect_file(source)
-        team.cops.each_with_object([]) do |cop, offenses|
+        team.cops.each do |cop|
           correction_offset = 0
           cop.offenses.reject(&:disabled?).each do |rubocop_offense|
             if rubocop_offense.corrected?
@@ -87,18 +77,12 @@ module ERBLint
               correction_offset += 1
             end
 
-            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,
-            )
+            offset = code_node.loc.begin_pos - alignment_column
+            offense_range = processed_source
+              .to_source_range(rubocop_offense.location)
+              .offset(offset)
 
-            bound_range = processed_source.to_source_range(
-              code_node.loc.start,
-              code_node.loc.stop
-            )
-
-            offenses << add_offense(rubocop_offense, offense_range, correction, offset, bound_range)
+            add_offense(rubocop_offense, offense_range, correction, offset, code_node.loc.range)
           end
         end
       end
@@ -173,16 +157,12 @@ module ERBLint
         configs.compact
       end
 
-      def add_offense(offense, offense_range, correction, offset, bound_range)
-        if offense.corrected?
-          klass = OffenseWithCorrection
-          options = { correction: correction, offset: offset, bound_range: bound_range }
-        else
-          klass = Offense
-          options = {}
+      def add_offense(rubocop_offense, offense_range, correction, offset, bound_range)
+        context = if rubocop_offense.corrected?
+          { rubocop_correction: correction, offset: offset, bound_range: bound_range }
         end
 
-        klass.new(self, offense_range, offense.message.strip, **options)
+        super(offense_range, rubocop_offense.message.strip, context)
       end
     end
   end

data/lib/erb_lint/linters/self_closing_tag.rb

@@ -11,25 +11,23 @@ module ERBLint
         link menuitem meta param source track wbr img
       )
 
-      def offenses(processed_source)
-        processed_source.ast.descendants(:tag).each_with_object([]) do |tag_node, offenses|
+      def run(processed_source)
+        processed_source.ast.descendants(:tag).each do |tag_node|
           tag = BetterHtml::Tree::Tag.from_node(tag_node)
           next unless SELF_CLOSING_TAGS.include?(tag.name)
 
           if tag.closing?
             start_solidus = tag_node.children.first
-            offenses << Offense.new(
-              self,
-              processed_source.to_source_range(start_solidus.loc.start, start_solidus.loc.stop),
+            add_offense(
+              start_solidus.loc,
               "Tag `#{tag.name}` is self-closing, it must not start with `</`.",
               ''
             )
           end
 
           next if tag.self_closing?
-          offenses << Offense.new(
-            self,
-            processed_source.to_source_range(tag_node.loc.stop, tag_node.loc.stop - 1),
+          add_offense(
+            tag_node.loc.end.offset(-1),
             "Tag `#{tag.name}` is self-closing, it must end with `/>`.",
             '/'
           )

data/lib/erb_lint/linters/space_around_erb_tag.rb

@@ -11,51 +11,45 @@ module ERBLint
       START_SPACES = /\A([[:space:]]*)/m
       END_SPACES = /([[:space:]]*)\z/m
 
-      def offenses(processed_source)
-        [].tap do |offenses|
-          processed_source.ast.descendants(:erb).each do |erb_node|
-            indicator, ltrim, code_node, rtrim = *erb_node
-            code = code_node.children.first
+      def run(processed_source)
+        processed_source.ast.descendants(:erb).each do |erb_node|
+          indicator, ltrim, code_node, rtrim = *erb_node
+          code = code_node.children.first
 
-            start_spaces = code.match(START_SPACES)&.captures&.first || ""
-            if start_spaces.size != 1 && !start_spaces.include?("\n")
-              offenses << Offense.new(
-                self,
-                processed_source.to_source_range(code_node.loc.start, code_node.loc.start + start_spaces.size - 1),
-                "Use 1 space after `<%#{indicator&.loc&.source}#{ltrim&.loc&.source}` "\
-                "instead of #{start_spaces.size} space#{'s' if start_spaces.size > 1}.",
-                ' '
-              )
-            elsif start_spaces.count("\n") > 1
-              lines = start_spaces.split("\n", -1)
-              offenses << Offense.new(
-                self,
-                processed_source.to_source_range(code_node.loc.start, code_node.loc.start + start_spaces.size - 1),
-                "Use 1 newline after `<%#{indicator&.loc&.source}#{ltrim&.loc&.source}` "\
-                "instead of #{start_spaces.count("\n")}.",
-                "#{lines.first}\n#{lines.last}"
-              )
-            end
+          start_spaces = code.match(START_SPACES)&.captures&.first || ""
+          if start_spaces.size != 1 && !start_spaces.include?("\n")
+            add_offense(
+              code_node.loc.resize(start_spaces.size),
+              "Use 1 space after `<%#{indicator&.loc&.source}#{ltrim&.loc&.source}` "\
+              "instead of #{start_spaces.size} space#{'s' if start_spaces.size > 1}.",
+              ' '
+            )
+          elsif start_spaces.count("\n") > 1
+            lines = start_spaces.split("\n", -1)
+            add_offense(
+              code_node.loc.resize(start_spaces.size),
+              "Use 1 newline after `<%#{indicator&.loc&.source}#{ltrim&.loc&.source}` "\
+              "instead of #{start_spaces.count("\n")}.",
+              "#{lines.first}\n#{lines.last}"
+            )
+          end
 
-            end_spaces = code.match(END_SPACES)&.captures&.first || ""
-            if end_spaces.size != 1 && !end_spaces.include?("\n")
-              offenses << Offense.new(
-                self,
-                processed_source.to_source_range(code_node.loc.stop - end_spaces.size + 1, code_node.loc.stop),
-                "Use 1 space before `#{rtrim&.loc&.source}%>` "\
-                "instead of #{end_spaces.size} space#{'s' if start_spaces.size > 1}.",
-                ' '
-              )
-            elsif end_spaces.count("\n") > 1
-              lines = end_spaces.split("\n", -1)
-              offenses << Offense.new(
-                self,
-                processed_source.to_source_range(code_node.loc.stop - end_spaces.size + 1, code_node.loc.stop),
-                "Use 1 newline before `#{rtrim&.loc&.source}%>` "\
-                "instead of #{end_spaces.count("\n")}.",
-                "#{lines.first}\n#{lines.last}"
-              )
-            end
+          end_spaces = code.match(END_SPACES)&.captures&.first || ""
+          if end_spaces.size != 1 && !end_spaces.include?("\n")
+            add_offense(
+              code_node.loc.end.adjust(begin_pos: -end_spaces.size),
+              "Use 1 space before `#{rtrim&.loc&.source}%>` "\
+              "instead of #{end_spaces.size} space#{'s' if start_spaces.size > 1}.",
+              ' '
+            )
+          elsif end_spaces.count("\n") > 1
+            lines = end_spaces.split("\n", -1)
+            add_offense(
+              code_node.loc.end.adjust(begin_pos: -end_spaces.size),
+              "Use 1 newline before `#{rtrim&.loc&.source}%>` "\
+              "instead of #{end_spaces.count("\n")}.",
+              "#{lines.first}\n#{lines.last}"
+            )
           end
         end
       end

data/lib/erb_lint/linters/space_in_html_tag.rb

@@ -6,35 +6,33 @@ module ERBLint
     class SpaceInHtmlTag < Linter
       include LinterRegistry
 
-      def offenses(processed_source)
-        offenses = []
+      def run(processed_source)
         processed_source.ast.descendants(:tag).each do |tag_node|
           start_solidus, name, attributes, end_solidus = *tag_node
 
-          next_loc = name&.loc&.start || attributes&.loc&.start ||
-            end_solidus&.loc&.start || tag_node.loc.stop
+          next_loc = name&.loc&.begin_pos || attributes&.loc&.begin_pos ||
+            end_solidus&.loc&.begin_pos || (tag_node.loc.end_pos - 1)
           if start_solidus
-            offenses << no_space(processed_source, tag_node.loc.start + 1, start_solidus.loc.start)
-            offenses << no_space(processed_source, start_solidus.loc.stop + 1, next_loc)
+            no_space(processed_source, (tag_node.loc.begin_pos + 1)...start_solidus.loc.begin_pos)
+            no_space(processed_source, start_solidus.loc.end_pos...next_loc)
           else
-            offenses << no_space(processed_source, tag_node.loc.start + 1, next_loc)
+            no_space(processed_source, (tag_node.loc.begin_pos + 1)...next_loc)
           end
 
           if attributes
-            offenses << single_space_or_newline(processed_source, name.loc.stop + 1, attributes.loc.start) if name
-            offenses.concat(process_attributes(processed_source, attributes) || [])
+            single_space_or_newline(processed_source, name.loc.end_pos...attributes.loc.begin_pos) if name
+            process_attributes(processed_source, attributes)
           end
 
-          previous_loc = attributes&.loc&.stop || name&.loc&.stop ||
-            start_solidus&.loc&.stop || tag_node.loc.start
+          previous_loc = attributes&.loc&.end_pos || name&.loc&.end_pos ||
+            start_solidus&.loc&.end_pos || (tag_node.loc.begin_pos + 1)
           if end_solidus
-            offenses << single_space(processed_source, previous_loc + 1, end_solidus.loc.start)
-            offenses << no_space(processed_source, end_solidus.loc.stop + 1, tag_node.loc.stop)
+            single_space(processed_source, previous_loc...end_solidus.loc.begin_pos)
+            no_space(processed_source, end_solidus.loc.end_pos...(tag_node.loc.end_pos - 1))
           else
-            offenses << no_space(processed_source, previous_loc + 1, tag_node.loc.stop)
+            no_space(processed_source, previous_loc...(tag_node.loc.end_pos - 1))
           end
         end
-        offenses.compact
       end
 
       def autocorrect(_processed_source, offense)
@@ -45,25 +43,22 @@ module ERBLint
 
       private
 
-      def no_space(processed_source, begin_pos, end_pos)
-        range = Range.new(begin_pos, end_pos - 1)
+      def no_space(processed_source, range)
         chars = processed_source.file_content[range]
         return if chars.empty?
 
-        Offense.new(
-          self,
-          processed_source.to_source_range(begin_pos, end_pos - 1),
+        add_offense(
+          processed_source.to_source_range(range),
           "Extra space detected where there should be no space.",
           ''
         )
       end
 
-      def single_space_or_newline(processed_source, begin_pos, end_pos)
-        single_space(processed_source, begin_pos, end_pos, accept_newline: true)
+      def single_space_or_newline(processed_source, range)
+        single_space(processed_source, range, accept_newline: true)
       end
 
-      def single_space(processed_source, begin_pos, end_pos, accept_newline: false)
-        range = Range.new(begin_pos, end_pos - 1)
+      def single_space(processed_source, range, accept_newline: false)
         chars = processed_source.file_content[range]
         return if chars == ' '
 
@@ -72,27 +67,24 @@ module ERBLint
         non_space = chars.match(/([^[[:space:]]])/m)
 
         if non_space && !non_space.captures.empty?
-          Offense.new(
-            self,
-            processed_source.to_source_range(begin_pos, end_pos - 1),
+          add_offense(
+            processed_source.to_source_range(range),
             "Non-whitespace character(s) detected: "\
               "#{non_space.captures.map(&:inspect).join(', ')}.",
             expected
           )
         elsif newlines && accept_newline
           if expected != chars
-            Offense.new(
-              self,
-              processed_source.to_source_range(begin_pos, end_pos - 1),
+            add_offense(
+              processed_source.to_source_range(range),
               "#{chars.empty? ? 'No' : 'Extra'} space detected where there should be "\
                 "a single space or a single line break.",
               expected
             )
           end
         else
-          Offense.new(
-            self,
-            processed_source.to_source_range(begin_pos, end_pos - 1),
+          add_offense(
+            processed_source.to_source_range(range),
             "#{chars.empty? ? 'No' : 'Extra'} space detected where there should be a single space.",
             expected
           )
@@ -100,19 +92,19 @@ module ERBLint
       end
 
       def process_attributes(processed_source, attributes)
-        offenses = []
         attributes.children.each_with_index do |attribute, index|
           name, equal, value = *attribute
-          offenses << no_space(processed_source, name.loc.stop + 1, equal.loc.start) if equal
-          offenses << no_space(processed_source, equal.loc.stop + 1, value.loc.start) if equal && value
+          no_space(processed_source, name.loc.end_pos...equal.loc.begin_pos) if equal
+          no_space(processed_source, equal.loc.end_pos...value.loc.begin_pos) if equal && value
 
           next if index >= attributes.children.size - 1
           next_attribute = attributes.children[index + 1]
 
-          offenses << single_space_or_newline(processed_source,
-            attribute.loc.stop + 1, next_attribute.loc.start)
+          single_space_or_newline(
+            processed_source,
+            attribute.loc.end_pos...next_attribute.loc.begin_pos
+          )
         end
-        offenses
       end
     end
   end

data/lib/erb_lint/linters/space_indentation.rb

@@ -13,16 +13,15 @@ module ERBLint
 
       START_SPACES = /\A([[:blank:]]*)/
 
-      def offenses(processed_source)
+      def run(processed_source)
         lines = processed_source.file_content.split("\n", -1)
         document_pos = 0
-        lines.each_with_object([]) do |line, offenses|
+        lines.each do |line|
           spaces = line.match(START_SPACES)&.captures&.first
 
           if spaces.include?("\t")
-            offenses << Offense.new(
-              self,
-              processed_source.to_source_range(document_pos, document_pos + spaces.length - 1),
+            add_offense(
+              processed_source.to_source_range(document_pos...(document_pos + spaces.length)),
               "Indent with spaces instead of tabs.",
               spaces.gsub("\t", ' ' * @config.tab_width)
             )

data/lib/erb_lint/linters/trailing_whitespace.rb

@@ -8,17 +8,16 @@ module ERBLint
 
       TRAILING_WHITESPACE = /([[:space:]]*)\Z/
 
-      def offenses(processed_source)
+      def run(processed_source)
         lines = processed_source.file_content.split("\n", -1)
         document_pos = 0
-        lines.each_with_object([]) do |line, offenses|
+        lines.each do |line|
           document_pos += line.length + 1
           whitespace = line.match(TRAILING_WHITESPACE)&.captures&.first
           next unless whitespace && !whitespace.empty?
 
-          offenses << Offense.new(
-            self,
-            processed_source.to_source_range(document_pos - whitespace.length - 1, document_pos - 2),
+          add_offense(
+            processed_source.to_source_range((document_pos - whitespace.length - 1)...(document_pos - 1)),
             "Extra whitespace detected at end of line."
           )
         end

data/lib/erb_lint/offense.rb

@@ -17,7 +17,7 @@ module ERBLint
 
     def inspect
       "#<#{self.class.name} linter=#{linter.class.name} "\
-        "source_range=#{source_range.begin_pos}..#{source_range.end_pos - 1} "\
+        "source_range=#{source_range.begin_pos}...#{source_range.end_pos} "\
         "message=#{message}>"
     end
 

data/lib/erb_lint/processed_source.rb

@@ -7,7 +7,7 @@ module ERBLint
     def initialize(filename, file_content)
       @filename = filename
       @file_content = file_content
-      @parser = BetterHtml::Parser.new(file_content, template_language: :html)
+      @parser = BetterHtml::Parser.new(source_buffer, template_language: :html)
     end
 
     def ast
@@ -22,8 +22,13 @@ module ERBLint
       end
     end
 
-    def to_source_range(begin_pos, end_pos)
-      Parser::Source::Range.new(source_buffer, begin_pos, end_pos + 1)
+    def to_source_range(range)
+      range = (range.begin_pos...range.end_pos) if range.is_a?(::Parser::Source::Range)
+      BetterHtml::Tokenizer::Location.new(
+        source_buffer,
+        range.begin,
+        range.exclude_end? ? range.end : range.end + 1
+      )
     end
   end
 end

data/lib/erb_lint/runner.rb

@@ -3,6 +3,8 @@
 module ERBLint
   # Runs all enabled linters against an html.erb file.
   class Runner
+    attr_reader :offenses
+
     def initialize(file_loader, config)
       @file_loader = file_loader
       @config = config || RunnerConfig.default
@@ -13,16 +15,21 @@ module ERBLint
       @linters = linter_classes.map do |linter_class|
         linter_class.new(@file_loader, @config.for_linter(linter_class))
       end
+      @offenses = []
     end
 
     def run(processed_source)
-      offenses = []
       @linters
         .reject { |linter| linter.excludes_file?(processed_source.filename) }
         .each do |linter|
-        offenses += linter.offenses(processed_source)
+        linter.run(processed_source)
+        @offenses.concat(linter.offenses)
       end
-      offenses
+    end
+
+    def clear_offenses
+      @offenses = []
+      @linters.each(&:clear_offenses)
     end
   end
 end

data/lib/erb_lint/utils/block_map.rb

@@ -26,7 +26,7 @@ module ERBLint
       private
 
       def erb_nodes
-        erb_ast.descendants(:erb).sort { |a, b| a.loc.start <=> b.loc.start }
+        erb_ast.descendants(:erb).sort { |a, b| a.loc.begin_pos <=> b.loc.begin_pos }
       end
 
       class Entry
@@ -72,14 +72,14 @@ module ERBLint
         def ordered(nodes)
           nodes
             .uniq(&:loc)
-            .sort { |a, b| a.loc.start <=> b.loc.start }
+            .sort { |a, b| a.loc.begin_pos <=> b.loc.begin_pos }
         end
       end
 
       def build_map
         erb_nodes.each do |erb_node|
           indicator_node, _, code_node, _ = *erb_node
-          length = code_node.loc.stop - code_node.loc.start
+          length = code_node.loc.size
           start = current_pos
           if indicator_node.nil?
             append("#{code_node.loc.source}\n")

data/lib/erb_lint/utils/offset_corrector.rb

@@ -40,15 +40,14 @@ module ERBLint
 
       def range_with_offset(range)
         @processed_source.to_source_range(
-          bound(@offset + range.begin_pos),
-          bound(@offset + range.end_pos - 1),
+          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
+          [pos, @bound_range.min].max,
+          @bound_range.max
         ].min
       end
     end

data/lib/erb_lint/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: erb_lint
 version: !ruby/object:Gem::Version
-  version: 0.0.21
+  version: 0.0.22
 platform: ruby
 authors:
 - Justin Chan
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-02-02 00:00:00.000000000 Z
+date: 2018-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: better_html
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.5
+        version: 1.0.6
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.5
+        version: 1.0.6
 - !ruby/object:Gem::Dependency
   name: html_tokenizer
   requirement: !ruby/object:Gem::Requirement