lint_trappings 0.1.0

data/lib/lint_trappings/location.rb

@@ -0,0 +1,39 @@
+module LintTrappings
+  # Store location of a {Lint} in a document.
+  class Location
+    include Comparable
+
+    attr_reader :line, :column
+
+    # @param line [Integer] One-based index
+    # @param column [Integer] One-based index
+    def initialize(line = 1, column = 1)
+      raise ArgumentError, "Line must be >= 0, but was #{line}" if line < 0
+      raise ArgumentError, "Column must be >= 0, but was #{column}" if column < 0
+
+      @line   = line
+      @column = column
+    end
+
+    def ==(other)
+      [:line, :column].all? do |attr|
+        send(attr) == other.send(attr)
+      end
+    end
+
+    alias eql? ==
+
+    def <=>(other)
+      [:line, :column].each do |attr|
+        result = send(attr) <=> other.send(attr)
+        return result unless result == 0
+      end
+
+      0
+    end
+
+    def to_s
+      "(#{line},#{column})"
+    end
+  end
+end

data/lib/lint_trappings/output.rb

@@ -0,0 +1,118 @@
+module LintTrappings
+  # Encapsulates all communication to an output source.
+  class Output
+    # 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(File::NULL, 'w'))
+    end
+
+    # Creates a new {SlimLint::Logger} instance.
+    #
+    # @param out [IO] the output destination.
+    def initialize(out)
+      @out = out
+      @color_enabled = tty?
+    end
+
+    # Print the specified output.
+    #
+    # @param output [String] the output to send
+    # @param newline [true,false] whether to append a newline
+    def puts(output, newline = true)
+      @out.print(output)
+      @out.print("\n") if newline
+    end
+
+    # Print the specified output without a newline.
+    #
+    # @param output [String] the output to send
+    def print(output)
+      puts(output, false)
+    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 something worthy of
+    # notice.
+    # If output destination is not a TTY, behaves the same as {#log}.
+    #
+    # @param args [Array<String>]
+    def notice(*args)
+      color(35, *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
+      puts('')
+    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)
+      puts(color_enabled ? "\033[#{code}m#{output}\033[0m" : output, newline)
+    end
+  end
+end

data/lib/lint_trappings/preprocessor.rb

@@ -0,0 +1,41 @@
+require 'open3'
+require 'stringio'
+
+module LintTrappings
+  # Processes a collection of streams with the specified command.
+  class Preprocessor
+    def initialize(config)
+      @config = config
+      @command = @config['preprocess_command']
+      @preprocess_files = @config['preprocess_files']
+    end
+
+    def preprocess_files(files_to_lint)
+      return unless @command
+
+      files_to_lint.each do |file_to_lint|
+        preprocess(file_to_lint) if preprocess_file?(file_to_lint.path)
+      end
+    end
+
+    private
+
+    def preprocess(file_to_lint)
+      contents, status = Open3.capture2(@command, stdin_data: file_to_lint.io.read)
+
+      unless status.success?
+        raise PreprocessorError,
+              "Preprocess command `#{@command}` failed when passed the " \
+              "contents of '#{file_to_lint.path}', returning an exit " \
+              "status of #{status.exitstatus}."
+      end
+
+      file_to_lint.io = StringIO.new(contents)
+    end
+
+    def preprocess_file?(file)
+      return true unless @preprocess_files
+      Utils.any_glob_matches?(@preprocess_files, file)
+    end
+  end
+end

data/lib/lint_trappings/rake_task.rb

