erb_lint 0.0.18 → 0.0.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0ae1dbd574b00046985466aacce7a126e9a61b34
-  data.tar.gz: 1649ae3b899e23ee9c02f5f40dfd6a9db02e2008
+  metadata.gz: d2a9562a665d609771d10b87e821c7d71a312882
+  data.tar.gz: 47b5284105cc9c12311ce4233b7306dc5c8b72e9
 SHA512:
-  metadata.gz: d6571d993f2acc94689f7711adb041dbca684b696f22548d85ed5af44a530143adf0acca04de2f19b46313223fbdeb8a3d539ac75827fd07d010c9280ef809d1
-  data.tar.gz: 1bd62fde864706db8442b6f03290ab71dcf4e94571aee526c425781469f5010f4d78ce8091cae3264f3a4d8927d5f4584f3d75c5770e056458f3f55decc4a69a
+  metadata.gz: a1b33b2d06509bfaa8f91e8f66458b80b13530964ec5976823a2dc75c3a98e0e133601d83e5a42b462960d743b4432df93c4d599944a71a2a893cfe9948f1565
+  data.tar.gz: 938c959af55a5260eee35f89810c4193edebdefbdc363910acddf0c70a3a19b2307366821ba58d54e98f3be419c9c91e2b7aab845e4980db97e549bcd81c21f0

data/lib/erb_lint.rb

@@ -6,7 +6,6 @@ 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'

data/lib/erb_lint/linters/allowed_script_type.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'better_html'
+require 'better_html/tree/tag'
+
+module ERBLint
+  module Linters
+    # Allow `<script>` tags in ERB that have specific `type` attributes.
+    # This only validates inline `<script>` tags, a separate rubocop cop
+    # may be used to enforce the same rule when `javascript_tag` is called.
+    class AllowedScriptType < Linter
+      include LinterRegistry
+
+      class ConfigSchema < LinterConfig
+        property :allowed_types, accepts: array_of?(String),
+          default: ['text/javascript']
+        property :allow_blank, accepts: [true, false], default: true, reader: :allow_blank?
+        property :disallow_inline_scripts, accepts: [true, false], default: false, reader: :disallow_inline_scripts?
+      end
+      self.config_schema = ConfigSchema
+
+      def offenses(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'
+
+            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
+
+            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
+          end
+        end
+      end
+
+      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"')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/erb_lint/linters/deprecated_classes.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'better_html'
 require 'better_html/parser'
 
 module ERBLint

data/lib/erb_lint/linters/erb_safety.rb

@@ -8,7 +8,6 @@ module ERBLint
     # Detect unsafe ruby interpolations into javascript.
     class ErbSafety < Linter
       include LinterRegistry
-      include BetterHtml::TestHelper::SafeErbTester
 
       class ConfigSchema < LinterConfig
         property :better_html_config, accepts: String
@@ -23,19 +22,38 @@ module ERBLint
 
       def offenses(processed_source)
         offenses = []
-        tester = Tester.new(processed_source.file_content, config: better_html_config)
-        tester.errors.each do |error|
-          offenses << Offense.new(
-            self,
-            processed_source.to_source_range(error.location.start, error.location.stop),
-            error.message
-          )
+
+        parser = BetterHtml::Parser.new(processed_source.file_content, template_language: :html)
+        testers_for(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),
+              error.message
+            )
+          end
         end
         offenses
       end
 
       private
 
+      def tester_classes
+        [
+          BetterHtml::TestHelper::SafeErb::NoStatements,
+          BetterHtml::TestHelper::SafeErb::AllowedScriptType,
+          BetterHtml::TestHelper::SafeErb::TagInterpolation,
+          BetterHtml::TestHelper::SafeErb::ScriptInterpolation,
+        ]
+      end
+
+      def testers_for(parser)
+        tester_classes.map do |tester_klass|
+          tester_klass.new(parser, config: better_html_config)
+        end
+      end
+
       def better_html_config
         @better_html_config ||= begin
           config_hash =

