slim_lint_standard 0.0.0

data/lib/slim_lint/report.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module SlimLint
+  # Contains information about all lints detected during a scan.
+  class Report
+    # List of lints that were found.
+    attr_accessor :lints
+
+    # List of files that were linted.
+    attr_reader :files
+
+    # Creates a report.
+    #
+    # @param lints [Array<SlimLint::Lint>] lints that were found
+    # @param files [Array<String>] files that were linted
+    def initialize(lints, files)
+      @lints = lints.sort_by { |l| [l.filename, l.line] }
+      @files = files
+    end
+
+    def failed?
+      @lints.any?
+    end
+  end
+end

data/lib/slim_lint/reporter/checkstyle_reporter.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "rexml/document"
+
+module SlimLint
+  # Outputs report as a Checkstyle XML document.
+  class Reporter::CheckstyleReporter < Reporter
+    def display_report(report)
+      document = REXML::Document.new.tap do |d|
+        d << REXML::XMLDecl.new
+      end
+      checkstyle = REXML::Element.new("checkstyle", document)
+
+      report.lints.group_by(&:filename).map do |lint|
+        map_file(lint, checkstyle)
+      end
+
+      log.log document.to_s
+    end
+
+    private
+
+    def map_file(file, checkstyle)
+      REXML::Element.new("file", checkstyle).tap do |f|
+        path_name = file.first
+        path_name = relative_path(file) if defined?(relative_path)
+        f.attributes["name"] = path_name
+
+        file.last.map { |o| map_offense(o, f) }
+      end
+    end
+
+    def map_offense(offence, parent)
+      REXML::Element.new("error", parent).tap do |e|
+        e.attributes["line"] = offence.line
+        e.attributes["severity"] = offence.error? ? "error" : "warning"
+        e.attributes["message"] = offence.message
+        e.attributes["source"] = "slim-lint"
+      end
+    end
+  end
+end

data/lib/slim_lint/reporter/default_reporter.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module SlimLint
+  # Outputs lints in a simple format with the filename, line number, and lint
+  # message.
+  class Reporter::DefaultReporter < Reporter
+    def display_report(report)
+      sorted_lints = report.lints.sort_by { |l| [l.filename, l.line] }
+
+      sorted_lints.each do |lint|
+        print_location(lint)
+        print_type(lint)
+        print_message(lint)
+      end
+    end
+
+    private
+
+    def print_location(lint)
+      log.info lint.filename, false
+      log.log ":", false
+      log.bold lint.line, false
+      log.log ":", false
+      log.bold lint.column, false
+    end
+
+    def print_type(lint)
+      if lint.error?
+        log.error " [E] ", false
+      else
+        log.warning " [W] ", false
+      end
+    end
+
+    def print_message(lint)
+      log.success("#{lint.name}: ", false)
+      log.log lint.message
+    end
+  end
+end

data/lib/slim_lint/reporter/emacs_reporter.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module SlimLint
+  # Outputs lints in format: {filename}:{line}:{column}: {kind}: {message}.
+  class Reporter::EmacsReporter < Reporter
+    def display_report(report)
+      sorted_lints = report.lints.sort_by { |l| [l.filename, l.line] }
+
+      sorted_lints.each do |lint|
+        print_location(lint)
+        print_type(lint)
+        print_message(lint)
+      end
+    end
+
+    private
+
+    def print_location(lint)
+      log.info lint.filename, false
+      log.log ":", false
+      log.bold lint.line, false
+      log.log ":", false
+      log.bold lint.column, false
+      log.log ":", false
+    end
+
+    def print_type(lint)
+      if lint.error?
+        log.error " E: ", false
+      else
+        log.warning " W: ", false
+      end
+    end
+
+    def print_message(lint)
+      log.success("#{lint.name}: ", false)
+      log.log lint.message
+    end
+  end
+end

