lint_trappings 0.1.0

data/lib/lint_trappings/spec.rb

@@ -0,0 +1,12 @@
+require 'lint_trappings'
+
+# Stub declaration so nested modules can reference it
+module LintTrappings::Spec; end
+
+Dir[File.join(File.dirname(__FILE__), 'spec', '**', '*.rb')].each do |file|
+  require file
+end
+
+RSpec.configure do |config|
+  config.include LintTrappings::Matchers
+end

data/lib/lint_trappings/spec/directory_helpers.rb

@@ -0,0 +1,22 @@
+require 'tmpdir'
+
+# Helpers for creating temporary directories for testing.
+module LintTrappings::Spec::DirectoryHelpers
+  module_function
+
+  # Creates a directory in a temporary directory which will automatically be
+  # destroyed at the end of the spec run. Any block passed to this will be
+  # executed with the created directory as the working directory.
+  #
+  # @return [String] The full path of the directory.
+  def directory(name = 'some-dir', &block)
+    tmpdir = Dir.mktmpdir.tap do |path|
+      Dir.chdir(path) do
+        Dir.mkdir(name)
+        Dir.chdir(name, &block) if block_given?
+      end
+    end
+
+    File.join(tmpdir, name)
+  end
+end

data/lib/lint_trappings/spec/indentation_helpers.rb

@@ -0,0 +1,7 @@
+module LintTrappings::Spec::IndentationHelpers
+  # Strips off excess leading indentation from each line so we can use Heredocs
+  # for writing code without having the leading indentation count.
+  def normalize_indent(code)
+    LintTrappings::Utils.normalize_indent(code)
+  end
+end

data/lib/lint_trappings/spec/matchers/report_lint_matcher.rb

@@ -0,0 +1,169 @@
+# rubocop:disable Metrics/ClassLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength, Metrics/LineLength
+
+module LintTrappings::Matchers
+  # RSpec matcher that returns whether or not a linter reported lints matching
+  # the specified criteria.
+  #
+  # @example
+  #
+  #   it { should report_lint line: 2 }
+  class ReportLintMatcher
+    ALLOWED_KEYWORD_ARGUMENTS = %i[line message]
+
+    def initialize(*args, **kwargs)
+      @options = kwargs
+
+      if args.any?
+        raise ArgumentError,
+              '`report_lint` was given more than one argument!' if args.length > 1
+
+        if @options[:line]
+          raise ArgumentError,
+                '`line` keyword argument cannot be specified when Range is given'
+        end
+
+        @range = args.first
+        if @range.is_a?(Array)
+          if @range.length != 2 ||
+             !@range.first.is_a?(Integer) ||
+             !@range.last.is_a?(Integer)
+            raise ArgumentError,
+                  'Location tuple must be an Array of two integers ' \
+                  "representing line and column, but was #{@range.inspect}"
+          end
+
+          # Convert to an actual range by assuming it spans nothing
+          @range = @range..@range
+        elsif !@range.is_a?(Range)
+          raise ArgumentError, '`report_lint` must be given a Range e.g. [1, 2]..[3, 4]'
+        elsif !(@range.begin.is_a?(Array) && @range.end.is_a?(Array))
+          raise ArgumentError, 'Source range must have Array tuple endpoints'
+        end
+      else
+        # Otherwise no explicit range was specified, so verify the options
+        @options.keys.each do |key|
+          raise ArgumentError,
+                "Unknown keyword argument #{key}" unless ALLOWED_KEYWORD_ARGUMENTS.include?(key)
+        end
+
+        @line = @options[:line]
+      end
+
+      @message = @options[:message] if @options[:message]
+    end
+
+    def matches?(linter)
+      # We're cheating by accessing private values here, but it will allow us to
+      # present more-helpful error messages since we get access to so much more
+      # information by passing the linter instead of just a list of lints.
+      @linter = linter
+      @lints = linter.instance_variable_get(:@lints)
+
+      any_lint_matches?
+    end
+
+    def failure_message
+      output = 'expected that a lint would be reported'
+
+      if !any_range_matches?
+        output <<
+          if @line
+            " on line #{@line}"
+          elsif @range
+            " on #{range_to_str(@range)}"
+          end.to_s
+
+        output <<
+          case @lints.count
+          when 0
+            ', but none were'
+          when 1
+            if @line
+              ", but was reported on line #{@lints.first.source_range.begin.line}"
+            elsif @range
+              ", but was reported on #{range_to_str(@lints.first.source_range)}"
+            end.to_s
+          else
+            if @line
+              ", but lints were reported on the following lines instead:\n" +
+                @lints.map { |lint| lint.source_range.line }.sort.join(', ')
+            elsif @range
+              ", but lints were reported on the following ranges instead:\n" +
+                @lints.map { |lint| range_to_str(lint.source_range) }.join("\n")
+            end.to_s
+          end
+      elsif @message
+        matching_lints = lints_matching_range
+        output <<
+          if @message.is_a?(Regexp)
+            " with message matching pattern #{@message.inspect} "
+          else
+            " with message #{@message.inspect} "
+          end
+
+        output << "but got:\n" << matching_lints.map(&:message).join("\n")
+      end
+
+      output
+    end
+
+    def failure_message_when_negated
+      'expected that a lint would NOT be reported'
+    end
+
+    def description
+      output = 'report a lint'
+      output <<
+        if @line
+          " on line #{@line}"
+        elsif @range
+          " on #{range_to_str(@range)}"
+        end.to_s
+
+      output
+    end
+
+    private
+
+    def lints_matching_range
+      @lints.select { |lint| range_matches?(lint) }
+    end
+
+    def any_lint_matches?
+      return true if !@line && !@range && @lints.any?
+      lints_matching_range.any? { |lint| message_matches?(lint) }
+    end
+
+    def any_range_matches?
+      @lints.any? do |lint|
+        range_matches?(lint)
+      end
+    end
+
+    def range_matches?(lint)
+      if @line
+        lint.source_range.begin.line == @line
+      else
+        lint.source_range == @range
+      end
+    end
+
+    def message_matches?(lint)
+      if @message.nil?
+        true
+      elsif @message.is_a?(Regexp)
+        lint.message =~ @message
+      elsif @message.is_a?(String)
+        lint.message == @message
+      end
+    end
+
+    def range_to_str(range)
+      "(L#{range.begin.line},C#{range.begin.column})..(L#{range.end.line},C#{range.end.column})"
+    end
+  end
+
+  def report_lint(*args, **kwargs)
+    ReportLintMatcher.new(*args, **kwargs)
+  end
+end