@@ -0,0 +1,145 @@
+require 'rake'
+require 'rake/tasklib'
+
+module LintTrappings
+  # Rake task interface factory for a LintTrappings application.
+  #
+  # In your application, define your Rake task factory class as:
+  #
+  #   require 'lint_trappings/rake_task'
+  #   require 'my_app'
+  #
+  #   module MyApp
+  #     class RakeTask < LintTrappings::RakeTask
+  #       def initialize(name = :my_app)
+  #         @application_class = MyApp::Application
+  #         super
+  #       end
+  #     end
+  #   end
+  #
+  # Then developers can follow the instructions below (swapping out MyApp/my_app
+  # with the appropriate name of your application) to invoke your application
+  # via Rake.
+  #
+  # @example
+  #   # Add the following to your Rakefile...
+  #   require 'my_app/rake_task'
+  #
+  #   MyApp::RakeTask.new do |t|
+  #     t.config = 'path/to/custom/config.yml'
+  #     t.files = %w[app/views/**/*.txt custom/*.txt]
+  #     t.quiet = true # Don't display output from app
+  #   end
+  #
+  #   # ...and then execute from the command line:
+  #   rake my_app
+  #
+  # You can also specify the list of files as explicit task arguments:
+  #
+  # @example
+  #   # Add the following to your Rakefile...
+  #   require 'my_app/rake_task'
+  #
+  #   MyApp::RakeTask.new
+  #
+  #   # ...and then execute from the command line:
+  #   rake my_app[some/directory, some/specific/file.txt]
+  #
+  class RakeTask < Rake::TaskLib
+    # Name of the task.
+    # @return [String]
+    attr_accessor :name
+
+    # Path of the configuration file to use.
+    # @return [String]
+    attr_accessor :config
+
+    # List of files to lint.
+    #
+    # Note that this will be ignored if you explicitly pass a list of files as
+    # task arguments via the command line.
+    # @return [Array<String>]
+    attr_accessor :files
+
+    # Whether output from application 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.
+    #
+    # @param name [Symbol] task name
+    def initialize(name)
+      @name = name
+      @files = []
+      @quiet = false
+
+      # Allow custom configuration to be defined in a block passed to constructor
+      yield self if block_given?
+
+      define
+    end
+
+    private
+
+    # Defines the Rake task.
+    def define
+      desc default_description unless ::Rake.application.last_description
+
+      task(name, [:files]) do |_task, task_args|
+        run_cli(task_args)
+      end
+    end
+
+    # Executes the CLI given the specified task arguments.
+    #
+    # @param task_args [Rake::TaskArguments]
+    def run_cli(task_args)
+      raise ArgumentError, '@application_class must be defined!' unless @application_class
+
+      output = quiet ? LintTrappings::Output.silent : LintTrappings::Output.new(STDOUT)
+      app = @application_class.new(output)
+
+      options = {}.tap do |opts|
+        opts[:command] = :scan
+        opts[:config_file] = @config if @config
+        opts[:included_paths] = files_to_lint(task_args)
+      end
+
+      begin
+        app.run(options) # Will raise exception on failure
+      rescue LintTrappings::ScanWarned
+        puts "#{app.name} reported warnings"
+      end
+    end
+
+    # Returns the list of files that should be linted given the specified task
+    # arguments.
+    #
+    # @param task_args [Rake::TaskArguments]
+    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 up in Rake task listing.
+    #
+    # This allows us to change the information displayed by `rake --tasks` based
+    # on the options passed to the constructor which defined the task.
+    #
+    # @return [String]
+    def default_description
+      description = "Run `#{@application_class.name}`"
+      description << ' quietly' if @quiet
+      description << " using config file #{@config}" if @config
+      description
+    end
+  end
+end

data/lib/lint_trappings/report.rb

@@ -0,0 +1,58 @@
+module LintTrappings
+  # Contains information about all lints detected during a scan.
+  class Report
+    # List of lints that were found.
+    # @return [Array<LintTrappings::Lint]
+    attr_accessor :lints
+
+    # @return [Array<String>] List of files that were inspected.
+    attr_reader :documents_inspected
+
+    # @param config [LintTrappings::Configuration]
+    # @param lints [Array<LintTrappings::Lint>] lints that were found
+    # @param documents [Array<Document>] files that were linted
+    def initialize(config, lints, documents)
+      @config = config
+      @lints = lints.sort_by { |lint| [lint.path, lint.source_range.begin.line] }
+      @documents_inspected = documents
+    end
+
+    def severities
+      @severities ||= @config.fetch('severities', error: 'fail', warning: 'warn')
+    end
+
+    def fail_severities
+      @fail_severities ||= severities.select { |_severity, action| action == 'fail' }.keys
+    end
+
+    def warn_severities
+      @warn_severities ||= severities.select { |_severity, action| action == 'warn' }.keys
+    end
+
+    def failures?
+      failures.any?
+    end
+
+    def failures
+      @failures ||=
+        begin
+          @lints.select { |lint| fail_severities.include?(lint.severity) }
+        end
+    end
+
+    def warnings?
+      warnings.any?
+    end
+
+    def warnings
+      @warnings ||=
+        begin
+          @lints.select { |lint| warn_severities.include?(lint.severity) }
+        end
+    end
+
+    def success?
+      lints.empty?
+    end
+  end
+end

data/lib/lint_trappings/runner.rb

