slim_lint_standard 0.0.0

data/lib/slim_lint/document.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module SlimLint
+  # Represents a parsed Slim document and its associated metadata.
+  class Document
+    FRONTMATTER_RE = /
+      # From the start of the string
+      \A
+      # First-capture match --- followed by optional whitespace up
+      # to a newline then 0 or more chars followed by an optional newline.
+      # This matches the --- and the contents of the frontmatter
+      (---\s*\n.*?\n?)
+      # From the start of the line
+      ^
+      # Second capture match --- or ... followed by optional whitespace
+      # and newline. This matches the closing --- for the frontmatter.
+      (---|\.\.\.)\s*$\n?
+    /mx
+
+    # @return [SlimLint::Configuration] Configuration used to parse template
+    attr_reader :config
+
+    # @return [String] Slim template file path
+    attr_reader :file
+
+    # @return [SlimLint::Sexp] Sexpression representing the parsed document
+    attr_reader :sexp
+
+    # @return [String] original source code
+    attr_reader :source
+
+    # @return [Array<String>] original source code as an array of lines
+    attr_reader :source_lines
+
+    # Parses the specified Slim code into a {Document}.
+    #
+    # @param source [String] Slim code to parse
+    # @param options [Hash]
+    # @option options :file [String] file name of document that was parsed
+    # @raise [Slim::Parser::Error] if there was a problem parsing the document
+    def initialize(source, options)
+      @config = options[:config]
+      @file = options.fetch(:file, nil)
+
+      process_source(source)
+    end
+
+    private
+
+    # @param source [String] Slim code to parse
+    # @raise [SlimLint::Exceptions::ParseError] if there was a problem parsing the document
+    def process_source(source)
+      @source = process_encoding(source)
+      @source = strip_frontmatter(source)
+      @source_lines = @source.split("\n")
+
+      engine = SlimLint::Engine.new(file: @file)
+      @sexp = engine.parse(@source)
+    end
+
+    # Ensure the string's encoding is valid.
+    #
+    # @param source [String]
+    # @return [String] source encoded in a valid encoding
+    def process_encoding(source)
+      ::Temple::Filters::Encoding.new.call(source)
+    end
+
+    # Removes YAML frontmatter
+    def strip_frontmatter(source)
+      if config["skip_frontmatter"] && source =~ FRONTMATTER_RE
+        source = $POSTMATCH
+      end
+
+      source
+    end
+  end
+end

data/lib/slim_lint/engine.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module SlimLint
+  # Temple engine used to generate a {Sexp} parse tree for use by linters.
+  #
+  # We omit a lot of the filters that are in {Slim::Engine} because they result
+  # in information potentially being removed from the parse tree (since some
+  # Sexp abstractions are optimized/removed or otherwise transformed). In order
+  # for linters to be useful, they need to operate on the original parse tree.
+  #
+  # The other key task this engine accomplishes is converting the Array-based
+  # S-expressions into {SlimLint::Sexp} objects, which have a number of helper
+  # methods that makes working with them easier. It also annotates these
+  # {SlimLint::Sexp} objects with line numbers so it's easy to cross reference
+  # with the original source code.
+  class Engine < Temple::Engine
+    filter :Encoding
+    filter :RemoveBOM
+
+    # Parse into S-expression using Slim parser
+    use SlimLint::Parser
+
+    # Parses the given source code into a Sexp.
+    #
+    # @param source [String] source code to parse
+    # @return [SlimLint::Sexp] parsed Sexp
+    def parse(source)
+      call(source)
+    rescue ::Slim::Parser::SyntaxError => e
+      # Convert to our own exception type to isolate from upstream changes
+      error = SlimLint::Exceptions::ParseError.new(
+        e.error,
+        e.file,
+        e.line,
+        e.lineno,
+        e.column
+      )
+      raise error
+    end
+  end
+end

data/lib/slim_lint/exceptions.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Collection of exceptions that can be raised by the application.
+module SlimLint::Exceptions
+  # Raised when a {Configuration} could not be loaded from a file.
+  class ConfigurationError < StandardError; end
+
+  # Raised when invalid/incompatible command line options are provided.
+  class InvalidCLIOption < StandardError; end
+
+  # Raised when an invalid file path is specified
+  class InvalidFilePath < StandardError; end
+
+  # Raised when the Slim parser is unable to parse a template.
+  class ParseError < ::Slim::Parser::SyntaxError; end
+
+  # Raised when attempting to execute `Runner` with options that would result in
+  # no linters being enabled.
+  class NoLintersError < StandardError; end
+end

