slim_lint_standard 0.0.0

data/lib/slim_lint/linter/standard.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "slim_lint/ruby_extractor"
+require "slim_lint/ruby_extract_engine"
+
+module SlimLint
+  class Linter
+    # Runs RuboCop on Ruby code extracted from Slim templates.
+    class Standard < RuboCop
+      include LinterRegistry
+
+      def initialize(*args)
+        require "standard"
+        super
+      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)
+        filename = document.file ? "#{document.file}.rb" : "ruby_script.rb"
+
+        with_ruby_from_stdin(ruby) do
+          extract_lints_from_offenses(lint_file(filename), source_map)
+        end
+      end
+
+      # Defined so we can stub the results in tests
+      #
+      # @param file [String]
+      # @return [Array<RuboCop::Cop::Offense>]
+      def lint_file(filename)
+        ::Standard::Cli.new(rubocop_flags << filename).run
+        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.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 += ["--stdin"]
+        flags
+      end
+    end
+  end
+end

data/lib/slim_lint/linter/tab.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module SlimLint
+  # Searches for tab indentation
+  class Linter::Tab < Linter
+    include LinterRegistry
+
+    TAB_RE = /^( *)[\t ]*\t/
+    MSG = "Tab detected"
+
+    on_start do |_sexp|
+      document.source_lines.each.with_index(1) do |line, lineno|
+        next unless TAB_RE.match?(line)
+
+        sexp = Sexp.new(:dummy, start: [lineno, 0], finish: [lineno, ($` ? $`.size : 0)])
+        report_lint(sexp, MSG)
+      end
+    end
+  end
+end

data/lib/slim_lint/linter/tag_case.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SlimLint
+  # Searches for tags with uppercase characters.
+  class Linter::TagCase < Linter
+    include LinterRegistry
+
+    on [:html, :tag] do |sexp|
+      _, _, name = sexp
+      next unless name[/[A-Z]/]
+
+      report_lint(sexp, "Tag `#{name}` should be written as `#{name.downcase}`")
+    end
+  end
+end

data/lib/slim_lint/linter/trailing_blank_lines.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module SlimLint
+  # This linter looks for trailing blank lines and a final newline.
+  class Linter::TrailingBlankLines < Linter
+    include LinterRegistry
+
+    on_start do |_sexp|
+      next if document.source.empty?
+
+      sexp = Sexp.new(:dummy, start: [document.source.lines.size, 0], finish: [document.source.lines.size, 0])
+      if !document.source.end_with?("\n")
+        report_lint(sexp, "No blank line in the end of file")
+      elsif document.source.lines.last.blank?
+        report_lint(sexp, "Multiple empty lines in the end of file")
+      end
+    end
+  end
+end

data/lib/slim_lint/linter/trailing_whitespace.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module SlimLint
+  # Checks for trailing whitespace.
+  class Linter::TrailingWhitespace < Linter
+    include LinterRegistry
+
+    on_start do |_sexp|
+      document.source_lines.each.with_index(1) do |line, lineno|
+        next unless /\s+$/.match?(line)
+
+        sexp = Sexp.new(:dummy, start: [lineno, line.rstrip.size], finish: [lineno, line.size])
+        report_lint(sexp, "Line contains trailing whitespace")
+      end
+    end
+  end
+end