data/lib/erb_lint/linters/no_javascript_tag_helper.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'better_html/ast/node'
+require 'better_html/test_helper/ruby_node'
+require 'erb_lint/utils/block_map'
+require 'erb_lint/utils/ruby_to_erb'
+
+module ERBLint
+  module Linters
+    class NoJavascriptTagHelper < Linter
+      include LinterRegistry
+
+      class ConfigSchema < LinterConfig
+        property :correction_style, converts: :to_sym, accepts: [:cdata, :plain], default: :cdata
+      end
+      self.config_schema = ConfigSchema
+
+      def offenses(processed_source)
+        offenses = []
+
+        parser = processed_source.parser
+        parser.ast.descendants(:erb).each do |erb_node|
+          indicator_node, _, code_node, _ = *erb_node
+          indicator = indicator_node&.loc&.source
+          next if indicator == '#'
+          source = code_node.loc.source
+
+          next unless (ruby_node = BetterHtml::TestHelper::RubyNode.parse(source))
+          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),
+            "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)
+        lambda do |corrector|
+          correct_offense(processed_source, offense, corrector)
+        end
+      end
+
+      private
+
+      def correct_offense(processed_source, offense, corrector)
+        erb_node, send_node = *offense.context
+        block_map = Utils::BlockMap.new(processed_source)
+        nodes = block_map.find_connected_nodes(erb_node) || [erb_node]
+        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)
+
+        script_content = unless argument_nodes.first&.type?(:hash)
+          Utils::RubyToERB.ruby_to_erb(argument_nodes.first, '==')
+        end
+        arguments = if argument_nodes.last&.type?(:hash)
+          ' ' + Utils::RubyToERB.html_options_to_tag_attributes(argument_nodes.last)
+        end
+
+        return if end_node && script_content
+
+        if end_node
+          begin_content = "<script#{arguments}>"
+          begin_content += "\n//<![CDATA[\n" if @config.correction_style == :cdata
+          corrector.replace(begin_range, begin_content)
+          end_content = "</script>"
+          end_content = "\n//]]>\n" + end_content if @config.correction_style == :cdata
+          corrector.replace(end_range, end_content)
+        elsif script_content
+          script_content = "\n//<![CDATA[\n#{script_content}\n//]]>\n" if @config.correction_style == :cdata
+          corrector.replace(begin_range,
+            "<script#{arguments}>#{script_content}</script>")
+        end
+      rescue Utils::RubyToERB::Error, Utils::BlockMap::ParseError
+        nil
+      end
+    end
+  end
+end

data/lib/erb_lint/linters/parser_errors.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ERBLint
+  module Linters
+    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),
+            "#{error.message} (at #{error.loc.source})"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/erb_lint/linters/right_trim.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module ERBLint
+  module Linters
+    # In ERB, right trim can be either =%> or -%>
+    # this linter will force one or the other.
+    class RightTrim < Linter
+      include LinterRegistry
+
+      class ConfigSchema < LinterConfig
+        property :enforced_style, accepts: ['-', '='], default: '-'
+      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
+
+            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
+        end
+      end
+
+      def autocorrect(_processed_source, offense)
+        lambda do |corrector|
+          corrector.replace(offense.source_range, @config.enforced_style)
+        end
+      end
+    end
+  end
+end

data/lib/erb_lint/linters/rubocop.rb

@@ -3,6 +3,7 @@
 require 'better_html'
 require 'rubocop'
 require 'tempfile'
+require 'erb_lint/utils/offset_corrector'
 
 module ERBLint
   module Linters
@@ -12,7 +13,7 @@ module ERBLint
 
       class ConfigSchema < LinterConfig
         property :only, accepts: array_of?(String)
-        property :rubocop_config, accepts: Hash
+        property :rubocop_config, accepts: Hash, default: {}
       end
 
       self.config_schema = ConfigSchema
@@ -29,17 +30,16 @@ module ERBLint
       end
 
       def offenses(processed_source)
-        offenses = []
-        descendant_nodes(processed_source).each do |erb_node|
+        descendant_nodes(processed_source).each_with_object([]) do |erb_node, offenses|
           offenses.push(*inspect_content(processed_source, erb_node))
         end
-        offenses
       end
 
       def autocorrect(processed_source, offense)
-        return unless offense.correction
+        return unless offense.is_a?(OffenseWithCorrection)
+
         lambda do |corrector|