data/lib/slim_lint/file_finder.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "find"
+
+module SlimLint
+  # Finds Slim files that should be linted given a specified list of paths, glob
+  # patterns, and configuration.
+  class FileFinder
+    # List of extensions of files to include under a directory when a directory
+    # is specified instead of a file.
+    VALID_EXTENSIONS = %w[.slim].freeze
+
+    # Create a file finder using the specified configuration.
+    #
+    # @param config [SlimLint::Configuration]
+    def initialize(config)
+      @config = config
+    end
+
+    # Return list of files to lint given the specified set of paths and glob
+    # patterns.
+    # @param patterns [Array<String>]
+    # @param excluded_patterns [Array<String>]
+    # @raise [SlimLint::Exceptions::InvalidFilePath]
+    # @return [Array<String>] list of actual files
+    def find(patterns, excluded_patterns)
+      excluded_patterns = excluded_patterns.map { |pattern| normalize_path(pattern) }
+
+      extract_files_from(patterns).reject do |file|
+        SlimLint::Utils.any_glob_matches?(excluded_patterns, file)
+      end
+    end
+
+    private
+
+    # Extract the list of matching files given the list of glob patterns, file
+    # paths, and directories.
+    #
+    # @param patterns [Array<String>]
+    # @return [Array<String>]
+    def extract_files_from(patterns)
+      files = []
+
+      patterns.each do |pattern|
+        if File.file?(pattern)
+          files << pattern
+        else
+          begin
+            ::Find.find(pattern) do |file|
+              files << file if slim_file?(file)
+            end
+          rescue ::Errno::ENOENT
+            # File didn't exist; it might be a file glob pattern
+            matches = ::Dir.glob(pattern)
+            if matches.any?
+              files += matches
+            else
+              # One of the paths specified does not exist; raise a more
+              # descriptive exception so we know which one
+              raise SlimLint::Exceptions::InvalidFilePath,
+                "File path '#{pattern}' does not exist"
+            end
+          end
+        end
+      end
+
+      files.uniq.sort.map { |file| normalize_path(file) }
+    end
+
+    # Trim "./" from the front of relative paths.
+    #
+    # @param path [String]
+    # @return [String]
+    def normalize_path(path)
+      path.start_with?(".#{File::SEPARATOR}") ? path[2..] : path
+    end
+
+    # Whether the given file should be treated as a Slim file.
+    #
+    # @param file [String]
+    # @return [Boolean]
+    def slim_file?(file)
+      return false unless ::FileTest.file?(file)
+
+      VALID_EXTENSIONS.include?(::File.extname(file))
+    end
+  end
+end

data/lib/slim_lint/filter.rb