@@ -0,0 +1,161 @@
+require 'lint_trappings/formatter_forwarder'
+require 'lint_trappings/formatter_loader'
+require 'lint_trappings/preprocessor'
+
+module LintTrappings
+  # Linter runner.
+  #
+  # Runs linters against a set of files, ensuring the appropriate linters are
+  # run against the relevant files based on configuration.
+  class Runner
+    def initialize(application, config, output)
+      @application = application
+      @config = config
+      @output = output
+    end
+
+    # A individual unit of work which can be processed by a worker.
+    Job = Struct.new(:linter, :path)
+
+    # Runs the appropriate linters against the set of specified files, return a
+    # report of all lints found.
+    #
+    # @param options [Hash]
+    #
+    # @return [LintTrappings::Report] report of all lints found and other statistics
+    def run(options = {})
+      @options = options
+
+      # Coalesce formatters into a single formatter which will forward calls
+      formatters = FormatterLoader.new(@application, @config, @output).load(options)
+      @formatter = FormatterForwarder.new(formatters)
+
+      # We store the documents in a map so that if we're parallelizing the run
+      # we don't need to pass serialized Document objects via IPC, just the path
+      # string.  Since forking will use copy-on-write semantics, we'll be able
+      # to reuse the memory storing those documents for all workers, since we're
+      # just reading.
+      @paths_to_documents_map, parse_lints = load_documents_to_lint(options)
+
+      # Extract all jobs we want to run as file/linter pairs
+      linter_selector = LinterSelector.new(@application, @config, options)
+      jobs = @paths_to_documents_map.keys.map do |path|
+        linter_selector.linters_for_file(path).map { |linter| Job.new(linter, path) }
+      end.flatten
+
+      lints = find_all_lints(jobs) + parse_lints
+      report = Report.new(@config, lints, @paths_to_documents_map.values)
+
+      @formatter.finished(report)
+
+      report
+    end
+
+    private
+
+    # A file to be linted.
+    FileToLint = Struct.new(:io, :path)
+
+    def determine_files_to_lint(options)
+      if options[:stdin_file_path]
+        [FileToLint.new(options[:stdin], options[:stdin_file_path])]
+      else
+        find_files(options).map do |path|
+          FileToLint.new(File.open(path), path)
+        end
+      end
+    rescue Errno::ENOENT => err
+      raise InvalidFilePathError, err.message
+    end
+
+    def find_files(options)
+      opts = {}
+      opts[:allowed_extensions] = @config.fetch(:file_extensions, @application.file_extensions)
+
+      opts[:included_paths] = options.fetch(:included_paths, @config.fetch(:included_paths, []))
+      opts[:excluded_paths] = @config.fetch(:excluded_paths, []) +
+                              options.fetch(:excluded_paths, [])
+
+      opts[:included_patterns] = @config.fetch(:include) do
+        if opts[:included_paths].any?
+          # Don't specify default inclusion pattern since include paths were
+          # explicitly specified
+          []
+        else
+          # Otherwise, we want the default behavior to lint all files with the
+          # default file extensions
+          opts[:allowed_extensions].map { |ext| "**/*.#{ext}" }
+        end
+      end
+      opts[:excluded_patterns] = @config.fetch(:exclude, [])
+
+      FileFinder.find(opts)
+    end
+
+    def load_documents_to_lint(options)
+      documents = {}
+      parse_lints = []
+
+      files_to_lint = determine_files_to_lint(options)
+      Preprocessor.new(@config).preprocess_files(files_to_lint)
+      @formatter.started(files_to_lint)
+
+      files_to_lint.each do |file_to_lint|
+        begin
+          documents[file_to_lint.path] =
+            @application.document_class.new(file_to_lint.io.read,
+                                            @config,
+                                            path: file_to_lint.path)
+        rescue ParseError => err
+          parse_lints << Lint.new(
+            path: file_to_lint.path,
+            source_range: err.source_range,
+            message: "Error occurred while parsing #{file_to_lint.path}: #{err.message}",
+            severity: :error,
+          )
+        end
+      end
+
+      [documents, parse_lints]
+    end
+
+    def scan_document(job)
+      @formatter.job_started(job)
+
+      document = @paths_to_documents_map[job.path]
+      reported_lints = job.linter.run(document)
+
+      @formatter.job_finished(job, reported_lints)
+
+      reported_lints
+    rescue => err
+      loc = Location.new(1)
+      message = "Error occurred while linting #{job.path}: #{err.message}"
+
+      lints = [Lint.new(
+        linter: job.linter,
+        path: job.path,
+        source_range: loc..loc,
+        message: message,
+        severity: :error,
+        exception: err,
+      )]
+
+      @formatter.job_finished(job, lints)
+      lints
+    end
+
+    def find_all_lints(jobs)
+      lints =
+        if workers = @options[:concurrency]
+          require 'parallel'
+          workers = workers == 'auto' ? Parallel.processor_count : Integer(workers)
+          ::Parallel.map(jobs, { in_processes: workers }, &method(:scan_document))
+        else
+          jobs.map(&method(:scan_document))
+        end
+
+      lints.flatten
+    end
+  end
+end