data/lib/lint_trappings/spec/shared_contexts/linter_shared_context.rb

@@ -0,0 +1,35 @@
+# Makes writing tests for linters a lot DRYer by taking any `src` variable
+# defined via `let` and normalizing it (removing indentation that would be
+# inserted by using Heredocs) and setting up the subject to be the lints
+# returned by Linter#run.
+#
+# Thus a typical test will look like:
+#
+# @example
+#   require 'spec_helper'
+#
+#   RSpec.describe MyApp::Linter::MyLinter do
+#     include_context 'linter'
+#
+#     context 'when source contains "foo"' do
+#       let(:src) { <<-SRC }
+#         This is some code
+#         with the word "foo" in it.
+#       SRC
+#
+#       it { should report_lint line: 2 }
+#     end
+#   end
+shared_context 'linter' do
+  let(:config) do
+    LINT_TRAP_APPLICATION_CLASS.base_configuration.for_linter(described_class)
+  end
+
+  subject do
+    linter = described_class.new(config)
+    document = LINT_TRAP_APPLICATION_CLASS.document_class
+                                          .new(normalize_indent(src), config)
+    linter.run(document)
+    linter
+  end
+end

data/lib/lint_trappings/utils.rb

@@ -0,0 +1,123 @@
+module LintTrappings
+  # Miscellaneus collection of helper functions.
+  module Utils
+    module_function
+
+    # Returns whether a glob pattern (or any of a list of patterns) matches the
+    # specified file.
+    #
+    # This is defined here so our file globbing options are consistent
+    # everywhere we perform globbing.
+    #
+    # @param glob [String, Array]
+    # @param file [String]
+    # @return [Boolean]
+    def any_glob_matches?(globs_or_glob, file)
+      Array(globs_or_glob).any? do |glob|
+        ::File.fnmatch?(glob, file,
+                        ::File::FNM_PATHNAME | # Wildcards don't match path separators
+                        ::File::FNM_DOTMATCH)  # `*` wildcard matches dotfiles
+      end
+    end
+
+    # Find all consecutive items satisfying the given block of a minimum size,
+    # yielding each group of consecutive items to the provided block.
+    #
+    # @param items [Array]
+    # @param satisfies [Proc] function that takes an item and returns true/false
+    # @param min_consecutive [Fixnum] minimum number of consecutive items before
+    #   yielding the group
+    # @yield Passes list of consecutive items all matching the criteria defined
+    #   by the `satisfies` {Proc} to the provided block
+    # @yieldparam group [Array] List of consecutive items
+    # @yieldreturn [Boolean] block should return whether item matches criteria
+    #   for inclusion
+    def for_consecutive_items(items, satisfies, min_consecutive = 2)
+      current_index = -1
+
+      while (current_index += 1) < items.count
+        next unless satisfies[items[current_index]]
+
+        count = count_consecutive(items, current_index, &satisfies)
+        next unless count >= min_consecutive
+
+        # Yield the chunk of consecutive items
+        yield items[current_index...(current_index + count)]
+
+        current_index += count # Skip this patch of consecutive items to find more
+      end
+    end
+
+    # Count the number of consecutive items satisfying the given {Proc}.
+    #
+    # @param items [Array]
+    # @param offset [Fixnum] index to start searching from
+    # @yield [item] Passes item to the provided block.
+    # @yieldparam item [Object] Item to evaluate as matching criteria for
+    #   inclusion
+    # @yieldreturn [Boolean] whether to include the item
+    # @return [Integer]
+    def count_consecutive(items, offset = 0, &block)
+      count = 1
+      count += 1 while (offset + count < items.count) && block.call(items[offset + count])
+      count
+    end
+
+    # Convert a class name or CamelCase string into snake_case.
+    #
+    # @see stackoverflow.com/questions/1509915/converting-camel-case-to-underscore-case-in-ruby
+    #
+    # @param str [String]
+    #
+    # @return [String]
+    def snake_case(str)
+      str.gsub(/::/, '/')
+         .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+         .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+         .tr('-', '_')
+         .downcase
+    end
+
+    # Converts a string containing underscores/hyphens/spaces into CamelCase.
+    #
+    # @param str [String]
+    #
+    # @return [String]
+    def camel_case(str)
+      str.split(/_|-| /).map { |part| part.sub(/^\w/, &:upcase) }.join
+    end
+
+    # Returns the plural of the word if necessary based on the given count.
+    #
+    # @param word [String]
+    # @param count [Integer]
+    #
+    # @return [String]
+    def pluralize(word, count)
+      count == 1 ? word : "#{word}s"
+    end
+
+    # Strips off excess leading indentation from each line so we can use Heredocs
+    # for writing code without having the leading indentation count.
+    def normalize_indent(code)
+      leading_indent = code[/^(\s*)/, 1]
+      code.lstrip.gsub(/\n#{leading_indent}/, "\n")
+    end
+
+    # Calls a block of code with a modified set of environment variables,
+    # restoring them once the code has executed.
+    #
+    # @param env [Hash] environment variables to set
+    def with_environment(env)
+      old_env = {}
+      env.each do |var, value|
+        old_env[var] = ENV[var.to_s]
+        ENV[var.to_s] = value
+      end
+
+      yield
+    ensure
+      old_env.each { |var, value| ENV[var.to_s] = value }
+    end
+  end
+end

data/lib/lint_trappings/version.rb

@@ -0,0 +1,4 @@
+# Defines the gem version.
+module LintTrappings
+  VERSION = '0.1.0'
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: lint_trappings
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Shane da Silva
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-02-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parallel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: terminal-table
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+description: Framework for writing static analysis tools (a.k.a. linters)
+email:
+- shane@dasilva.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.md
+- lib/lint_trappings.rb
+- lib/lint_trappings/application.rb
+- lib/lint_trappings/arguments_parser.rb
+- lib/lint_trappings/cli.rb
+- lib/lint_trappings/command/base.rb
+- lib/lint_trappings/command/display_documentation.rb
+- lib/lint_trappings/command/display_formatters.rb
+- lib/lint_trappings/command/display_help.rb
+- lib/lint_trappings/command/display_linters.rb
+- lib/lint_trappings/command/display_version.rb
+- lib/lint_trappings/command/scan.rb
+- lib/lint_trappings/configuration.rb
+- lib/lint_trappings/configuration_loader.rb
+- lib/lint_trappings/configuration_resolver.rb
+- lib/lint_trappings/document.rb
+- lib/lint_trappings/errors.rb
+- lib/lint_trappings/executable.rb
+- lib/lint_trappings/file_finder.rb
+- lib/lint_trappings/formatter/base.rb
+- lib/lint_trappings/formatter/checkstyle.rb
+- lib/lint_trappings/formatter/default.rb
+- lib/lint_trappings/formatter/json.rb
+- lib/lint_trappings/formatter_forwarder.rb
+- lib/lint_trappings/formatter_loader.rb
+- lib/lint_trappings/lint.rb
+- lib/lint_trappings/linter.rb
+- lib/lint_trappings/linter_configuration_validator.rb
+- lib/lint_trappings/linter_loader.rb
+- lib/lint_trappings/linter_plugin.rb
+- lib/lint_trappings/linter_selector.rb
+- lib/lint_trappings/location.rb
+- lib/lint_trappings/output.rb
+- lib/lint_trappings/preprocessor.rb
+- lib/lint_trappings/rake_task.rb
+- lib/lint_trappings/report.rb
+- lib/lint_trappings/runner.rb
+- lib/lint_trappings/spec.rb
+- lib/lint_trappings/spec/directory_helpers.rb
+- lib/lint_trappings/spec/indentation_helpers.rb
+- lib/lint_trappings/spec/matchers/report_lint_matcher.rb
+- lib/lint_trappings/spec/shared_contexts/linter_shared_context.rb
+- lib/lint_trappings/utils.rb
+- lib/lint_trappings/version.rb
+homepage: https://github.com/sds/lint-trappings
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Linter framework
+test_files: []
+has_rdoc: