slim_lint 0.1.0

data/lib/slim_lint/linter/rubocop.rb

@@ -0,0 +1,73 @@
+require 'slim_lint/ruby_extractor'
+require 'slim_lint/ruby_extract_engine'
+require 'rubocop'
+require 'tempfile'
+
+module SlimLint
+  # Runs RuboCop on Ruby code extracted from Slim templates.
+  class Linter::RuboCop < Linter
+    include LinterRegistry
+
+    on_start do |_sexp|
+      processed_sexp = SlimLint::RubyExtractEngine.new.call(document.source)
+
+      extractor = SlimLint::RubyExtractor.new
+      extracted_ruby = extractor.extract(processed_sexp)
+
+      find_lints(extractor, extracted_ruby) unless extracted_ruby.empty?
+    end
+
+    private
+
+    def find_lints(extractor, ruby)
+      rubocop = ::RuboCop::CLI.new
+
+      original_filename = document.file || 'ruby_script'
+      filename = "#{File.basename(original_filename)}.slim_lint.tmp"
+      directory = File.dirname(original_filename)
+
+      Tempfile.open(filename, directory) do |f|
+        begin
+          f.write(ruby)
+          f.close
+          extract_lints_from_offences(lint_file(rubocop, f.path), extractor)
+        ensure
+          f.unlink
+        end
+      end
+    end
+
+    # Defined so we can stub the results in tests
+    def lint_file(rubocop, file)
+      rubocop.run(%w[--format SlimLint::OffenceCollector] << file)
+      OffenceCollector.offences
+    end
+
+    def extract_lints_from_offences(offences, extractor)
+      offences.select { |offence| !config['ignored_cops'].include?(offence.cop_name) }
+              .each do |offence|
+        @lints << Lint.new(self,
+                           document.file,
+                           extractor.source_map[offence.line],
+                           "#{offence.cop_name}: #{offence.message}")
+      end
+    end
+  end
+
+  # Collects offences detected by RuboCop.
+  class OffenceCollector < ::RuboCop::Formatter::BaseFormatter
+    attr_accessor :offences
+
+    class << self
+      attr_accessor :offences
+    end
+
+    def started(_target_files)
+      self.class.offences = []
+    end
+
+    def file_finished(_file, offences)
+      self.class.offences += offences
+    end
+  end
+end

data/lib/slim_lint/linter/trailing_whitespace.rb

@@ -0,0 +1,17 @@
+module SlimLint
+  # Checks for trailing whitespace.
+  class Linter::TrailingWhitespace < Linter
+    include LinterRegistry
+
+    on_start do |_sexp|
+      dummy_node = Struct.new(:line)
+
+      document.source_lines.each_with_index do |line, index|
+        next unless line =~ /\s+$/
+
+        report_lint(dummy_node.new(index + 1),
+                    'Line contains trailing whitespace')
+      end
+    end
+  end
+end

data/lib/slim_lint/linter.rb

@@ -0,0 +1,49 @@
+module SlimLint
+  # Base implementation for all lint checks.
+  class Linter
+    # Include definitions for Sexp pattern-matching helpers.
+    include SexpVisitor
+    extend SexpVisitor::DSL
+
+    # TODO: Remove once spec support returns an array of lints instead of a
+    # linter
+    attr_reader :lints
+
+    # @param config [Hash] configuration for this linter
+    def initialize(config)
+      @config = config
+      @lints = []
+      @ruby_parser = nil
+    end
+
+    # Runs the linter against the specified Sexp
+    def run(document)
+      @document = document
+      @lints = []
+      trigger_pattern_callbacks(document.sexp)
+      @lints
+    end
+
+    # Returns the simple name for this linter.
+    def name
+      self.class.name.split('::').last
+    end
+
+    private
+
+    attr_reader :config, :document
+
+    # Record a lint for reporting back to the user.
+    def report_lint(sexp, message)
+      @lints << SlimLint::Lint.new(self, @document.file, sexp.line, message)
+    end
+
+    # Parse Ruby code into an abstract syntax tree.
+    #
+    # @return [AST::Node]
+    def parse_ruby(source)
+      @ruby_parser ||= SlimLint::RubyParser.new
+      @ruby_parser.parse(source)
+    end
+  end
+end

data/lib/slim_lint/linter_registry.rb

@@ -0,0 +1,26 @@
+module SlimLint
+  class NoSuchLinter < StandardError; end
+
+  # Stores all defined linters.
+  module LinterRegistry
+    @linters = []
+
+    class << self
+      attr_reader :linters
+
+      def included(base)
+        @linters << base
+      end
+
+      def extract_linters_from(linter_names)
+        linter_names.map do |linter_name|
+          begin
+            SlimLint::Linter.const_get(linter_name)
+          rescue NameError
+            raise NoSuchLinter, "Linter #{linter_name} does not exist"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/slim_lint/logger.rb