data/lib/slim_lint/reporter/json_reporter.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module SlimLint
+  # Outputs report as a JSON document.
+  class Reporter::JsonReporter < Reporter
+    def display_report(report)
+      lints = report.lints
+      grouped = lints.group_by(&:filename)
+
+      report_hash = {
+        metadata: metadata,
+        files: grouped.map { |l| map_file(l) },
+        summary: {
+          offense_count: lints.length,
+          target_file_count: grouped.length,
+          inspected_file_count: report.files.length
+        }
+      }
+
+      log.log report_hash.to_json
+    end
+
+    private
+
+    def metadata
+      {
+        slim_lint_version: SlimLint::VERSION,
+        ruby_engine: RUBY_ENGINE,
+        ruby_patchlevel: RUBY_PATCHLEVEL.to_s,
+        ruby_platform: RUBY_PLATFORM
+      }
+    end
+
+    def map_file(file)
+      {
+        path: file.first,
+        offenses: file.last.map { |o| map_offense(o) }
+      }
+    end
+
+    def map_offense(offense)
+      {
+        severity: offense.severity,
+        message: offense.message,
+        location: offense.location.as_json,
+        cop_name: offense.name
+      }
+    end
+  end
+end

data/lib/slim_lint/reporter.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module SlimLint
+  # Abstract lint reporter. Subclass and override {#display_report} to
+  # implement a custom lint reporter.
+  #
+  # @abstract
+  class Reporter
+    # Creates the reporter that will display the given report.
+    #
+    # @param logger [SlimLint::Logger]
+    def initialize(logger)
+      @log = logger
+    end
+
+    # Implemented by subclasses to display lints from a {SlimLint::Report}.
+    #
+    # @param report [SlimLint::Report]
+    def display_report(report)
+      raise NotImplementedError,
+        "Implement `display_report` to display #{report}"
+    end
+
+    # Keep tracking all the descendants of this class for the list of available
+    # reporters.
+    #
+    # @return [Array<Class>]
+    def self.descendants
+      @descendants ||= []
+    end
+
+    # Executed when this class is subclassed.
+    #
+    # @param descendant [Class]
+    def self.inherited(descendant)
+      descendants << descendant
+    end
+
+    private
+
+    # @return [SlimLint::Logger] logger to send output to
+    attr_reader :log
+  end
+end

data/lib/slim_lint/ruby_extract_engine.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module SlimLint
+  # Generates a {SlimLint::Sexp} suitable for consumption by the
+  # {RubyExtractor}.
+  #
+  # This is mostly copied from Slim::Engine, with some filters and generators
+  # omitted.
+  class RubyExtractEngine < Temple::Engine
+    filter :Encoding
+    filter :RemoveBOM
+
+    # Parse into S-expression using Slim parser
+    use SlimLint::Parser
+
+    # Perform additional processing so extracting Ruby code in {RubyExtractor}
+    # is easier. We don't do this for regular linters because some information
+    # about the original syntax tree is lost in the process, but that doesn't
+    # matter in this case.
+    use SlimLint::Filters::Interpolation
+    use SlimLint::Filters::SplatProcessor
+    use SlimLint::Filters::DoInserter
+    use SlimLint::Filters::EndInserter
+    use SlimLint::Filters::AutoIndenter
+    use SlimLint::Filters::ControlProcessor
+    use SlimLint::Filters::AttributeProcessor
+    use SlimLint::Filters::MultiFlattener
+    use SlimLint::Filters::StaticMerger
+  end
+end

