slim_lint_standard 0.0.0

data/lib/slim_lint/filters/multi_flattener.rb

@@ -0,0 +1,32 @@
+module SlimLint
+  module Filters
+    # Flattens nested multi expressions while respecting source locatoins.
+    #
+    # @api public
+    class MultiFlattener < Filter
+      def on_slim_embedded(*args)
+        @self
+      end
+
+      def on_multi(*exps)
+        # If the multi contains a single element, just return the element
+        return compile(exps.first) if exps.size == 1
+
+        result = @self
+        result.clear
+        result.concat(@key)
+
+        exps.each do |exp|
+          exp = compile(exp)
+          if exp.first == :multi
+            result.concat(exp[1..])
+          else
+            result << exp
+          end
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/slim_lint/filters/splat_processor.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module SlimLint
+  module Filters
+    # A dumbed-down version of {Slim::Splat::Filter} which doesn't introduced
+    # temporary variables or other cruft.
+    class SplatProcessor < Filter
+      # Handle slim splat expressions `[:slim, :splat, code]`
+      #
+      # @param code [String]
+      # @return [Array]
+      def on_slim_splat(code)
+        return code if code[0] == :multi
+        @self.delete_at(1)
+        @self.first.value = :code
+        @self
+      end
+    end
+  end
+end

data/lib/slim_lint/filters/static_merger.rb

@@ -0,0 +1,47 @@
+module SlimLint
+  module Filters
+    # Merges several statics into a single static while respecting source
+    # location data.  Example:
+    #
+    #   [:multi,
+    #     [:static, "Hello "],
+    #     [:static, "World!"]]
+    #
+    # Compiles to:
+    #
+    #   [:static, "Hello World!"]
+    #
+    # @api public
+    class StaticMerger < Filter
+      def on_slim_embedded(*exps)
+        @self
+      end
+
+      def on_multi(*exps)
+        result = @self
+        result.clear
+        result.concat(@key)
+
+        static = nil
+        exps.each do |exp|
+          if exp.first == :static
+            if static
+              static.finish = exp.finish if later_pos?(static.finish, exp.finish)
+              static.last.finish = exp.finish if later_pos?(static.last.finish, exp.finish)
+              static.last.value << exp.last.value
+            else
+              static = exp
+              static[1] = exp.last.dup
+              result << static
+            end
+          else
+            result << compile(exp)
+            static = nil unless exp.first == :newline
+          end
+        end
+
+        result.size == 2 ? result[1] : result
+      end
+    end
+  end
+end

data/lib/slim_lint/lint.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module SlimLint
+  # Contains information about a problem or issue with a Slim document.
+  class Lint
+    # @return [String] file path to which the lint applies
+    attr_reader :filename
+
+    # @return [SourceLocation] location in the file the lint corresponds to
+    attr_reader :location
+
+    # @return [SlimLint::Linter] linter that reported the lint
+    attr_reader :linter
+
+    # @return [String] sublinter that reported the lint
+    attr_reader :sublinter
+
+    # @return [String] error/warning message to display to user
+    attr_reader :message
+
+    # @return [Symbol] whether this lint is a warning or an error
+    attr_reader :severity
+
+    # Creates a new lint.
+    #
+    # @param linter [SlimLint::Linter]
+    # @param filename [String]
+    # @param location [SourceLocation]
+    # @param message [String]
+    # @param severity [Symbol]
+    def initialize(linter, filename, location, message, severity = :warning)
+      @linter, @sublinter = Array(linter)
+      @filename = filename
+      @location = location
+      @message = message
+      @severity = severity
+    end
+
+    def line
+      location.line
+    end
+
+    def column
+      location.column
+    end
+
+    def last_line
+      location.last_line
+    end
+
+    def last_column
+      location.last_column
+    end
+
+    def cop
+      @sublinter || @linter.name if @linter
+    end
+
+    def name
+      [@linter.name, @sublinter].compact.join("/") if @linter
+    end
+
+    # Return whether this lint has a severity of error.
+    #
+    # @return [Boolean]
+    def error?
+      @severity == :error
+    end
+  end
+end

data/lib/slim_lint/linter/avoid_multiline_expressions.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module SlimLint
+  # Searches for multi-line control statements, dynamic output statements,
+  # attribute values, and splats.
+  class Linter::AvoidMultilineExpressions < Linter
+    include LinterRegistry
+
+    on [:slim, :control] do |sexp|
+      _, _, code = sexp
+      next unless code.size > 2
+
+      msg = "Avoid control statements that span multiple lines."
+      report_lint(sexp, msg)
+    end
+
+    on [:slim, :output] do |sexp|
+      _, _, _, code = sexp
+      next unless code.size > 2
+
+      msg = "Avoid dynamic output statements that span multiple lines."
+      report_lint(sexp, msg)
+    end
+
+    on [:slim, :attrvalue] do |sexp|
+      _, _, _, code = sexp
+      next unless code.size > 2
+
+      msg = "Avoid attribute values that span multiple lines."
+      report_lint(sexp, msg)
+    end
+
+    on [:slim, :splat] do |sexp|
+      _, _, code = sexp
+      next unless code.size > 2
+
+      msg = "Avoid attribute values that span multiple lines."
+      report_lint(sexp, msg)
+    end
+  end
+end