@@ -0,0 +1,126 @@
+module SlimLint
+  # Alternative implementation of Slim::Filter that operates without
+  # destroying the Sexp position data.
+  class Filter < Temple::HTML::Filter
+    module Overrides
+      def on_multi(*exps)
+        exps.each.with_index(1) { |exp, i| @self[i] = compile(exp) }
+        @self
+      end
+
+      def on_escape(flag, content)
+        @self[2] = compile(content)
+        @self
+      end
+
+      def on_html_attrs(*attrs)
+        attrs.each.with_index(2) { |attr, i| @self[i] = compile(attr) }
+        @self
+      end
+
+      def on_html_attr(name, content)
+        @self[3] = compile(content)
+        @self
+      end
+
+      def on_html_comment(content)
+        @self[2] = compile(content)
+        @self
+      end
+
+      def on_html_condcomment(condition, content)
+        @self[3] = compile(content)
+        @self
+      end
+
+      def on_html_js(content)
+        @self[2] = compile(content)
+        @self
+      end
+
+      def on_html_tag(name, attrs, content = nil)
+        @self[3] = compile(attrs)
+        @self[4] = compile(content) if content
+        @self
+      end
+
+      # Pass-through handler
+      def on_slim_text(type, content)
+        @self[3] = compile(content)
+        @self
+      end
+
+      # Pass-through handler
+      def on_slim_embedded(type, content, attrs)
+        @self[3] = compile(content)
+        @self
+      end
+
+      # Pass-through handler
+      def on_slim_control(code, content)
+        @self[3] = compile(content)
+        @self
+      end
+
+      # Pass-through handler
+      def on_slim_output(escape, code, content)
+        @self[4] = compile(content)
+        @self
+      end
+
+      private
+
+      def dispatcher(exp)
+        @self_stack ||= []
+        @key_stack ||= []
+        @self_stack << @self
+        @self = exp
+
+        exp.size.downto(1) do |depth|
+          available_methods = dispatched_methods_by_depth[depth]
+          next unless available_methods
+
+          slice = exp.take(depth)
+          next unless slice.all? { |x| x.is_a?(Atom) && x.value.is_a?(Symbol) }
+
+          name = "on_#{slice.join("_")}"
+          if available_methods.include?(name)
+            @key_stack << @key
+            @key = slice
+            return send(name, *exp.drop(depth))
+          end
+        end
+
+        exp
+      ensure
+        @self = @self_stack.pop
+        @key = @key_stack.pop
+      end
+
+      def dispatched_methods_by_depth
+        @dispatched_methods_by_depth ||= dispatched_methods.group_by { |x| x.count("_") }
+      end
+
+      def empty_exp?(exp)
+        case exp[0].value
+        when :multi
+          exp[1..].all? { |e| empty_exp?(e) }
+        else
+          false
+        end
+      end
+
+      # Compares two [line, column] position pairs, and returns true if position
+      # `a` comes before position `b`.
+      #
+      # @param a [Array(Int, Int)] Position `a`
+      # @param b [Array(Int, Int)] Position `b`
+      # @return Does position `a` occur before position `b`?
+      def later_pos?(a, b)
+        a[0] < b[0] || (a[0] == b[0] && a[1] < b[1])
+      end
+    end
+
+    include Overrides
+  end
+end

data/lib/slim_lint/filters/attribute_processor.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module SlimLint
+  module Filters
+    # A dumbed-down version of {Slim::CodeAttributes} which doesn't introduce any
+    # temporary variables or other cruft.
+    class AttributeProcessor < Filter
+      define_options :merge_attrs
+
+      # Handle attributes expression `[:html, :attrs, *attrs]`
+      #
+      # @param attrs [Array]
+      # @return [Array]
+      def on_html_attrs(*attrs)
+        @self.delete_at(1)
+        expr = on_multi(*attrs)
+        expr[0].value = :multi
+        expr
+      end
+
+      # # Handle attribute expression `[:html, :attr, name, value]`
+      # #
+      # # @param name [String] name of the attribute
+      # # @param value [Array] Sexp representing the value
+      # def on_html_attr(name, value)
+      #   if value[0] == :slim && value[1] == :attrvalue
+      #     code = value[3]
+      #     [:code, code]
+      #   else
+      #     @attr = name
+      #     super
+      #   end
+      # end
+
+      def on_slim_attrvalue(_escape, code)
+        return code if code[0] == :multi
+        @self.start = code.start
+        @self.finish = code.finish
+        @self[0].value = :code
+        @self.delete_at(2)
+        @self.delete_at(1)
+        @self
+      end
+    end
+  end
+end

data/lib/slim_lint/filters/auto_indenter.rb

@@ -0,0 +1,39 @@
+module SlimLint
+  module Filters
+    # This filter annotates the sexp with indentation guidance, so that we can
+    # generate Ruby code with reasonable indentation semantics.
+    class AutoIndenter < Filter
+      BLOCK_REGEX = /(\A(if|unless|else|elsif|when|begin|rescue|ensure|case)\b)|\bdo\s*(\|[^|]*\|\s*)?\Z/
+
+      # Handle control expression `[:slim, :control, code, content]`
+      #
+      # @param [String] code Ruby code
+      # @param [Array] content Temple expression
+      # @return [Array] Compiled temple expression
+      def on_slim_control(code, content)
+        @self[3] = compile(content)
+        if code.last.last.value =~ BLOCK_REGEX && content[0].value == :multi
+          @self[3].insert(1, Sexp.new(:slim_lint, :indent, start: content.start, finish: content.start))
+          @self[3].insert(-1, Sexp.new(:slim_lint, :outdent, start: content.finish, finish: content.finish))
+        end
+
+        @self
+      end
+
+      # Handle output expression `[:slim, :control, escape, code, content]`
+      #
+      # @param [String] code Ruby code
+      # @param [Array] content Temple expression
+      # @return [Array] Compiled temple expression
+      def on_slim_output(escape, code, content)
+        @self[4] = compile(content)
+        if code.last.last.value =~ BLOCK_REGEX && content[0].value == :multi
+          @self[4].insert(1, Sexp.new(:slim_lint, :indent, start: content.start, finish: content.start))
+          @self[4].insert(-1, Sexp.new(:slim_lint, :outdent, start: content.finish, finish: content.finish))
+        end
+
+        @self
+      end
+    end
+  end
+end

