erb_lint 0.0.19 → 0.0.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d2a9562a665d609771d10b87e821c7d71a312882
-  data.tar.gz: 47b5284105cc9c12311ce4233b7306dc5c8b72e9
+  metadata.gz: ab337195cd313e04726f3c3ca31cc6fd77e661ce
+  data.tar.gz: 52de035725a4a39e533552a056f17e2f6d87e980
 SHA512:
-  metadata.gz: a1b33b2d06509bfaa8f91e8f66458b80b13530964ec5976823a2dc75c3a98e0e133601d83e5a42b462960d743b4432df93c4d599944a71a2a893cfe9948f1565
-  data.tar.gz: 938c959af55a5260eee35f89810c4193edebdefbdc363910acddf0c70a3a19b2307366821ba58d54e98f3be419c9c91e2b7aab845e4980db97e549bcd81c21f0
+  metadata.gz: 35dc5da94ef03e07d04a933ac5ded2951fde3437c20410d333e28b5c0fde51a6fe7df2b743f80cc0e13840c73b18b2309fdcd3a15c8ae9ecb0de30bcaad5270d
+  data.tar.gz: f1a74b863008b9ed36f56d7ecbf12533b9ee8b3bb89aca0da8c118306013ea0e54c9d1ea84def71b49b912d41c3347163fa284029cab98c36a3ec6132ccc35c9

data/lib/erb_lint/cli.rb

@@ -35,11 +35,12 @@ module ERBLint
       load_options(args)
       @files = args.dup
 
+      load_config
+
       if lint_files.empty?
         success!("no files given...\n#{option_parser}")
       end
 
-      load_config
       ensure_files_exist(lint_files)
 
       if enabled_linter_classes.empty?
@@ -50,8 +51,7 @@ module ERBLint
         "#{enabled_linter_classes.size} #{'autocorrectable ' if autocorrect?}linters..."
       puts
 
-      runner_config = @config.merge(runner_config_override)
-      runner = ERBLint::Runner.new(file_loader, runner_config)
+      runner = ERBLint::Runner.new(file_loader, @config)
       lint_files.each do |filename|
         begin
           run_with_corrections(runner, filename)
@@ -142,6 +142,7 @@ module ERBLint
         warn "#{config_filename} not found: using default config".yellow
         @config = RunnerConfig.default
       end
+      @config.merge!(runner_config_override)
     rescue Psych::SyntaxError => e
       failure!("error parsing config: #{e.message}")
     end
@@ -157,9 +158,19 @@ module ERBLint
     def lint_files
       if @options[:lint_all]
         pattern = File.expand_path(DEFAULT_LINT_ALL_GLOB, Dir.pwd)
-        Dir[pattern]
+        Dir[pattern].select { |filename| !excluded?(filename) }
       else
-        @files.map { |f| f.include?('*') ? Dir[f] : f }.flatten.map { |f| File.expand_path(f, Dir.pwd) }
+        @files
+          .map { |f| f.include?('*') ? Dir[f] : f }
+          .flatten
+          .map { |f| File.expand_path(f, Dir.pwd) }
+          .select { |filename| !excluded?(filename) }
+      end
+    end
+
+    def excluded?(filename)
+      @config.global_exclude.any? do |path|
+        File.fnmatch?(path, filename)
       end
     end
 

data/lib/erb_lint/linters/closing_erb_tag_indent.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module ERBLint
+  module Linters
+    # When `<%` isn't followed by a newline, ensure `%>` isn't preceeded by a newline.
+    # When `%>` is preceeded by a newline, indent it at the same level as the corresponding `<%`.
+    class ClosingErbTagIndent < Linter
+      include LinterRegistry
+
+      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|
+          _, _, code_node, = *erb_node
+          code = code_node.children.first
+
+          start_spaces = code.match(START_SPACES)&.captures&.first || ""
+          end_spaces = code.match(END_SPACES)&.captures&.first || ""
+
+          start_with_newline = start_spaces.include?("\n")
+          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),
+              "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),
+              "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),
+                "Indent `%>` on column #{erb_node.loc.column} to match start of tag.",
+                ' ' * erb_node.loc.column
+              )
+            end
+          end
+        end
+      end
+
+      def autocorrect(_processed_source, offense)
+        lambda do |corrector|
+          corrector.replace(offense.source_range, offense.context)
+        end
+      end
+    end
+  end
+end

data/lib/erb_lint/linters/extra_newline.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ERBLint
+  module Linters
+    # Detects multiple blank lines
+    class ExtraNewline < Linter
+      include LinterRegistry
+
+      EXTRA_NEWLINES = /(\n{3,})/m
+
+      def offenses(processed_source)
+        matches = processed_source.file_content.match(EXTRA_NEWLINES)
+        return [] unless matches
+
+        offenses = []
+        matches.captures.each_index do |index|
+          offenses << Offense.new(
+            self,
+            processed_source.to_source_range(
+              matches.begin(index) + 2,
+              matches.end(index) - 1
+            ),
+            "Extra blank line detected."
+          )
+        end
+        offenses
+      end
+
+      def autocorrect(_processed_source, offense)
+        lambda do |corrector|
+          corrector.replace(offense.source_range, '')
+        end
+      end
+    end
+  end
+end