-          passthrough = OffsetCorrector.new(
+          passthrough = Utils::OffsetCorrector.new(
             processed_source,
             corrector,
             offense.offset,
@@ -77,12 +77,15 @@ module ERBLint
         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.select(&:corrected?).each_with_index do |rubocop_offense, index|
-            correction = cop.corrections[index] if rubocop_offense.corrected?
+        team.cops.each_with_object([]) do |cop, offenses|
+          correction_offset = 0
+          cop.offenses.reject(&:disabled?).each do |rubocop_offense|
+            if rubocop_offense.corrected?
+              correction = cop.corrections[correction_offset]
+              correction_offset += 1
+            end
 
             offset = code_node.loc.start - alignment_column
             offense_range = processed_source.to_source_range(
@@ -95,18 +98,9 @@ module ERBLint
               code_node.loc.stop
             )
 
-            offenses <<
-              OffenseWithCorrection.new(
-                self,
-                offense_range,
-                rubocop_offense.message.strip,
-                correction: correction,
-                offset: offset,
-                bound_range: bound_range,
-              )
+            offenses << add_offense(rubocop_offense, offense_range, correction, offset, bound_range)
           end
         end
-        offenses
       end
 
       def tempfile_from(filename, content)
@@ -149,7 +143,7 @@ module ERBLint
       end
 
       def config_from_hash(hash)
-        inherit_from = hash.delete('inherit_from')
+        inherit_from = hash&.delete('inherit_from')
         resolve_inheritance(hash, inherit_from)
 
         tempfile_from('.erblint-rubocop', hash.to_yaml) do |tempfile|
@@ -178,6 +172,18 @@ 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 = {}
+        end
+
+        klass.new(self, offense_range, offense.message.strip, **options)
+      end
     end
   end
 end

data/lib/erb_lint/linters/rubocop_text.rb

@@ -27,11 +27,10 @@ module ERBLint
         erb_nodes
       end
 
-      def team
+      def cop_classes
         selected_cops = RuboCop::Cop::Cop.all.select { |cop| cop.match?(@only_cops) }
-        cop_classes = RuboCop::Cop::Registry.new(selected_cops)
 
-        RuboCop::Cop::Team.new(cop_classes, @rubocop_config, extra_details: true, display_cop_names: true)
+        RuboCop::Cop::Registry.new(selected_cops)
       end
     end
   end

data/lib/erb_lint/linters/space_around_erb_tag.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module ERBLint
+  module Linters
+    # Enforce a single space after `<%` and before `%>` in the erb source.
+    # This linter ignores opening erb tags (`<%`) that are followed by a newline,
+    # and closing erb tags (`%>`) that are preceeded by a newline.
+    class SpaceAroundErbTag < Linter
+      include LinterRegistry
+
+      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
+
+            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}."
+              )
+            end
+
+            end_spaces = code.match(END_SPACES)&.captures&.first || ""
+            next unless 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}."
+            )
+          end
+        end
+      end
+
+      def autocorrect(_processed_source, offense)
+        lambda do |corrector|
+          corrector.replace(offense.source_range, ' ')
+        end
+      end
+    end
+  end
+end

data/lib/erb_lint/offense.rb

@@ -3,15 +3,16 @@
 module ERBLint
   # Defines common functionality available to all linters.
   class Offense
-    attr_reader :linter, :source_range, :message
+    attr_reader :linter, :source_range, :message, :context
 
-    def initialize(linter, source_range, message)
+    def initialize(linter, source_range, message, context = nil)
       unless source_range.is_a?(Parser::Source::Range)
         raise ArgumentError, "expected Parser::Source::Range for arg 2"
       end
       @linter = linter
       @source_range = source_range
       @message = message
+      @context = context
     end
 
     def inspect

data/lib/erb_lint/runner_config.rb

@@ -38,9 +38,12 @@ module ERBLint
       def default
         new(
           linters: {
-            FinalNewline: {
-              enabled: true,
-            },
+            FinalNewline: { enabled: true },
+            ParserErrors: { enabled: true },
+            RightTrim: { enabled: true },
+            SpaceAroundErbTag: { enabled: true },
+            NoJavascriptTagHelper: { enabled: true },
+            AllowedScriptType: { enabled: true },
           },
         )
       end

