lint_trappings 0.1.0

data/lib/lint_trappings/command/display_formatters.rb

@@ -0,0 +1,14 @@
+module LintTrappings::Command
+  # Displays all available formatters.
+  class DisplayFormatters < Base
+    def run
+      formatter_names = LintTrappings::Formatter::Base.descendants.map do |formatter_class|
+        formatter_class.name.split('::').last.sub(/Formatter$/, '').downcase
+      end
+
+      formatter_names.sort.each do |formatter_name|
+        output.puts " - #{formatter_name}"
+      end
+    end
+  end
+end

data/lib/lint_trappings/command/display_help.rb

@@ -0,0 +1,8 @@
+module LintTrappings::Command
+  # Outputs help documentation.
+  class DisplayHelp < Base
+    def run
+      output.puts options[:help_message]
+    end
+  end
+end

data/lib/lint_trappings/command/display_linters.rb

@@ -0,0 +1,24 @@
+require 'set'
+
+module LintTrappings::Command
+  # Displays all available linters and whether or not they are enabled.
+  class DisplayLinters < Base
+    def run
+      LintTrappings::LinterLoader.new(application, config).load(options)
+
+      linter_selector = LintTrappings::LinterSelector.new(config, options)
+      all_linter_names = linter_selector.all_linter_classes.map(&:canonical_name)
+      enabled_linter_names = linter_selector.enabled_linter_classes.map(&:canonical_name).to_set
+
+      all_linter_names.sort.each do |linter_name|
+        output.print(' - ')
+        output.bold(linter_name, false)
+        if enabled_linter_names.include?(linter_name)
+          output.success(' enabled')
+        else
+          output.error(' disabled')
+        end
+      end
+    end
+  end
+end

data/lib/lint_trappings/command/display_version.rb

@@ -0,0 +1,14 @@
+module LintTrappings::Command
+  # Outputs application version information.
+  class DisplayVersion < Base
+    def run
+      output.bold(application.executable_name, false)
+      output.info(application.version)
+
+      if options[:verbose]
+        output.bold('Ruby version: ', false)
+        output.info(RUBY_VERSION)
+      end
+    end
+  end
+end

data/lib/lint_trappings/command/scan.rb

@@ -0,0 +1,19 @@
+module LintTrappings::Command
+  # Scan for lints, outputting report of results using the specified formatter.
+  class Scan < Base
+    def run
+      LintTrappings::LinterLoader.new(application, config).load(options)
+
+      runner = LintTrappings::Runner.new(application, config, output)
+      report = runner.run(options)
+
+      if report.failures?
+        raise LintTrappings::ScanFailed,
+              'High severity lints were reported!'
+      elsif report.warnings?
+        raise LintTrappings::ScanWarned,
+              'Warnings were reported.'
+      end
+    end
+  end
+end

data/lib/lint_trappings/configuration.rb

@@ -0,0 +1,94 @@
+require 'forwardable'
+
+module LintTrappings
+  # Stores runtime configuration for the application.
+  class Configuration
+    # The path of this configuration, if it was loaded from a file.
+    #
+    # Used in certain scenarios to determine the absolute path of a file
+    # specified in a configuration (i.e. getting the path relative to the
+    # location of the configuration file itself).
+    #
+    # @return [String]
+    attr_accessor :path
+
+    # Creates a configuration from the given options hash.
+    #
+    # @param options [Hash]
+    def initialize(options = {})
+      @hash = options.dup
+    end
+
+    # Compares this configuration with another.
+    #
+    # @param other [LintTrappings::Configuration]
+    #
+    # @return [true,false] whether the given configuration is equivalent
+    def ==(other)
+      super || @hash == other.hash
+    end
+
+    def fetch(*args, &block)
+      @hash.fetch(*args, &block)
+    end
+
+    def [](key)
+      @hash[key]
+    end
+
+    def delete(key)
+      @hash.delete(key)
+    end
+
+    # Merges the given configuration with this one.
+    #
+    # The provided configuration will either add to or replace any options
+    # defined in this configuration.
+    #
+    # @param config [LintTrappings::Configuration]
+    #
+    # @return [LintTrappings::Configuration]
+    def merge(config)
+      merged_hash = smart_merge(@hash, config.hash)
+      self.class.new(merged_hash)
+    end
+
+    def for_linter(linterish)
+      linter_name =
+        case linterish
+        when Class, LintTrappings::Linter
+          linterish.canonical_name
+        else
+          linterish.to_s
+        end
+
+      conf = @hash.fetch('linters', {}).fetch(linter_name, {}).dup
+      conf['severity'] ||= @hash.fetch('default_severity', :error)
+      conf['severity'] = conf['severity'].to_sym
+      conf
+    end
+
+    protected
+
+    # Internal hash storing the configuration.
+    attr_reader :hash
+
+    private
+
+    # Merge two hashes such that nested hashes are merged rather than replaced.
+    #
+    # @param parent [Hash]
+    # @param child [Hash]
+    # @return [Hash]
+    def smart_merge(parent, child)
+      parent.merge(child) do |_key, old, new|
+        case old
+        when Hash
+          smart_merge(old, new)
+        else
+          new
+        end
+      end
+    end
+  end
+end