data/lib/slim_lint/linter.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module SlimLint
+  # Base implementation for all lint checks.
+  #
+  # @abstract
+  class Linter
+    # Include definitions for Sexp pattern-matching helpers.
+    include SexpVisitor
+    extend SexpVisitor::DSL
+
+    # List of lints reported by this linter.
+    #
+    # @todo Remove once spec/support/shared_linter_context returns an array of
+    #   lints for the subject instead of the linter itself.
+    attr_reader :lints
+
+    # Initializes a linter with the specified configuration.
+    #
+    # @param config [Hash] configuration for this linter
+    def initialize(config)
+      @config = config
+      @lints = []
+    end
+
+    # Runs the linter against the given Slim document.
+    #
+    # @param document [SlimLint::Document]
+    def run(document)
+      @document = document
+      @lints = []
+      @disabled_lines = nil
+      trigger_pattern_callbacks(document.sexp)
+      @lints
+    end
+
+    # Returns the simple name for this linter.
+    #
+    # @return [String]
+    def name
+      self.class.name.split("::").last
+    end
+
+    private
+
+    attr_reader :config, :document
+
+    # Record a lint for reporting back to the user.
+    #
+    # @param node [Sexp, Atom] node to extract the line number from
+    # @param message [String] error/warning to display to the user
+    def report_lint(node, message)
+      return if disabled_for_line?(node.line)
+
+      @lints << SlimLint::Lint.new(self, @document.file, node.location, message)
+    end
+
+    # Parse Ruby code into an abstract syntax tree.
+    #
+    # @param source [String] Ruby code to parse
+    # @return [AST::Node]
+    def parse_ruby(source)
+      @ruby_parser ||= SlimLint::RubyParser.new
+      @ruby_parser.parse(source)
+    end
+
+    def disabled_for_line?(line)
+      disabled_lines.include?(line)
+    end
+
+    def disabled_lines
+      @disabled_lines ||= begin
+        currently_disabled = false
+        @document.source_lines.each_with_index.each_with_object([]) do |pair, lines|
+          line = pair[0]
+          line_number = pair[1] + 1
+
+          if line.match?(%r{/ slim-lint:disable #{linter_name}})
+            currently_disabled = true
+          elsif line.match?(%r{/ slim-lint:enable #{linter_name}})
+            currently_disabled = false
+          elsif currently_disabled
+            lines << line_number
+          end
+        end
+      end
+    end
+
+    def linter_name
+      @linter_name ||= self.class.name.split("::").last
+    end
+  end
+end

data/lib/slim_lint/linter_registry.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module SlimLint
+  class NoSuchLinter < StandardError; end
+
+  # Stores all defined linters.
+  module LinterRegistry
+    @linters = []
+
+    class << self
+      # List of all registered linters.
+      attr_reader :linters
+
+      # Executed when a linter includes the {LinterRegistry} module.
+      #
+      # This results in the linter being registered with the registry.
+      #
+      # @param subclass [Class]
+      def included(subclass)
+        @linters << subclass
+      end
+
+      # Return a list of {SlimLint::Linter} {Class}es corresponding to the
+      # specified list of names.
+      #
+      # @param linter_names [Array<String>]
+      # @return [Array<Class>]
+      def extract_linters_from(linter_names)
+        linter_names.map do |linter_name|
+          SlimLint::Linter.const_get(linter_name)
+        rescue NameError
+          raise NoSuchLinter, "Linter #{linter_name} does not exist"
+        end
+      end
+    end
+  end
+end

data/lib/slim_lint/linter_selector.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module SlimLint
+  # Chooses the appropriate linters to run given the specified configuration.
+  class LinterSelector
+    # Creates a selector using the given configuration and additional options.
+    #
+    # @param config [SlimLint::Configuration]
+    # @param options [Hash]
+    def initialize(config, options)
+      @config = config
+      @options = options
+    end
+
+    # Returns the set of linters to run against the given file.
+    #
+    # @param file [String]
+    # @raise [SlimLint::Exceptions::NoLintersError] when no linters are enabled
+    # @return [Array<SlimLint::Linter>]
+    def linters_for_file(file)
+      @linters ||= extract_enabled_linters(@config, @options)
+      @linters.select { |linter| run_linter_on_file?(@config, linter, file) }
+    end
+
+    private
+
+    # Returns a list of linter names that are enabled given the specified
+    # configuration and additional options.
+    #
+    # @param config [SlimLint::Configuration]
+    # @param options [Hash]
+    # @return [Array<String>]
+    def extract_enabled_linter_names(config, options)
+      included_linters = options.fetch(:included_linters, [])
+      included_linters = LinterRegistry.linters.map(&:name) if included_linters.empty?
+
+      excluded_linters = options.fetch(:excluded_linters, [])
+
+      # After filtering out explicitly included/excluded linters, only include
+      # linters which are enabled in the configuration
+      linters = (included_linters - excluded_linters).select do |name|
+        config.for_linter(name)["enabled"]
+      end
+
+      # Highlight condition where all linters were filtered out, as this was
+      # likely a mistake on the user's part
+      if linters.empty?
+        raise SlimLint::Exceptions::NoLintersError, "No linters specified"
+      end
+
+      linters
+    end
+
+    # Returns a list of linters that are enabled given the specified
+    # configuration and additional options.
+    #
+    # @param config [SlimLint::Configuration]
+    # @param options [Hash]
+    # @return [Array<SlimLint::Linter>]
+    def extract_enabled_linters(config, options)
+      linter_names = extract_enabled_linter_names(config, options)
+      linter_classes = LinterRegistry.extract_linters_from(linter_names)
+      linter_classes.map { |klass| klass.new(config.for_linter(klass)) }
+    end
+
+    # Whether to run the given linter against the specified file.
+    #
+    # @param config [SlimLint::Configuration]
+    # @param linter [SlimLint::Linter]
+    # @param file [String]
+    # @return [Boolean]
+    def run_linter_on_file?(config, linter, file)
+      linter_config = config.for_linter(linter)
+      incl, excl = linter_config["include"], linter_config["exclude"]
+
+      if incl.any? && !SlimLint::Utils.any_glob_matches?(incl, file)
+        return false
+      end
+
+      if SlimLint::Utils.any_glob_matches?(excl, file)
+        return false
+      end
+
+      true
+    end
+  end
+end

data/lib/slim_lint/logger.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module SlimLint
+  # Encapsulates all communication to an output source.
+  class Logger
+    # Whether colored output via ANSI escape sequences is enabled.
+    # @return [true,false]
+    attr_accessor :color_enabled
+
+    # Creates a logger which outputs nothing.
+    # @return [SlimLint::Logger]
+    def self.silent
+      new(File.open("/dev/null", "w"))
+    end
+
+    # Creates a new {SlimLint::Logger} instance.
+    #
+    # @param out [IO] the output destination.
+    def initialize(out)
+      @out = out
+    end
+
+    # Print the specified output.
+    #
+    # @param output [String] the output to send
+    # @param newline [true,false] whether to append a newline
+    def log(output, newline = true)
+      @out.print(output)
+      @out.print("\n") if newline
+    end
+
+    # Print the specified output in bold face.
+    # If output destination is not a TTY, behaves the same as {#log}.
+    #
+    # @param args [Array<String>]
+    def bold(*args)
+      color("1", *args)
+    end
+
+    # Print the specified output in a color indicative of error.
+    # If output destination is not a TTY, behaves the same as {#log}.
+    #
+    # @param args [Array<String>]
+    def error(*args)
+      color(31, *args)
+    end
+
+    # Print the specified output in a bold face and color indicative of error.
+    # If output destination is not a TTY, behaves the same as {#log}.
+    #
+    # @param args [Array<String>]
+    def bold_error(*args)
+      color("1;31", *args)
+    end
+
+    # Print the specified output in a color indicative of success.
+    # If output destination is not a TTY, behaves the same as {#log}.
+    #
+    # @param args [Array<String>]
+    def success(*args)
+      color(32, *args)
+    end
+
+    # Print the specified output in a color indicative of a warning.
+    # If output destination is not a TTY, behaves the same as {#log}.
+    #
+    # @param args [Array<String>]
+    def warning(*args)
+      color(33, *args)
+    end
+
+    # Print the specified output in a color indicating information.
+    # If output destination is not a TTY, behaves the same as {#log}.
+    #
+    # @param args [Array<String>]
+    def info(*args)
+      color(36, *args)
+    end
+
+    # Print a blank line.
+    def newline
+      log("")
+    end
+
+    # Whether this logger is outputting to a TTY.
+    #
+    # @return [true,false]
+    def tty?
+      @out.respond_to?(:tty?) && @out.tty?
+    end
+
+    private
+
+    # Print output in the specified color.
+    #
+    # @param code [Integer,String] ANSI color code
+    # @param output [String] output to print
+    # @param newline [Boolean] whether to append a newline
+    def color(code, output, newline = true)
+      log(color_enabled ? "\033[#{code}m#{output}\033[0m" : output, newline)
+    end
+  end
+end

data/lib/slim_lint/matcher/anything.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module SlimLint::Matcher
+  # Will match anything, acting as a wildcard.
+  class Anything < Base
+    # @see {SlimLint::Matcher::Base#match?}
+    def match?(*)
+      true
+    end
+  end
+end

data/lib/slim_lint/matcher/base.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module SlimLint::Matcher
+  # Represents a Sexp pattern implementing complex matching logic.
+  #
+  # Subclasses can implement custom logic to create complex matches that can be
+  # reused across linters, DRYing up matching code.
+  #
+  # @abstract
+  class Base
+    # Whether this matcher matches the specified object.
+    #
+    # This must be implemented by subclasses.
+    #
+    # @param other [Object]
+    # @return [Boolean]
+    def match?(*)
+      raise NotImplementedError, "Matcher must implement `match?`"
+    end
+  end
+end

data/lib/slim_lint/matcher/capture.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module SlimLint::Matcher
+  # Wraps a matcher, taking on the behavior of the wrapped matcher but storing
+  # the value that matched so it can be referred to later.
+  class Capture < Base
+    # @return [SlimLint::Matcher::Base] matcher that this capture wraps
+    attr_accessor :matcher
+
+    # @return [Object] value that was captured
+    attr_accessor :value
+
+    # Creates a capture that wraps that given matcher.
+    #
+    # @param matcher [SlimLint::Matcher::Base]
+    # @return [SlimLint::Matcher::Capture]
+    def self.from_matcher(matcher)
+      new.tap do |cap_matcher|
+        cap_matcher.matcher = matcher
+      end
+    end
+
+    # @see {SlimLint::Matcher::Base#match?}
+    def match?(object)
+      if (result = @matcher.match?(object))
+        @value = object
+      end
+
+      result
+    end
+  end
+end

data/lib/slim_lint/matcher/nothing.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module SlimLint::Matcher
+  # Does not match anything.
+  #
+  # This is used in specs.
+  class Nothing < Base
+    # @see {SlimLint::Matcher::Base#match?}
+    def match?(*)
+      false
+    end
+  end
+end

data/lib/slim_lint/options.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module SlimLint
+  # Handles option parsing for the command line application.
+  class Options
+    # Parses command line options into an options hash.
+    #
+    # @param args [Array<String>] arguments passed via the command line
+    # @return [Hash] parsed options
+    def parse(args)
+      @options = {}
+
+      OptionParser.new do |parser|
+        parser.banner = "Usage: #{APP_NAME} [options] [file1, file2, ...]"
+
+        add_linter_options parser
+        add_file_options parser
+        add_info_options parser
+      end.parse!(args)
+
+      # Any remaining arguments are assumed to be files
+      @options[:files] = args
+
+      @options
+    rescue OptionParser::InvalidOption => e
+      raise Exceptions::InvalidCLIOption,
+        e.message,
+        e.backtrace
+    end
+
+    private
+
+    # Register linter-related flags.
+    def add_linter_options(parser)
+      msg = "Specify which linters you want to run"
+      parser.on("-i", "--include-linter linter,...", Array, msg) do |linters|
+        @options[:included_linters] = linters
+      end
+
+      msg = "Specify which linters you don't want to run"
+      parser.on("-x", "--exclude-linter linter,...", Array, msg) do |linters|
+        @options[:excluded_linters] = linters
+      end
+
+      msg = "Specify which reporter you want to use to generate the output"
+      parser.on("-r", "--reporter reporter", String, msg) do |reporter|
+        @options[:reporter] = load_reporter_class(reporter.capitalize)
+      end
+    end
+
+    # Returns the class of the specified Reporter.
+    #
+    # @param reporter_name [String]
+    # @raise [SlimLint::Exceptions::InvalidCLIOption] if reporter doesn't exist
+    # @return [Class]
+    def load_reporter_class(reporter_name)
+      SlimLint::Reporter.const_get("#{reporter_name}Reporter")
+    rescue NameError
+      raise SlimLint::Exceptions::InvalidCLIOption,
+        "#{reporter_name}Reporter does not exist"
+    end
+
+    # Register file-related flags.
+    def add_file_options(parser)
+      msg = "Specify which configuration file you want to use"
+      parser.on("-c", "--config config-file", String, msg) do |conf_file|
+        @options[:config_file] = conf_file
+      end
+
+      msg = "List of file names to exclude"
+      parser.on("-e", "--exclude file,...", Array, msg) do |files|
+        @options[:excluded_files] = files
+      end
+
+      msg = "Pipe source from STDIN, using file in offense reports."
+      parser.on("--stdin-file-path file", String, msg) do |file|
+        @options[:stdin_file_path] = file
+      end
+    end
+
+    # Register informational flags.
+    def add_info_options(parser)
+      parser.on("--show-linters", "Display available linters") do
+        @options[:show_linters] = true
+      end
+
+      parser.on("--show-reporters", "Display available reporters") do
+        @options[:show_reporters] = true
+      end
+
+      parser.on("--[no-]color", "Force output to be colorized") do |color|
+        @options[:color] = color
+      end
+
+      parser.on_tail("-h", "--help", "Display help documentation") do
+        @options[:help] = parser.help
+      end
+
+      parser.on_tail("-v", "--version", "Display version") do
+        @options[:version] = true
+      end
+
+      parser.on_tail("-V", "--verbose-version", "Display verbose version information") do
+        @options[:verbose_version] = true
+      end
+    end
+  end
+end