data/lib/erb_lint/linters/final_newline.rb

@@ -23,19 +23,30 @@ module ERBLint
         return offenses if file_content.empty?
 
         match = file_content.match(/(\n+)\z/)
-        ends_with_newline = match.present?
+        final_newline = match&.captures&.first || ""
 
-        if @new_lines_should_be_present && !ends_with_newline
-          offenses << Offense.new(
-            self,
-            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
+        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),
+              '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),
+              '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),
-            "Remove #{match[0].size} trailing newline at the end of the file."
+            "Remove #{final_newline.size} trailing newline at the end of the file.",
+            :remove
           )
         end
         offenses
@@ -43,7 +54,7 @@ module ERBLint
 
       def autocorrect(_processed_source, offense)
         lambda do |corrector|
-          if @new_lines_should_be_present
+          if offense.context == :insert
             corrector.insert_after(offense.source_range, "\n")
           else
             corrector.remove_trailing(offense.source_range, offense.source_range.size)

data/lib/erb_lint/linters/rubocop.rb

@@ -67,14 +67,14 @@ module ERBLint
 
       def inspect_content(processed_source, erb_node)
         indicator, _, code_node, = *erb_node
-        return if indicator == '#'
+        return if indicator&.children&.first == '#'
 
         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)
+        source = rubocop_processed_source(aligned_source, processed_source.filename)
         return unless source.valid_syntax?
 
         team = build_team
@@ -112,11 +112,11 @@ module ERBLint
         end
       end
 
-      def rubocop_processed_source(content)
+      def rubocop_processed_source(content, filename)
         RuboCop::ProcessedSource.new(
           content,
           @rubocop_config.target_ruby_version,
-          '(erb)'
+          filename
         )
       end
 

data/lib/erb_lint/linters/self_closing_tag.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module ERBLint
+  module Linters
+    # Warns when a tag is not self-closed properly.
+    class SelfClosingTag < Linter
+      include LinterRegistry
+
+      SELF_CLOSING_TAGS = %w(
+        area base br col command embed hr input keygen
+        link menuitem meta param source track wbr img
+      )
+
+      def offenses(processed_source)
+        processed_source.ast.descendants(:tag).each_with_object([]) do |tag_node, offenses|
+          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),
+              "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),
+            "Tag `#{tag.name}` is self-closing, it must end with `/>`.",
+            '/'
+          )
+        end
+      end
+
+      def autocorrect(_processed_source, offense)
+        lambda do |corrector|
+          corrector.replace(offense.source_range, offense.context)
+        end
+      end
+    end
+  end
+end

data/lib/erb_lint/linters/space_around_erb_tag.rb

@@ -23,25 +23,46 @@ module ERBLint
                 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}."
+                "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
 
             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}."
-            )
+            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
         end
       end
 
       def autocorrect(_processed_source, offense)
         lambda do |corrector|
-          corrector.replace(offense.source_range, ' ')
+          corrector.replace(offense.source_range, offense.context)
         end
       end
     end

data/lib/erb_lint/linters/space_in_html_tag.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module ERBLint
+  module Linters
+    # Detects extra or missing whitespace in html tags.
+    class SpaceInHtmlTag < Linter
+      include LinterRegistry
+
+      def offenses(processed_source)
+        offenses = []
+        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
+          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)
+          else
+            offenses << no_space(processed_source, tag_node.loc.start + 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) || [])
+          end
+
+          previous_loc = attributes&.loc&.stop || name&.loc&.stop ||
+            start_solidus&.loc&.stop || tag_node.loc.start
+          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)
+          else
+            offenses << no_space(processed_source, previous_loc + 1, tag_node.loc.stop)
+          end
+        end
+        offenses.compact
+      end
+
+      def autocorrect(_processed_source, offense)
+        lambda do |corrector|
+          corrector.replace(offense.source_range, offense.context)
+        end
+      end
+
+      private
+
+      def no_space(processed_source, begin_pos, end_pos)
+        range = Range.new(begin_pos, end_pos - 1)
+        chars = processed_source.file_content[range]
+        return if chars.empty?
+
+        Offense.new(
+          self,
+          processed_source.to_source_range(begin_pos, end_pos - 1),
+          "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)
+      end
+
+      def single_space(processed_source, begin_pos, end_pos, accept_newline: false)
+        range = Range.new(begin_pos, end_pos - 1)
+        chars = processed_source.file_content[range]
+        return if chars == ' '
+
+        newlines = chars.include?("\n")
+        expected = newlines && accept_newline ? "\n#{chars.split("\n", -1).last}" : ' '
+        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),
+            "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),
+              "#{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),
+            "#{chars.empty? ? 'No' : 'Extra'} space detected where there should be a single space.",
+            expected
+          )
+        end
+      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
+
+          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)
+        end
+        offenses
+      end
+    end
+  end
+end