data/lib/slim_lint/filters/control_processor.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module SlimLint
+  module Filters
+    # A dumbed-down version of {Slim::Controls} which doesn't introduce temporary
+    # variables and other cruft (which in the context of extracting Ruby code,
+    # results in a lot of weird cops reported by RuboCop).
+    class ControlProcessor < Filter
+      BLOCK_RE = /\A(if|unless)\b|\bdo\s*(\|[^|]*\|)?\s*$/
+
+      # Handle output expression `[:slim, :output, escape, code, content]`
+      #
+      # @param _escape [Boolean]
+      # @param code [Sexp]
+      # @param content [Sexp]
+      # @return [Sexp]
+      def on_slim_output(_escape, code, content)
+        _, lines = code
+
+        code.start = @self.start
+        code.finish = @self.finish
+        code << compile(content)
+
+        if lines.last[BLOCK_RE]
+          code << Sexp.new(Atom.new(:code, pos: code.finish), "end", start: code.finish, finish: code.finish)
+        end
+
+        Sexp.new(
+          Atom.new(:dynamic, pos: code.start),
+          code,
+          start: code.start,
+          finish: code.finish
+        )
+      end
+
+      # Handle text expression `[:slim, :text, type, content]`
+      #
+      # @param _type [Symbol]
+      # @param content [Sexp]
+      # @return [Sexp]
+      def on_slim_text(_type, content)
+        compile(content)
+      end
+    end
+  end
+end

data/lib/slim_lint/filters/do_inserter.rb

@@ -0,0 +1,39 @@
+module SlimLint
+  module Filters
+    # In Slim you don't need the do keyword sometimes. This
+    # filter adds the missing keyword.
+    #
+    #   - 10.times
+    #     | Hello
+    #
+    # @api private
+    class DoInserter < Filter
+      BLOCK_REGEX = /(\A(if|unless|else|elsif|when|begin|rescue|ensure|case)\b)|\bdo\s*(\|[^|]*\|\s*)?\Z/
+
+      # Handle control expression `[:slim, :control, code, content]`
+      #
+      # @param [Sexp] code Ruby code
+      # @param [Sexp] content Temple expression
+      # @return [Sexp] Compiled temple expression
+      def on_slim_control(code, content)
+        _, lines = code
+        lines.last.value.concat(" do") unless lines.last.value =~ BLOCK_REGEX || empty_exp?(content)
+        @self[3] = compile(content)
+        @self
+      end
+
+      # Handle output expression `[:slim, :output, escape, code, content]`
+      #
+      # @param [Boolean] escape Escape html
+      # @param [Sexp] code Ruby code
+      # @param [Sexp] content Temple expression
+      # @return [Sexp] Compiled temple expression
+      def on_slim_output(escape, code, content)
+        _, lines = code
+        lines.last.value.concat(" do") unless lines.last.value =~ BLOCK_REGEX || empty_exp?(content)
+        @self[4] = compile(content)
+        @self
+      end
+    end
+  end
+end

data/lib/slim_lint/filters/end_inserter.rb