data/lib/lint_trappings/configuration_loader.rb

@@ -0,0 +1,98 @@
+require 'pathname'
+require 'yaml'
+
+module LintTrappings
+  # Manages configuration file loading.
+  class ConfigurationLoader
+    def initialize(application)
+      @application = application
+    end
+
+    # Load configuration file given the current working directory the
+    # application is running within.
+    #
+    # @param options [Hash]
+    # @option options :working_directory [String] directory to start searching
+    #   from
+    #
+    # @raise [NoConfigurationFileError] if no configuration file was found
+    #
+    # @return [LintTrappings::Configuration]
+    def load(options = {})
+      config_file_names = @application.configuration_file_names
+      working_directory = options.fetch(:working_directory, Dir.pwd)
+
+      directory = File.expand_path(working_directory)
+      config_file = possible_config_files(config_file_names, directory).find(&:file?)
+
+      if config_file
+        load_file(config_file.to_path)
+      else
+        raise NoConfigurationFileError,
+              "No configuration file #{config_file_names.join('/')} found in " \
+              'working directory or any parent directory'
+      end
+    end
+
+    # Loads a configuration, ensuring it extends the base configuration.
+    #
+    # @param path [String]
+    #
+    # @raise [LintTrappings::ConfigurationParseError] YAML file could not be parsed
+    # @raise [LintTrappings::NoConfigurationFileError] specified file not found
+    #
+    # @return [LintTrappings::Configuration]
+    def load_file(path)
+      load_from_file(path)
+    rescue ::Psych::SyntaxError => error
+      raise ConfigurationParseError,
+            "Unable to parse configuration from '#{file}': #{error}",
+            error.backtrace
+    rescue Errno::ENOENT => error
+      raise NoConfigurationFileError,
+            "Unable to load configuration from '#{file}': #{error}"
+    end
+
+    private
+
+    def configuration_class
+      @application.base_configuration.class
+    end
+
+    # Parses and loads a configuration from the given file.
+    #
+    # @param path [String]
+    #
+    # @return [LintTrappings::Configuration]
+    def load_from_file(path)
+      hash =
+        if yaml = YAML.load_file(path)
+          yaml.to_hash
+        else
+          {}
+        end
+
+      configuration_class.new(hash).tap do |config|
+        config.path = path
+      end
+    end
+
+    # Returns an enumerator for the possible configuration file paths given
+    # the context of the specified working directory.
+    #
+    # @param config_file_name [String]
+    # @param directory [String]
+    #
+    # @return [Array<Pathname>]
+    def possible_config_files(config_file_names, directory)
+      Enumerator.new do |y|
+        Pathname.new(directory)
+                .enum_for(:ascend)
+                .each do |path|
+          config_file_names.each { |config_name| y << (path + config_name) }
+        end
+        config_file_names.each { |config_name| y << Pathname.new(config_name) }
+      end
+    end
+  end
+end

data/lib/lint_trappings/configuration_resolver.rb

@@ -0,0 +1,49 @@
+require 'lint_trappings/linter_plugin'
+
+module LintTrappings
+  # Resolves a configuration to its final representation.
+  #
+  # This does the dirty work of loading and merging a configuration with the
+  # configurations it extends via the `extends` option or `linter_gems` option.
+  class ConfigurationResolver
+    # @param loader [LintTrappings::ConfigurationLoader]
+    def initialize(loader)
+      @loader = loader
+    end
+
+    # Resolves the given configuration, returning a configuration with all
+    # external configuration files merged into one {Configuration}.
+    #
+    # @param conf [LintTrappings::Configuration]
+    def resolve(conf, options)
+      configs_to_extend = Array(conf.delete('extends')).map do |extend_path|
+        # If the path is relative, expand it relative to the path of this config
+        config_path = File.expand_path(extend_path, conf.path)
+
+        # Recursively resolve this configuration (it may have `extends` of its own)
+        resolve(@loader.load_file(config_path))
+      end
+
+      # Load any configurations included by plugins
+      require_paths = Array(conf.delete('linter_plugins')) + options.fetch(:linter_plugins, [])
+      configs_to_extend += require_paths.map do |require_path|
+        plugin = LinterPlugin.new(require_path)
+        plugin.load
+        resolve(@loader.load_file(plugin.config_file_path))
+      end
+
+      conf = extend_configs(configs_to_extend, conf) if configs_to_extend.any?
+      conf
+    end
+
+    private
+
+    # Extend the given configurations with the specified config, merging into a
+    # single config.
+    def extend_configs(configs_to_extend, config)
+      configs_to_extend[1..-1].inject(configs_to_extend.first) do |merged, config_to_extend|
+        merged.merge(config_to_extend)
+      end.merge(config)
+    end
+  end
+end

data/lib/lint_trappings/document.rb