data/lib/slim_lint/ruby_extractor.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module SlimLint
+  # Utility class for extracting Ruby script from a Slim template that can then
+  # be linted with a Ruby linter (i.e. is "legal" Ruby).
+  #
+  # The goal is to turn this:
+  #
+  #    - if items.any?
+  #      table#items
+  #      - for item in items
+  #        tr
+  #          td.name = item.name
+  #          td.price = item.price
+  #    - else
+  #       p No items found.
+  #
+  # into (something like) this:
+  #
+  #    if items.any?
+  #      for item in items
+  #        puts item.name
+  #        puts item.price
+  #    else
+  #      puts 'No items found'
+  #    end
+  #
+  # The translation won't be perfect, and won't make any real sense, but the
+  # relationship between variable declarations/uses and the flow control graph
+  # will remain intact.
+  class RubyExtractor
+    include SexpVisitor
+    extend SexpVisitor::DSL
+
+    # Stores the extracted source and a map of lines of generated source to the
+    # original source that created them.
+    #
+    # @attr_reader source [String] generated source code
+    # @attr_reader source_map [Hash] map of line numbers from generated source
+    #   to original source line number
+    RubySource = Struct.new(:source, :source_map)
+
+    # Extracts Ruby code from Sexp representing a Slim document.
+    #
+    # @param sexp [SlimLint::Sexp]
+    # @return [SlimLint::RubyExtractor::RubySource]
+    def extract(sexp)
+      trigger_pattern_callbacks(sexp)
+      RubySource.new(@source_lines.join("\n") + "\n", @source_map)
+    end
+
+    on_start do |_sexp|
+      @source_lines = []
+      @source_map = {}
+      @line_count = 0
+      @indent = 0
+      @dummy_puts_count = 0
+    end
+
+    on [:html, :doctype] do |sexp|
+      append_dummy_puts(sexp)
+    end
+
+    on [:html, :tag] do |sexp|
+      append_dummy_puts(sexp)
+    end
+
+    on [:html, :attr] do |sexp|
+      _, _, attr, value = sexp
+      append("attribute(#{attr.value.inspect}) do", attr)
+      @indent += 1
+      traverse(value)
+      @indent -= 1
+      append("end", attr)
+      :stop
+    end
+
+    on [:html, :comment] do |sexp|
+      append_dummy_puts(sexp)
+      :stop
+    end
+
+    on [:html, :condcomment] do |sexp|
+      append_dummy_puts(sexp)
+      :stop
+    end
+
+    on [:slim_lint, :indent] do |sexp|
+      @indent += 1
+    end
+
+    on [:slim_lint, :outdent] do |sexp|
+      @indent -= 1
+    end
+
+    on [:static] do |sexp|
+      append_dummy_puts(sexp)
+    end
+
+    on [:dynamic] do |sexp|
+      _, ruby = sexp
+      append("output do", sexp)
+      @indent += 1
+      traverse_children(ruby)
+      @indent -= 1
+      append("end", sexp)
+      :stop
+    end
+
+    on [:interpolated] do |sexp|
+      _, ruby = sexp
+      append_interpolated(ruby, sexp)
+    end
+
+    on [:code] do |sexp|
+      _, ruby = sexp
+      append(ruby.value, sexp)
+    end
+
+    on [:slim, :embedded] do |sexp|
+      _, _, name, body, _attrs = sexp
+
+      if name == "ruby"
+        body.drop(1).each do |subexp|
+          if subexp[0] == :static
+            append(subexp[1].value, subexp)
+          end
+        end
+      else
+        append_dummy_puts(sexp)
+      end
+
+      :stop
+    end
+
+    private
+
+    # Append code to the buffer.
+    #
+    # @param code [String]
+    # @param sexp [SlimLint::Sexp]
+    def append(code, sexp)
+      raise "Unexpected newline!" if code.match?(/\n/)
+
+      @source_lines << code.dup
+      @line_count += 1
+
+      if code.empty?
+        @source_map[@line_count] = sexp.location
+      else
+        @source_lines.last.prepend("  " * @indent)
+        @source_map[@line_count] = sexp.location.adjust(column: -2 * @indent)
+      end
+    end
+
+    def append_dynamic(code, sexp)
+      return if code.empty?
+      @source_lines << "#{"  " * @indent}p #{code}"
+      @line_count += 1
+      @source_map[@line_count] = sexp.location.adjust(column: (-2 * @indent) - 2)
+    end
+
+    def append_interpolated(code, sexp)
+      return if code.empty?
+      @source_lines << %(#{"  " * @indent}p "x\#{#{code}}x")
+      @line_count += 1
+      @source_map[@line_count] = code.location.adjust(column: (-2 * @indent) - 6)
+    end
+
+    def append_dummy_puts(sexp)
+      append("_slim_lint_puts_#{@dummy_puts_count}", sexp)
+      @dummy_puts_count += 1
+    end
+  end
+end

data/lib/slim_lint/ruby_parser.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "rubocop"
+require "rubocop/ast/builder"
+require "parser/current"
+
+module SlimLint
+  # Parser for the Ruby language.
+  #
+  # This provides a convenient wrapper around the `parser` gem and the
+  # `astrolabe` integration to go with it. It is intended to be used for linter
+  # checks that require deep inspection of Ruby code.
+  class RubyParser
+    # Creates a reusable parser.
+    def initialize
+      @builder = ::RuboCop::AST::Builder.new
+      @parser = ::Parser::CurrentRuby.new(@builder)
+    end
+
+    # Parse the given Ruby source into an abstract syntax tree.
+    #
+    # @param source [String] Ruby source code
+    # @return [Array] syntax tree in the form returned by Parser gem
+    def parse(source)
+      buffer = ::Parser::Source::Buffer.new("(string)")
+      buffer.source = source
+
+      @parser.reset
+      @parser.parse(buffer)
+    end
+  end
+end

data/lib/slim_lint/runner.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module SlimLint
+  # Responsible for running the applicable linters against the desired files.
+  class Runner
+    # Runs the appropriate linters against the desired files given the specified
+    # options.
+    #
+    # @param [Hash] options
+    # @option options :config_file [String] path of configuration file to load
+    # @option options :config [SlimLint::Configuration] configuration to use
+    # @option options :excluded_files [Array<String>]
+    # @option options :included_linters [Array<String>]
+    # @option options :excluded_linters [Array<String>]
+    # @return [SlimLint::Report] a summary of all lints found
+    def run(options = {})
+      config = load_applicable_config(options)
+      linter_selector = SlimLint::LinterSelector.new(config, options)
+
+      if options[:stdin_file_path].nil?
+        files = extract_applicable_files(config, options)
+        lints = files.map do |file|
+          collect_lints(File.read(file), file, linter_selector, config)
+        end.flatten
+      else
+        files = [options[:stdin_file_path]]
+        lints = collect_lints($stdin.read, options[:stdin_file_path], linter_selector, config)
+      end
+
+      SlimLint::Report.new(lints, files)
+    end
+
+    private
+
+    # Returns the {SlimLint::Configuration} that should be used given the
+    # specified options.
+    #
+    # @param options [Hash]
+    # @return [SlimLint::Configuration]
+    def load_applicable_config(options)
+      if options[:config_file]
+        SlimLint::ConfigurationLoader.load_file(options[:config_file])
+      elsif options[:config]
+        options[:config]
+      else
+        SlimLint::ConfigurationLoader.load_applicable_config
+      end
+    end
+
+    # Runs all provided linters using the specified config against the given
+    # file.
+    #
+    # @param file [String] path to file to lint
+    # @param linter_selector [SlimLint::LinterSelector]
+    # @param config [SlimLint::Configuration]
+    def collect_lints(file_content, file_name, linter_selector, config)
+      begin
+        document = SlimLint::Document.new(file_content, file: file_name, config: config)
+      rescue SlimLint::Exceptions::ParseError => e
+        return [SlimLint::Lint.new(nil, file_name, SourceLocation.new(start_line: e.lineno), e.error, :error)]
+      end
+
+      linter_selector.linters_for_file(file_name).map do |linter|
+        linter.run(document)
+      end.flatten
+    end
+
+    # Returns the list of files that should be linted given the specified
+    # configuration and options.
+    #
+    # @param config [SlimLint::Configuration]
+    # @param options [Hash]
+    # @return [Array<String>]
+    def extract_applicable_files(config, options)
+      included_patterns = options[:files]
+      excluded_patterns = config["exclude"]
+      excluded_patterns += options.fetch(:excluded_files, [])
+
+      SlimLint::FileFinder.new(config).find(included_patterns, excluded_patterns)
+    end
+  end
+end

data/lib/slim_lint/sexp.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module SlimLint
+  # Symbolic expression which represents tree-structured data.
+  #
+  # The main use of this particular implementation is to provide a single
+  # location for defining convenience helpers when operating on Sexps.
+  class Sexp < Array
+    # Stores the line number of the code in the original document that
+    # corresponds to this Sexp.
+    attr_accessor :start, :finish
+
+    def line
+      start[0] if start
+    end
+
+    def column
+      start[1] if start
+    end
+
+    # Creates an {Sexp} from the given {Array}-based Sexp.
+    #
+    # This provides a convenient way to convert between literal arrays of
+    # {Symbol}s and {Sexp}s containing {Atom}s and nested {Sexp}s. These objects
+    # all expose a similar API that conveniently allows the two objects to be
+    # treated similarly due to duck typing.
+    #
+    # @param array_sexp [Array]
+    def initialize(*array_sexp, start:, finish:)
+      @start = start
+      @finish = finish
+      array_sexp.each do |atom_or_sexp|
+        case atom_or_sexp
+        when Sexp, Atom
+          push atom_or_sexp
+        when Array
+          push Sexp.new(*atom_or_sexp, start: start, finish: finish)
+        else
+          push SlimLint::Atom.new(atom_or_sexp, pos: start)
+        end
+      end
+    end
+
+    def location
+      SourceLocation.new(
+        start_line: start[0],
+        start_column: start[1],
+        last_line: (finish || start)[0],
+        last_column: (finish || start)[1]
+      )
+    end
+
+    # Returns whether this {Sexp} matches the given Sexp pattern.
+    #
+    # A Sexp pattern is simply an incomplete Sexp prefix.
+    #
+    # @example
+    #   The following Sexp:
+    #
+    #     [:html, :doctype, "html5"]
+    #
+    #   ...will match the given patterns:
+    #
+    #     [:html]
+    #     [:html, :doctype]
+    #     [:html, :doctype, "html5"]
+    #
+    # Note that nested Sexps will also be matched, so be careful about the cost
+    # of matching against a complicated pattern.
+    #
+    # @param sexp_pattern [Object,Array]
+    # @return [Boolean]
+    def match?(sexp_pattern)
+      # Delegate matching logic if we're comparing against a matcher
+      if sexp_pattern.is_a?(SlimLint::Matcher::Base)
+        return sexp_pattern.match?(self)
+      end
+
+      # If there aren't enough items to compare then this obviously won't match
+      return false unless sexp_pattern.is_a?(Array) && length >= sexp_pattern.length
+
+      sexp_pattern.each_with_index do |sub_pattern, index|
+        return false unless self[index].match?(sub_pattern)
+      end
+
+      true
+    end
+
+    def to_array
+      map(&:to_array)
+    end
+
+    # Returns pretty-printed representation of this S-expression.
+    #
+    # @return [String]
+    def inspect
+      display
+    end
+
+    protected
+
+    # Pretty-prints this Sexp in a form that is more readable.
+    #
+    # @param depth [Integer] indentation level to display Sexp at
+    # @return [String]
+    def display(depth = 1)
+      indentation = " " * 2 * depth
+      range = +""
+      range << start.join(":") if start
+      range << " => " if start && finish
+      range << finish.join(":") if finish
+      output = "S(#{range})["
+
+      each_with_index do |nested_sexp, index|
+        output << "\n"
+        output += indentation
+        output +=
+          if nested_sexp.is_a?(SlimLint::Sexp)
+            nested_sexp.display(depth + 1)
+          else
+            nested_sexp.inspect
+          end
+
+        # Add trailing comma unless this is the last item
+        output += ", " if index < length - 1
+      end
+
+      output << "\n" << " " * 2 * (depth - 1) unless empty?
+      output << "]"
+
+      output
+    end
+  end
+end