data/lib/erb_lint/utils/block_map.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+require 'better_html/ast/node'
+require 'better_html/test_helper/ruby_node'
+
+module ERBLint
+  module Utils
+    class BlockMap
+      attr_reader :connections
+
+      class ParseError < StandardError; end
+
+      def initialize(processed_source)
+        @processed_source = processed_source
+        @entries = []
+        @connections = []
+        @ruby_code = ""
+        build_map
+      end
+
+      def find_connected_nodes(other)
+        connection = @connections.find { |conn| conn.include?(other) }
+        connection&.nodes
+      end
+
+      private
+
+      def erb_nodes
+        erb_ast.descendants(:erb).sort { |a, b| a.loc.start <=> b.loc.start }
+      end
+
+      class Entry
+        attr_reader :node, :erb_range, :ruby_range
+
+        def initialize(node, ruby_range)
+          @node = node
+          @erb_range = node.loc.range
+          @ruby_range = ruby_range
+        end
+
+        def contains_ruby_range?(range)
+          range.begin >= @ruby_range.begin && range.end <= @ruby_range.end
+        end
+      end
+
+      class ConnectedErbNodes
+        attr_reader :type, :nodes
+
+        def initialize(type, nodes)
+          @type = type
+          @nodes = ordered(nodes)
+        end
+
+        def concat(other)
+          @nodes = ordered(@nodes.concat(other.nodes))
+        end
+
+        def include?(other)
+          @nodes.map(&:loc).include?(other.loc)
+        end
+
+        def inspect
+          "\#<#{self.class.name} type=#{type.inspect} nodes=#{nodes.inspect}>"
+        end
+
+        def &(other)
+          nodes.select { |node| other.include?(node) }
+        end
+
+        private
+
+        def ordered(nodes)
+          nodes
+            .uniq(&:loc)
+            .sort { |a, b| a.loc.start <=> b.loc.start }
+        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
+          start = current_pos
+          if indicator_node.nil?
+            append("#{code_node.loc.source}\n")
+          elsif block?(code_node.loc.source)
+            append("src= #{code_node.loc.source}\n")
+            start += 5
+          else
+            append("src=(#{code_node.loc.source});\n")
+            start += 5
+          end
+          ruby_range = Range.new(start, start + length)
+          @entries << Entry.new(erb_node, ruby_range)
+        end
+
+        ruby_node = BetterHtml::TestHelper::RubyNode.parse(@ruby_code)
+        raise ParseError unless ruby_node
+
+        ruby_node.descendants(:block, :if, :for).each do |node|
+          @connections << ConnectedErbNodes.new(
+            node.type,
+            extract_map_locations(node)
+              .map { |loc| find_entry(loc) }
+              .compact.map(&:node)
+          )
+        end
+
+        ruby_node.descendants(:kwbegin).each do |node|
+          @connections << ConnectedErbNodes.new(
+            :begin,
+            (extract_map_locations(node) + rescue_locations(node))
+              .map { |loc| find_entry(loc) }
+              .compact.map(&:node)
+          )
+        end
+
+        ruby_node.descendants(:case).each do |node|
+          @connections << ConnectedErbNodes.new(
+            node.type,
+            (extract_map_locations(node) + when_locations(node))
+              .map { |loc| find_entry(loc) }
+              .compact.map(&:node)
+          )
+        end
+
+        group_overlapping_connections
+      end
+
+      def block?(source)
+        # taken from: action_view/template/handlers/erb/erubi.rb
+        /\s*((\s+|\))do|\{)(\s*\|[^|]*\|)?\s*\Z/.match?(source)
+      end
+
+      def when_locations(node)
+        node.child_nodes
+          .select { |child| child.type?(:when) }
+          .map { |child| extract_map_locations(child) }
+          .flatten
+      end
+
+      def rescue_locations(node)
+        node.child_nodes
+          .select { |child| child.type?(:rescue) }
+          .map(&:child_nodes)
+          .flatten
+          .select { |child| child.type?(:resbody) }
+          .map { |child| extract_map_locations(child) }
+          .flatten
+      end
+
+      def extract_map_locations(node)
+        (
+          case node.loc
+          when Parser::Source::Map::Collection
+            [node.loc.begin, node.loc.end]
+          when Parser::Source::Map::Condition
+            [node.loc.keyword, node.loc.begin, node.loc.else, node.loc.end]
+          when Parser::Source::Map::Constant
+            [node.loc.double_colon, node.loc.name, node.loc.operator]
+          when Parser::Source::Map::Definition
+            [node.loc.keyword, node.loc.operator, node.loc.name, node.loc.end]
+          when Parser::Source::Map::For
+            [node.loc.keyword, node.loc.in, node.loc.begin, node.loc.end]
+          when Parser::Source::Map::Heredoc
+            [node.loc.heredoc_body, node.loc.heredoc_end]
+          when Parser::Source::Map::Keyword
+            [node.loc.keyword, node.loc.begin, node.loc.end]
+          when Parser::Source::Map::ObjcKwarg
+            [node.loc.keyword, node.loc.operator, node.loc.argument]
+          when Parser::Source::Map::RescueBody
+            [node.loc.keyword, node.loc.assoc, node.loc.begin]
+          when Parser::Source::Map::Send
+            [node.loc.dot, node.loc.selector, node.loc.operator, node.loc.begin, node.loc.end]
+          when Parser::Source::Map::Ternary
+            [node.loc.question, node.loc.colon]
+          when Parser::Source::Map::Variable
+            [node.loc.name, node.loc.operator]
+          end + [node.loc.expression]
+        ).compact
+      end
+
+      def current_pos
+        @ruby_code.size
+      end
+
+      def append(code)
+        @ruby_code += code
+      end
+
+      def parser
+        @processed_source.parser
+      end
+
+      def find_entry(range)
+        return unless range
+        @entries.find do |entry|
+          entry.contains_ruby_range?(Range.new(range.begin_pos, range.end_pos))
+        end
+      end
+
+      def group_overlapping_connections
+        loop do
+          first, second = find_overlapping_pair
+          break unless first && second
+
+          @connections.delete(second)
+          first.concat(second)
+        end
+      end
+
+      def find_overlapping_pair
+        @connections.each do |first|
+          @connections.each do |second|
+            next if first == second
+            return [first, second] if (first & second).any?
+          end
+        end
+        nil
+      end
+
+      def erb_ast
+        parser.ast
+      end
+    end
+  end
+end