@@ -0,0 +1,74 @@
+module SlimLint
+  module Filters
+    # In Slim you don't need to close any blocks:
+    #
+    #   - if Slim.awesome?
+    #     | But of course it is!
+    #
+    # However, the parser is not smart enough (and that's a good thing) to
+    # automatically insert end's where they are needed. Luckily, this filter
+    # does *exactly* that (and it does it well!)
+    #
+    # @api private
+    class EndInserter < Filter
+      IF_RE = /\A(if|begin|unless|else|elsif|when|rescue|ensure)\b|\bdo\s*(\|[^|]*\|)?\s*$/
+      ELSE_RE = /\A(else|elsif|when|rescue|ensure)\b/
+      END_RE = /\Aend\b/
+
+      # Handle multi expression `[:multi, *exps]`
+      #
+      # @return [Sexp] Corrected Temple expression with ends inserted
+      def on_multi(*exps)
+        @self.clear
+        @self.concat(@key)
+
+        # This variable is true if the previous line was
+        # (1) a control code and (2) contained indented content.
+        prev_indent = false
+
+        exps.each do |exp|
+          if control?(exp)
+            code_frags = exp[2].last
+            statement = code_frags.last.value
+            raise(Temple::FilterError, "Explicit end statements are forbidden") if END_RE.match?(statement)
+
+            # Two control code in a row. If this one is *not*
+            # an else block, we should close the previous one.
+            if prev_indent && statement !~ ELSE_RE
+              @self << Sexp.new(:code, "end", start: prev_indent.start, finish: prev_indent.start)
+            end
+
+            # Indent if the control code starts a block.
+            prev_indent = (statement =~ IF_RE) && exp
+          elsif prev_indent
+            # This is *not* a control code, so we should close the previous one.
+            # Ignores newlines because they will be inserted after each line.
+            @self << Sexp.new(:code, "end", start: prev_indent.start, finish: prev_indent.start)
+            prev_indent = false
+          end
+
+          @self << compile(exp)
+        end
+
+        # The last line can be a control code too.
+        if prev_indent
+          @self << Sexp.new(:code, "end", start: prev_indent.start, finish: prev_indent.start)
+        end
+
+        @self
+      end
+
+      private
+
+      # Checks if an expression is a Slim control code
+      def control?(exp)
+        exp[0].value == :slim && exp[1].value == :control
+      end
+
+      # Checks if an expression is Slim embedded code
+      def embedded?(exp)
+        exp[0].value == :slim && exp[1].value == :embedded
+      end
+    end
+  end
+end

data/lib/slim_lint/filters/interpolation.rb

@@ -0,0 +1,73 @@
+module SlimLint
+  module Filters
+    # Alternative implementation of Slim::Interpolation that operates without
+    # destroying the Sexp position data.
+    #
+    # @api private
+    class Interpolation < Filter
+      # Handle interpolate expression `[:slim, :interpolate, string]`
+      #
+      # @param [String] string Static interpolate
+      # @return [Array] Compiled temple expression
+      def on_slim_interpolate(string)
+        # Interpolate variables in text (#{variable}).
+        # Split the text into multiple dynamic and static parts.
+        block = Sexp.new(:multi, start: @self.start, finish: @self.finish)
+        line, column = string.start
+        string = string.to_s
+        loop do
+          case string
+          when /\A\\#\{/
+            # Escaped interpolation
+            block << Sexp.new(:static, '#{', start: [line, column], finish: [line, (column += 2)])
+            string = $'
+          when /\A#\{((?>[^{}]|(\{(?>[^{}]|\g<1>)*\}))*)\}/
+            # Interpolation
+            _, string, code = $&, $', $1
+            escape = code !~ /\A\{.*\}\Z/
+
+            column += 2
+            unless escape
+              code = code[1..-2]
+              column += 1
+            end
+
+            start = [line, column]
+            finish = [line, column + code.size]
+
+            block << Sexp.new(
+              :slim,
+              :output,
+              escape,
+              Sexp.new(
+                :multi,
+                Sexp.new(:interpolated, code, start: start, finish: finish),
+                start: start,
+                finish: finish
+              ),
+              Sexp.new(:multi, start: start, finish: finish),
+              start: start,
+              finish: finish
+            )
+
+            column += code.size + 1
+            column += 1 unless escape
+          when /\A([#\\]?[^#\\]*([#\\][^\\{#][^#\\]*)*)/
+            # Static text
+            text, string = $&, $'
+            text_lines = text.count("\n")
+
+            block << Sexp.new(:static, text, start: [line, column], finish: [(line + text_lines), (text_lines == 0 ? column + text.size : 1)])
+
+            line += text_lines
+            column = (text_lines == 0 ? column + text.size : 1)
+          end
+
+          break if string.empty?
+        end
+
+        block
+      end
+    end
+  end
+end