@@ -0,0 +1,107 @@
+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
+    # @return [nil]
+    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>]
+    # @return [nil]
+    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>]
+    # @return [nil]
+    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>]
+    # @return [nil]
+    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>]
+    # @return [nil]
+    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>]
+    # @return [nil]
+    def warning(*args)
+      color(33, *args)
+    end
+
+    # Print specified output in bold face in a color indicative of a warning.
+    # If output destination is not a TTY, behaves the same as {#log}.
+    #
+    # @param args [Array<String>]
+    # @return [nil]
+    def bold_warning(*args)
+      color('1;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>]
+    # @return [nil]
+    def info(*args)
+      color(36, *args)
+    end
+
+    # Whether this logger is outputting to a TTY.
+    #
+    # @return [true,false]
+    def tty?
+      @out.respond_to?(:tty?) && @out.tty?
+    end
+
+    private
+
+    def color(code, output, newline = true)
+      log(color_enabled ? "\033[#{code}m#{output}\033[0m" : output, newline)
+    end
+  end
+end

data/lib/slim_lint/options.rb

@@ -0,0 +1,89 @@
+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 => ex
+      raise Exceptions::InvalidCLIOption,
+            ex.message,
+            ex.backtrace
+    end
+
+    private
+
+    def add_linter_options(parser)
+      parser.on('-e', '--exclude file,...', Array,
+                'List of file names to exclude') do |files|
+        @options[:excluded_files] = files
+      end
+
+      parser.on('-i', '--include-linter linter,...', Array,
+                'Specify which linters you want to run') do |linters|
+        @options[:included_linters] = linters
+      end
+
+      parser.on('-x', '--exclude-linter linter,...', Array,
+                "Specify which linters you don't want to run") do |linters|
+        @options[:excluded_linters] = linters
+      end
+
+      parser.on('-r', '--reporter reporter', String,
+                'Specify which reporter you want to use to generate the output') do |reporter|
+        @options[:reporter] = SlimLint::Reporter.const_get("#{reporter.capitalize}Reporter")
+      end
+    end
+
+    def add_file_options(parser)
+      parser.on('-c', '--config config-file', String,
+                'Specify which configuration file you want to use') do |conf_file|
+        @options[:config_file] = conf_file
+      end
+
+      parser.on('-e', '--exclude file,...', Array,
+                'List of file names to exclude') do |files|
+        @options[:excluded_files] = files
+      end
+    end
+
+    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
+    end
+  end
+end

data/lib/slim_lint/rake_task.rb

@@ -0,0 +1,107 @@
+require 'rake'
+require 'rake/tasklib'
+
+module SlimLint
+  # Rake task interface for slim-lint command line interface.
+  #
+  # @example
+  #   # Add the following to your Rakefile...
+  #   require 'slim_lint/rake_task'
+  #
+  #   SlimLint::RakeTask.new do |t|
+  #     t.config = 'path/to/custom/slim-lint.yml'
+  #     t.files = %w[app/views/**/*.slim custom/*.slim]
+  #     t.quiet = true # Don't display output from slim-lint
+  #   end
+  #
+  #   # ...and then execute from the command line:
+  #   rake slim_lint
+  #
+  # You can also specify the list of files as explicit task arguments:
+  #
+  # @example
+  #   # Add the following to your Rakefile...
+  #   require 'slim_lint/rake_task'
+  #
+  #   SlimLint::RakeTask.new
+  #
+  #   # ...and then execute from the command line (single quotes prevent shell
+  #   # glob expansion and allow us to have a space after commas):
+  #   rake 'slim_lint[app/views/**/*.slim, other_files/**/*.slim]'
+  #
+  class RakeTask < Rake::TaskLib
+    # Name of the task.
+    # @return [String]
+    attr_accessor :name
+
+    # Configuration file to use.
+    # @return [String]
+    attr_accessor :config
+
+    # List of files to lint (can contain shell globs).
+    #
+    # Note that this will be ignored if you explicitly pass a list of files as
+    # task arguments via the command line or a task definition.
+    # @return [Array<String>]
+    attr_accessor :files
+
+    # Whether output from slim-lint should not be displayed to the standard out
+    # stream.
+    # @return [true,false]
+    attr_accessor :quiet
+
+    # Create the task so it exists in the current namespace.
+    def initialize(name = :slim_lint)
+      @name = name
+      @files = ['.'] # Search for everything under current directory by default
+      @quiet = false
+
+      yield self if block_given?
+
+      define
+    end
+
+    private
+
+    def define
+      desc default_description unless ::Rake.application.last_description
+
+      task(name, [:files]) do |_task, task_args|
+        # Lazy-load so task doesn't affect Rakefile load time
+        require 'slim_lint'
+        require 'slim_lint/cli'
+
+        run_cli(task_args)
+      end
+    end
+
+    def run_cli(task_args)
+      cli_args = ['--config', config] if config
+
+      logger = quiet ? SlimLint::Logger.silent : SlimLint::Logger.new(STDOUT)
+      result = SlimLint::CLI.new(logger).run(Array(cli_args) + files_to_lint(task_args))
+
+      fail "#{SlimLint::APP_NAME} failed with exit code #{result}" unless result == 0
+    end
+
+    def files_to_lint(task_args)
+      # Note: we're abusing Rake's argument handling a bit here. We call the
+      # first argument `files` but it's actually only the first file--we pull
+      # the rest out of the `extras` from the task arguments. This is so we
+      # can specify an arbitrary list of files separated by commas on the
+      # command line or in a custom task definition.
+      explicit_files = Array(task_args[:files]) + Array(task_args.extras)
+
+      explicit_files.any? ? explicit_files : files
+    end
+
+    # Friendly description that shows the full command that will be executed.
+    def default_description
+      description = "Run `#{SlimLint::APP_NAME}"
+      description += " --config #{config}" if config
+      description += " #{files.join(' ')}" if files.any?
+      description += ' [files...]`'
+      description
+    end
+  end
+end

data/lib/slim_lint/report.rb

@@ -0,0 +1,16 @@
+module SlimLint
+  # Contains information about all lints detected during a scan.
+  class Report
+    attr_accessor :lints
+    attr_reader :files
+
+    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/default_reporter.rb

@@ -0,0 +1,39 @@
+module SlimLint
+  # Outputs lints in a simple format with the filename, line number, and lint
+  # message.
+  class Reporter::DefaultReporter < Reporter
+    def report_lints
+      sorted_lints = 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
+    end
+
+    def print_type(lint)
+      if lint.error?
+        log.error ' [E] ', false
+      else
+        log.warning ' [W] ', false
+      end
+    end
+
+    def print_message(lint)
+      if lint.linter
+        log.success("#{lint.linter.name}: ", false)
+      end
+
+      log.log lint.message
+    end
+  end
+end

data/lib/slim_lint/reporter/json_reporter.rb

@@ -0,0 +1,44 @@
+module SlimLint
+  # Outputs report as a JSON document.
+  class Reporter::JsonReporter < Reporter
+    def report_lints
+      grouped = lints.group_by(&:filename)
+
+      report = {
+        metadata: {
+          slim_lint_version: SlimLint::VERSION,
+          ruby_engine:      RUBY_ENGINE,
+          ruby_patchlevel:  RUBY_PATCHLEVEL.to_s,
+          ruby_platform:    RUBY_PLATFORM,
+        },
+        files: grouped.map { |l| map_file(l) },
+        summary: {
+          offense_count: lints.length,
+          target_file_count: grouped.length,
+          inspected_file_count: files.length,
+        },
+      }
+
+      log.log report.to_json
+    end
+
+    private
+
+    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: {
+          line: offense.line,
+        },
+      }
+    end
+  end
+end