@@ -0,0 +1,45 @@
+module LintTrappings
+  # Represents a parsed document and its associated metadata.
+  #
+  # Implementors should implement the {#process_source} method.
+  #
+  # @abstract
+  class Document
+    # @return [LintTrappings::Configuration] configuration used to parse template
+    attr_reader :config
+
+    # @return [String, nil] path of the file that was parsed, or nil if it was
+    #   parsed directory from a string
+    attr_reader :path
+
+    # @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] Source code to parse
+    # @param config [LintTrappings::Configuration]
+    # @param options [Hash]
+    # @option options :path [String] path of document that was parsed
+    def initialize(source, config, options = {})
+      @config = config
+      @path = options[:path]
+      @source = source
+      @source_lines = @source.split("\n")
+
+      process_source(source)
+    end
+
+    private
+
+    # Processes the source code of the document, initializing the document.
+    #
+    # @raise [LintTrappings::ParseError] if there was a problem parsing the document
+    def process_source(_source)
+      raise NotImplementedError, 'Must implement #process_source'
+    end
+  end
+end

data/lib/lint_trappings/errors.rb

@@ -0,0 +1,127 @@
+# Collection of errors that can be raised by the framework.
+module LintTrappings
+  # Abstract error. Separates LintTrappings errors from other kinds of
+  # errors in the exception hierarchy.
+  #
+  # @abstract
+  class LintTrappingsError < StandardError
+    # Returns the status code that should be output if this error goes
+    # unhandled.
+    #
+    # Ideally these should resemble exit codes from the sysexits documentation
+    # where it makes sense.
+    def self.exit_status(*args)
+      if args.any?
+        @exit_status = args.first
+      else
+        if @exit_status
+          @exit_status
+        else
+          ancestors[1..-1].each do |ancestor|
+            return 70 if ancestor == LintTrappingsError # No exit status defined
+            return ancestor.exit_status if ancestor.exit_status
+          end
+        end
+      end
+    end
+
+    def exit_status
+      self.class.exit_status
+    end
+  end
+
+  # Superclass of all configuration-related errors.
+  # @abstract
+  class ConfigurationError < LintTrappingsError
+    exit_status 78 # EX_CONFIG
+  end
+
+  # Raised when a LintTrappings::Application subclass does not set a value for a
+  # required configuration attribute.
+  class ApplicationConfigurationError < ConfigurationError; end
+
+  # Raised when a configuration file could not be parsed.
+  class ConfigurationParseError < ConfigurationError; end
+
+  # Raised when configuration file was not found.
+  class NoConfigurationFileError < ConfigurationError; end
+
+  # Raised when a linter's configuration does not match its specification.
+  class LinterConfigurationError < ConfigurationError; end
+
+  # Superclass of all usage-related errors
+  # @abstract
+  class UsageError < LintTrappingsError
+    exit_status 64 # EX_USAGE
+  end
+
+  # Raised when there was a problem loading a formatter.
+  class FormatterLoadError < UsageError; end
+
+  # Raised when invalid/incompatible command line options are specified.
+  class InvalidCliOptionError < UsageError; end
+
+  # Raised when invalid command was specified.
+  class InvalidCommandError < UsageError; end
+
+  # Raised when an invalid file path is specified.
+  class InvalidFilePathError < UsageError; end
+
+  # Raised when an invalid file glob pattern is specified.
+  class InvalidFilePatternError < UsageError; end
+
+  # Raised when an invalid option specification is specified for a linter.
+  class InvalidOptionSpecificationError < ConfigurationError; end
+
+  # Raised when a linter raises an unexpected error.
+  class LinterError < LintTrappingsError; end
+
+  # Raised when an error occurs loading a linter file.
+  class LinterLoadError < ConfigurationError; end
+
+  # Raised when an external preprocessor command returns a non-zero exit status.
+  class PreprocessorError < LintTrappingsError
+    exit_status 84
+  end
+
+  # Raised when a report contains lints which qualify as warnings, but does not
+  # contain failures.
+  class ScanWarned < LintTrappingsError
+    exit_status 0 # Don't fail for warnings
+  end
+
+  # Raised when a report contains lints which qualify as failures.
+  class ScanFailed < LintTrappingsError
+    exit_status 2
+  end
+
+  # Raised when running with options that would result in no linters being
+  # enabled.
+  class NoLintersError < ConfigurationError; end
+
+  # Raised when there was a problem parsing a document.
+  class ParseError < LintTrappingsError
+    # @return [String] path to the file that failed to parse
+    attr_reader :path
+
+    # @return [Range<LintTrappings::Location>] source range of the parse error
+    attr_reader :source_range
+
+    def initialize(options)
+      @message = options[:message]
+      @path = options[:path]
+
+      if @source_range = options[:source_range]
+        @line = @source_range.begin.line
+        @column = @source_range.begin.column
+      end
+    end
+
+    def message
+      msg = @message
+      msg << " on line #{@line}" if @line
+      msg << ", column #{@column}" if @column
+      msg
+    end
+  end
+end