data/lib/erb_lint/utils/offset_corrector.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module ERBLint
+  module Utils
+    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
+end

data/lib/erb_lint/utils/ruby_to_erb.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module ERBLint
+  module Utils
+    class RubyToERB
+      class Error < StandardError; end
+
+      class << self
+        def html_options_to_tag_attributes(hash_node)
+          hash_node.children.map do |pair_node|
+            key_node, value_node = *pair_node
+            key = ruby_to_erb(key_node, '=') { |s| s.tr('_', '-') }
+            value = ruby_to_erb(value_node, '=') { |s| escape_quote(s) }
+            [key, "\"#{value}\""].join('=')
+          end.join(' ')
+        end
+
+        def ruby_to_erb(node, indicator = nil, &block)
+          return node if node.nil? || node.is_a?(String)
+          case node.type
+          when :str, :sym
+            s = node.children.first.to_s
+            s = yield s if block_given?
+            s
+          when :true, :false
+            node.type.to_s
+          when :nil
+            ""
+          when :dstr
+            node.children.map do |child|
+              case child.type
+              when :str
+                ruby_to_erb(child, indicator, &block)
+              when :begin
+                ruby_to_erb(child.children.first, indicator, &block)
+              else
+                raise Error, "unexpected #{child.type} in :dstr node"
+              end
+            end.join
+          else
+            "<%#{indicator} #{node.loc.expression.source} %>"
+          end
+        end
+
+        def escape_quote(str)
+          str.gsub('"', '&quot;')
+        end
+      end
+    end
+  end
+end

data/lib/erb_lint/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: erb_lint
 version: !ruby/object:Gem::Version
-  version: 0.0.18
+  version: 0.0.19
 platform: ruby
 authors:
 - Justin Chan
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-01-22 00:00:00.000000000 Z
+date: 2018-01-26 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.0
+        version: 1.0.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: 1.0.4
 - !ruby/object:Gem::Dependency
   name: html_tokenizer
   requirement: !ruby/object:Gem::Requirement
@@ -138,17 +138,24 @@ files:
 - lib/erb_lint/linter.rb
 - lib/erb_lint/linter_config.rb
 - lib/erb_lint/linter_registry.rb
+- lib/erb_lint/linters/allowed_script_type.rb
 - lib/erb_lint/linters/deprecated_classes.rb
 - lib/erb_lint/linters/erb_safety.rb
 - lib/erb_lint/linters/final_newline.rb
 - lib/erb_lint/linters/hard_coded_string.rb
+- lib/erb_lint/linters/no_javascript_tag_helper.rb
+- lib/erb_lint/linters/parser_errors.rb
+- lib/erb_lint/linters/right_trim.rb
 - lib/erb_lint/linters/rubocop.rb
 - lib/erb_lint/linters/rubocop_text.rb
+- lib/erb_lint/linters/space_around_erb_tag.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/utils/block_map.rb
+- lib/erb_lint/utils/offset_corrector.rb
+- lib/erb_lint/utils/ruby_to_erb.rb
 - lib/erb_lint/version.rb
 homepage: https://github.com/justinthec/erb-lint
 licenses:

data/lib/erb_lint/offset_corrector.rb

@@ -1,54 +0,0 @@
-# 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