data/lib/slim_lint/reporter.rb

@@ -0,0 +1,36 @@
+module SlimLint
+  # Abstract lint reporter. Subclass and override {#report_lints} to
+  # implement a custom lint reporter.
+  #
+  # @abstract
+  class Reporter
+    attr_reader :lints
+    attr_reader :files
+
+    # @param logger [SlimLint::Logger]
+    # @param report [SlimLint::Report]
+    def initialize(logger, report)
+      @log = logger
+      @lints = report.lints
+      @files = report.files
+    end
+
+    # Implemented by subclasses to display lints from a {SlimLint::Report}.
+    def report_lints
+      raise NotImplementedError
+    end
+
+    # Keep tracking all the descendants of this class for the list of available reporters
+    def self.descendants
+      @descendants ||= []
+    end
+
+    def self.inherited(descendant)
+      descendants << descendant
+    end
+
+    private
+
+    attr_reader :log
+  end
+end

data/lib/slim_lint/ruby_extract_engine.rb

@@ -0,0 +1,43 @@
+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
+    define_options sort_attrs: true,
+                   format: :xhtml,
+                   attr_quote: '"',
+                   merge_attrs: { 'class' => ' ' },
+                   default_tag: 'div'
+
+    filter :Encoding
+    filter :RemoveBOM
+
+    # Parse into S-expression using Slim parser
+    use Slim::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 Slim::Embedded
+    use Slim::Interpolation
+    use Slim::Splat::Filter
+    use Slim::DoInserter
+    use Slim::EndInserter
+    use Slim::Controls
+    html :AttributeSorter
+    html :AttributeMerger
+    use Slim::CodeAttributes
+    filter :ControlFlow
+    filter :MultiFlattener
+    filter :StaticMerger
+
+    # Converts Array-based S-expressions into SlimLint::Sexp objects, and gives
+    # them line numbers so we can easily map from the Ruby source to the
+    # original source
+    use SlimLint::Filters::SexpConverter
+    use SlimLint::Filters::InjectLineNumbers
+  end
+end