data/lib/erb_lint/linters/space_indentation.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ERBLint
+  module Linters
+    # Detects indentation with tabs and autocorrect them to spaces
+    class SpaceIndentation < Linter
+      include LinterRegistry
+
+      class ConfigSchema < LinterConfig
+        property :tab_width, converts: :to_i, accepts: Integer, default: 2
+      end
+      self.config_schema = ConfigSchema
+
+      START_SPACES = /\A([[:blank:]]*)/
+
+      def offenses(processed_source)
+        lines = processed_source.file_content.split("\n", -1)
+        document_pos = 0
+        lines.each_with_object([]) do |line, offenses|
+          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),
+              "Indent with spaces instead of tabs.",
+              spaces.gsub("\t", ' ' * @config.tab_width)
+            )
+          end
+
+          document_pos += line.length + 1
+        end
+      end
+
+      def autocorrect(_processed_source, offense)
+        lambda do |corrector|
+          corrector.replace(offense.source_range, offense.context)
+        end
+      end
+    end
+  end
+end

data/lib/erb_lint/linters/trailing_whitespace.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ERBLint
+  module Linters
+    # Detects trailing whitespace at the end of a line
+    class TrailingWhitespace < Linter
+      include LinterRegistry
+
+      TRAILING_WHITESPACE = /([[:space:]]*)\Z/
+
+      def offenses(processed_source)
+        lines = processed_source.file_content.split("\n", -1)
+        document_pos = 0
+        lines.each_with_object([]) do |line, offenses|
+          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),
+            "Extra whitespace detected at end of line."
+          )
+        end
+      end
+
+      def autocorrect(_processed_source, offense)
+        lambda do |corrector|
+          corrector.replace(offense.source_range, '')
+        end
+      end
+    end
+  end
+end

data/lib/erb_lint/runner_config.rb

@@ -22,7 +22,11 @@ module ERBLint
       end
       linter_klass = LinterRegistry.find_by_name(klass_name)
       raise Error, "#{klass_name}: linter not found (is it loaded?)" unless linter_klass
-      linter_klass.config_schema.new(linters_config[klass_name] || {})
+      linter_klass.config_schema.new(config_hash_for_linter(klass_name))
+    end
+
+    def global_exclude
+      @config['exclude'] || []
     end
 
     def merge(other_config)
@@ -38,12 +42,18 @@ module ERBLint
       def default
         new(
           linters: {
+            AllowedScriptType: { enabled: true },
+            ClosingErbTagIndent: { enabled: true },
+            ExtraNewline: { enabled: true },
             FinalNewline: { enabled: true },
+            NoJavascriptTagHelper: { enabled: true },
             ParserErrors: { enabled: true },
             RightTrim: { enabled: true },
+            SelfClosingTag: { enabled: true },
             SpaceAroundErbTag: { enabled: true },
-            NoJavascriptTagHelper: { enabled: true },
-            AllowedScriptType: { enabled: true },
+            SpaceIndentation: { enabled: true },
+            SpaceInHtmlTag: { enabled: true },
+            TrailingWhitespace: { enabled: true },
           },
         )
       end
@@ -54,5 +64,12 @@ module ERBLint
     def linters_config
       @config['linters'] || {}
     end
+
+    def config_hash_for_linter(klass_name)
+      config_hash = linters_config[klass_name] || {}
+      config_hash['exclude'] ||= []
+      config_hash['exclude'].concat(global_exclude) if config_hash['exclude'].is_a?(Array)
+      config_hash
+    end
   end
 end

data/lib/erb_lint/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: erb_lint
 version: !ruby/object:Gem::Version
-  version: 0.0.19
+  version: 0.0.20
 platform: ruby
 authors:
 - Justin Chan
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-01-26 00:00:00.000000000 Z
+date: 2018-01-29 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.4
+        version: 1.0.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.4
+        version: 1.0.5
 - !ruby/object:Gem::Dependency
   name: html_tokenizer
   requirement: !ruby/object:Gem::Requirement
@@ -139,8 +139,10 @@ files:
 - lib/erb_lint/linter_config.rb
 - lib/erb_lint/linter_registry.rb
 - lib/erb_lint/linters/allowed_script_type.rb
+- lib/erb_lint/linters/closing_erb_tag_indent.rb
 - lib/erb_lint/linters/deprecated_classes.rb
 - lib/erb_lint/linters/erb_safety.rb
+- lib/erb_lint/linters/extra_newline.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
@@ -148,7 +150,11 @@ files:
 - lib/erb_lint/linters/right_trim.rb
 - lib/erb_lint/linters/rubocop.rb
 - lib/erb_lint/linters/rubocop_text.rb
+- lib/erb_lint/linters/self_closing_tag.rb
 - lib/erb_lint/linters/space_around_erb_tag.rb
+- lib/erb_lint/linters/space_in_html_tag.rb
+- lib/erb_lint/linters/space_indentation.rb
+- lib/erb_lint/linters/trailing_whitespace.rb
 - lib/erb_lint/offense.rb
 - lib/erb_lint/processed_source.rb
 - lib/erb_lint/runner.rb