data/lib/slim_lint/linter/comment_control_statement.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module SlimLint
+  # Searches for control statements with only comments.
+  class Linter::CommentControlStatement < Linter
+    include LinterRegistry
+
+    RUBOCOP_CONTROL_COMMENT_RE = /^\s*(rubocop|standard):\w+/
+    TEMPLATE_DEPENDENCY_CONTROL_COMMENT_RE = /^\s*Template Dependency:/
+
+    on [:slim, :control] do |sexp|
+      _, _, code = sexp
+      next unless code.last[1][/\A\s*#/]
+
+      comment = code.last[1][/\A\s*#(.*\z)/, 1]
+
+      next if RUBOCOP_CONTROL_COMMENT_RE.match?(comment)
+      next if TEMPLATE_DEPENDENCY_CONTROL_COMMENT_RE.match?(comment)
+
+      msg =
+        "Slim code comments (`/#{comment}`) are preferred over " \
+        "control statement comments (`-##{comment}`)"
+      report_lint(sexp, msg)
+    end
+  end
+end

data/lib/slim_lint/linter/consecutive_control_statements.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module SlimLint
+  # Searches for more than an allowed number of consecutive control code
+  # statements that could be condensed into a :ruby filter.
+  class Linter::ConsecutiveControlStatements < Linter
+    include LinterRegistry
+
+    on [:multi] do |sexp|
+      max = config["max_consecutive"] + 1
+      Utils.for_consecutive_items(sexp, method(:flat_control_statement?), max) do |group|
+        report_lint(
+          group.first,
+          "#{group.count} consecutive control statements can be " \
+          "merged into a single `ruby:` filter"
+        )
+      end
+    end
+
+    private
+
+    def flat_control_statement?(sexp)
+      sexp.match?([:slim, :control]) && sexp[3] == [:multi]
+    end
+  end
+end

data/lib/slim_lint/linter/control_statement_spacing.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module SlimLint
+  # Checks for missing or superfluous spacing before and after control statements.
+  class Linter::ControlStatementSpacing < Linter
+    include LinterRegistry
+
+    on [:slim, :control] do |sexp|
+      expr = sexp.last[0]
+      expr_line, expr_col = sexp.start
+      line = document.source_lines[expr_line - 1][(expr_col - 1)..]
+      after_pattern, after_action = after_config
+
+      unless line.match?(after_pattern)
+        report_lint(expr, "Please #{after_action} the dash")
+      end
+    end
+
+    def after_config
+      @after_config ||= case config["space_after"]
+      when "never", false, nil
+        [/^ *-#?[^# ]/, "remove spaces after"]
+      when "always", "single", true
+        [/^ *-#? [^ ]/, "use one space after"]
+      when "ignore", "any"
+        [//, ""]
+      else
+        raise ArgumentError, "Unknown value for `space_after`; please use 'never' or 'always'"
+      end
+    end
+  end
+end

data/lib/slim_lint/linter/dynamic_output_spacing.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module SlimLint
+  # Checks for missing or superfluous spacing before and after dynamic tag output indicators.
+  class Linter::DynamicOutputSpacing < Linter
+    include LinterRegistry
+
+    PATTERN = "==?['<>]*"
+
+    on [:html, :tag, anything, [], capture(:expr, [:slim, :output, anything, anything])] do |sexp|
+      # Fetch original Slim code that contains an element with a control statement.
+      expr_line, expr_col = captures[:expr].start
+      line = document.source_lines[expr_line - 1][(expr_col - 1)..]
+
+      before_pattern, _ = before_config
+      after_pattern, _ = after_config
+
+      report(captures[:expr], line.match?(before_pattern), line.match?(after_pattern))
+
+      # Visit any children of the HTML tag, but don't _revisit_ this Slim output.
+      traverse_children(captures[:expr].last)
+      :stop
+    end
+
+    on [:slim, :output] do |sexp|
+      expr_line, expr_col = sexp.start
+      line = document.source_lines[expr_line - 1][(expr_col - 1)..]
+      after_pattern, _ = after_config
+
+      report(sexp, true, line.match?(after_pattern))
+    end
+
+    def report(expr, *results)
+      _, before_action = before_config
+      _, after_action = after_config
+
+      case results
+      when [false, true]
+        report_lint(expr, "Please #{before_action} the equals sign")
+      when [true, false]
+        report_lint(expr, "Please #{after_action} the equals sign")
+      when [false, false]
+        if before_action[0] == after_action[0]
+          report_lint(expr, "Please #{before_action} and after the equals sign")
+        else
+          report_lint(expr, "Please #{before_action} and #{after_action} the equals sign")
+        end
+      end
+    end
+
+    def before_config
+      @before_config ||= case config["space_before"]
+      when "never", false, nil
+        [/^#{PATTERN}/, "remove spaces before"]
+      when "always", "single", true
+        [/^ #{PATTERN}/, "use one space before"]
+      when "ignore", "any"
+        [//, ""]
+      else
+        raise ArgumentError, "Unknown value for `space_before`; please use 'never', 'always', or 'ignore'"
+      end
+    end
+
+    def after_config
+      @after_config ||= case config["space_after"]
+      when "never", false, nil
+        [/^ *#{PATTERN}[^ ]/, "remove spaces after"]
+      when "always", "single", true
+        [/^ *#{PATTERN} [^ ]/, "use one space after"]
+      when "ignore", "any"
+        [//, ""]
+      else
+        raise ArgumentError, "Unknown value for `space_after`; please use 'never', 'always', or 'ignore'"
+      end
+    end
+  end
+end

data/lib/slim_lint/linter/embedded_engines.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module SlimLint
+  # Checks for forbidden embedded engines.
+  class Linter::EmbeddedEngines < Linter
+    include LinterRegistry
+
+    MESSAGE = "Forbidden embedded engine `%s` found"
+
+    on [:slim, :embedded] do |sexp|
+      _, _, engine, _ = sexp
+
+      forbidden_engines = config["forbidden_engines"]
+      next unless forbidden_engines.include?(engine)
+      report_lint(sexp, MESSAGE % engine)
+    end
+  end
+end

data/lib/slim_lint/linter/empty_control_statement.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SlimLint
+  # Searches for control statements with no code.
+  class Linter::EmptyControlStatement < Linter
+    include LinterRegistry
+
+    on [:slim, :control] do |sexp|
+      _, _, code = sexp
+      next unless code.last[1][/\A\s*\Z/]
+
+      report_lint(sexp, "Empty control statement can be removed")
+    end
+  end
+end

data/lib/slim_lint/linter/empty_lines.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module SlimLint
+  # This linter checks for two or more consecutive blank lines
+  # and for the first blank line in file.
+  class Linter::EmptyLines < Linter
+    include LinterRegistry
+
+    on_start do |_sexp|
+      was_empty = true
+      document.source.lines.each.with_index(1) do |line, i|
+        if line.blank?
+          if was_empty
+            sexp = Sexp.new(start: [i, 0], finish: [i, 0])
+            report_lint(sexp, "Extra empty line detected")
+          end
+          was_empty = true
+        else
+          was_empty = false
+        end
+      end
+    end
+  end
+end

data/lib/slim_lint/linter/file_length.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module SlimLint
+  # Checks for file longer than a maximum number of lines.
+  class Linter::FileLength < Linter
+    include LinterRegistry
+
+    MSG = "File is too long. [%d/%d]"
+
+    on_start do |_sexp|
+      count = document.source_lines.size
+      if count > config["max"]
+        sexp = Sexp.new(start: [1, 0], finish: [1, 0])
+        report_lint(sexp, format(MSG, count, config["max"]))
+      end
+    end
+  end
+end

data/lib/slim_lint/linter/line_length.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module SlimLint
+  # Checks for lines longer than a maximum number of columns.
+  class Linter::LineLength < Linter
+    include LinterRegistry
+
+    MSG = "Line is too long. [%d/%d]"
+
+    on_start do |_sexp|
+      document.source_lines.each.with_index(1) do |line, i|
+        next if line.length <= config["max"]
+        sexp = Sexp.new(start: [i, 0], finish: [i, 0])
+        report_lint(sexp, format(MSG, line.length, config["max"]))
+      end
+    end
+  end
+end

data/lib/slim_lint/linter/redundant_div.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module SlimLint
+  # Checks for unnecessary uses of the `div` tag where a class name or ID
+  # already implies a div.
+  class Linter::RedundantDiv < Linter
+    include LinterRegistry
+
+    SHORTCUT_ATTRS = %w[id class]
+    MESSAGE = "`div` is redundant when %s attribute shortcut is present"
+
+    on [:html, :tag, "div", capture(:attrs, [:html, :attrs]), anything] do |sexp|
+      _, _, name, value = captures[:attrs][2]
+      next unless name
+      next unless value[0] == :static
+      next unless SHORTCUT_ATTRS.include?(name.value)
+
+      report_lint(sexp[2], MESSAGE % name)
+    end
+  end
+end

data/lib/slim_lint/linter/rubocop.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "slim_lint/ruby_extractor"
+require "slim_lint/ruby_extract_engine"
+require "rubocop"
+
+module SlimLint
+  class Linter
+    # Runs RuboCop on Ruby code extracted from Slim templates.
+    class RuboCop < Linter
+      include LinterRegistry
+
+      on_start do |_sexp|
+        processed_sexp = SlimLint::RubyExtractEngine.new.call(document.source)
+
+        extractor = SlimLint::RubyExtractor.new
+        extracted_source = extractor.extract(processed_sexp)
+
+        next if extracted_source.source.empty?
+
+        find_lints(extracted_source.source, extracted_source.source_map)
+      end
+
+      private
+
+      # Executes RuboCop against the given Ruby code and records the offenses as
+      # lints.
+      #
+      # @param ruby [String] Ruby code
+      # @param source_map [Hash] map of Ruby code line numbers to original line
+      #   numbers in the template
+      def find_lints(ruby, source_map)
+        rubocop = ::RuboCop::CLI.new
+
+        filename = document.file ? "#{document.file}.rb" : "ruby_script.rb"
+
+        with_ruby_from_stdin(ruby) do
+          extract_lints_from_offenses(lint_file(rubocop, filename), source_map)
+        end
+      end
+
+      # Defined so we can stub the results in tests
+      #
+      # @param rubocop [RuboCop::CLI]
+      # @param file [String]
+      # @return [Array<RuboCop::Cop::Offense>]
+      def lint_file(rubocop, file)
+        rubocop.run(rubocop_flags << file)
+        OffenseCollector.offenses
+      end
+
+      # Aggregates RuboCop offenses and converts them to {SlimLint::Lint}s
+      # suitable for reporting.
+      #
+      # @param offenses [Array<RuboCop::Cop::Offense>]
+      # @param source_map [Hash]
+      def extract_lints_from_offenses(offenses, source_map)
+        offenses.reject! { |offense| config["ignored_cops"].include?(offense.cop_name) }
+        offenses.each do |offense|
+          @lints << Lint.new(
+            [self, offense.cop_name],
+            document.file,
+            location_for_line(source_map, offense),
+            offense.message.gsub(/ at \d+, \d+/, "")
+          )
+        end
+      end
+
+      # Returns flags that will be passed to RuboCop CLI.
+      #
+      # @return [Array<String>]
+      def rubocop_flags
+        flags = %w[--format SlimLint::Linter::RuboCop::OffenseCollector]
+        flags += ["--no-display-cop-names"]
+        flags += ["--config", ENV["SLIM_LINT_RUBOCOP_CONF"]] if ENV["SLIM_LINT_RUBOCOP_CONF"]
+        flags += ["--stdin"]
+        flags
+      end
+
+      # Overrides the global stdin to allow RuboCop to read Ruby code from it.
+      #
+      # @param ruby [String] the Ruby code to write to the overridden stdin
+      # @param _block [Block] the block to perform with the overridden stdin
+      # @return [void]
+      def with_ruby_from_stdin(ruby, &_block)
+        original_stdin = $stdin
+        stdin = StringIO.new
+        stdin.puts(ruby.chomp)
+        stdin.rewind
+        $stdin = stdin
+        yield
+      ensure
+        $stdin = original_stdin
+      end
+
+      def location_for_line(source_map, offense)
+        if source_map.key?(offense.line)
+          start = source_map[offense.line].adjust(column: offense.column)
+          finish = source_map[offense.last_line].adjust(column: offense.last_column)
+          SourceLocation.merge(start, finish, length: offense.column_length)
+        else
+          SourceLocation.new(start_line: document.source_lines.size, start_column: 0)
+        end
+      end
+
+      # Collects offenses detected by RuboCop.
+      class OffenseCollector < ::RuboCop::Formatter::BaseFormatter
+        class << self
+          # List of offenses reported by RuboCop.
+          attr_accessor :offenses
+        end
+
+        # Executed when RuboCop begins linting.
+        #
+        # @param _target_files [Array<String>]
+        def started(_target_files)
+          self.class.offenses = []
+        end
+
+        # Executed when a file has been scanned by RuboCop, adding the reported
+        # offenses to our collection.
+        #
+        # @param _file [String]
+        # @param offenses [Array<RuboCop::Cop::Offense>]
+        def file_finished(_file, offenses)
+          self.class.offenses += offenses
+        end
+      end
+    end
+  end
+end