lintrunner 0.0.1

data/.scss-lint.yml

@@ -0,0 +1,191 @@
+# Default application configuration that all configurations inherit from.
+
+scss_files: "**/*.scss"
+
+linters:
+  BangFormat:
+    enabled: true
+    space_before_bang: true
+    space_after_bang: false
+
+  BorderZero:
+    enabled: true
+    convention: none
+
+  ColorKeyword:
+    enabled: true
+
+  ColorVariable:
+    enabled: true
+
+  Comment:
+    enabled: true
+
+  DebugStatement:
+    enabled: true
+
+  DeclarationOrder:
+    enabled: false
+
+  DuplicateProperty:
+    enabled: false
+
+  ElsePlacement:
+    enabled: true
+    style: same_line
+
+  EmptyLineBetweenBlocks:
+    enabled: true
+    ignore_single_line_blocks: false
+
+  EmptyRule:
+    enabled: true
+
+  FinalNewline:
+    enabled: true
+    present: true
+
+  HexLength:
+    enabled: true
+    style: long
+
+  HexNotation:
+    enabled: true
+    style: lowercase
+
+  HexValidation:
+    enabled: true
+
+  IdSelector:
+    enabled: false
+
+  ImportantRule:
+    enabled: true
+
+  ImportPath:
+    enabled: true
+    leading_underscore: false
+    filename_extension: false
+
+  Indentation:
+    enabled: true
+    allow_non_nested_indentation: false
+    character: space
+    width: 2
+
+  LeadingZero:
+    enabled: false
+    style: exclude_zero
+
+  MergeableSelector:
+    enabled: true
+    force_nesting: false
+
+  NameFormat:
+    enabled: true
+    allow_leading_underscore: true
+    convention: hyphenated_lowercase
+
+  NestingDepth:
+    enabled: true
+    max_depth: 4
+
+  PlaceholderInExtend:
+    enabled: true
+
+  PropertyCount:
+    enabled: false
+    include_nested: false
+    max_properties: 10
+
+  PropertySortOrder:
+    enabled: true
+    ignore_unspecified: false
+    separate_groups: false
+
+  PropertySpelling:
+    enabled: true
+    extra_properties: []
+
+  QualifyingElement:
+    enabled: false
+    allow_element_with_attribute: false
+    allow_element_with_class: false
+    allow_element_with_id: false
+
+  SelectorDepth:
+    enabled: true
+    max_depth: 3
+
+  SelectorFormat:
+    enabled: true
+    convention: hyphenated_BEM
+
+  Shorthand:
+    enabled: true
+
+  SingleLinePerProperty:
+    enabled: true
+    allow_single_line_rule_sets: false
+
+  SingleLinePerSelector:
+    enabled: true
+
+  SpaceAfterComma:
+    enabled: true
+
+  SpaceAfterPropertyColon:
+    enabled: true
+    style: one_space
+
+  SpaceAfterPropertyName:
+    enabled: true
+
+  SpaceBeforeBrace:
+    enabled: true
+    style: space # or 'new_line'
+    allow_single_line_padding: false
+
+  SpaceBetweenParens:
+    enabled: true
+    spaces: 0
+
+  StringQuotes:
+    enabled: false
+    style: single_quotes
+
+  TrailingSemicolon:
+    enabled: true
+
+  TrailingZero:
+    enabled: true
+
+  UnnecessaryMantissa:
+    enabled: true
+
+  UnnecessaryParentReference:
+    enabled: true
+
+  UrlFormat:
+    enabled: true
+
+  UrlQuotes:
+    enabled: true
+
+  VariableForProperty:
+    enabled: true
+    properties:
+    - color
+    - font
+
+  VendorPrefixes:
+    enabled: false
+    identifier_list: base
+    include: []
+    exclude: []
+
+  ZeroUnit:
+    enabled: true
+
+  Compass::*:
+    enabled: false

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in lintrunner.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Ivan Tse
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,31 @@
+# Lintrunner
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'lintrunner'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install lintrunner
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/lintrunner/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/bin/lintrunner

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.join(File.dirname(__FILE__), "../lib"))
+
+require "lintrunner"
+require "lintrunner/cli"
+
+Lintrunner::CLI.new.run(ARGV)

data/lib/lintrunner/cli.rb

@@ -0,0 +1,97 @@
+require "lintrunner/options"
+
+module Lintrunner
+  class CLI
+
+    # Takes an array of arguments
+    # Returns exit code
+    def run(args)
+      options = Options.new.parse(args)
+
+      handle_options(options)
+
+      path = options[:path]
+      context = options[:context]
+
+      # If context is different from path that we want to lint, check that it's up to date
+      path != context && is_up_to_date?(context)
+
+      warnings = []
+      reporter = initialize_reporter(options[:reporter], path)
+
+      config = JSON.parse(File.read(Dir.pwd + "/.lintrunner_config"))
+      include_paths(config["include_paths"])
+      require_files(config["require"])
+
+      config["linters"].each do |name, config|
+        next if config["disabled"]
+        if config["command"] && config["parser"]
+          parser = Lintrunner::Parser.const_get(config["parser"]).new
+          executor = Lintrunner::Executor.new(
+            command: config["command"],
+            parser: parser
+          )
+        else
+          executor = Lintrunner::Executor.new(
+            plugin: Lintrunner::Plugin.const_get(config["plugin"])
+          )
+        end
+
+        runner = Lintrunner::Runner.const_get(config["runner"]).new(
+          path: path,
+          match: config["match"],
+          executor: executor
+        )
+        reporter.start(name)
+        results = runner.run(reporter)
+        reporter.finish(results)
+        warnings.concat(results)
+      end
+      exit warnings.empty? ? 0 : 1
+    end
+
+    private
+
+    def initialize_reporter(reporter, path)
+      Lintrunner::Reporter.const_get(reporter.capitalize).new(path)
+    end
+
+    def handle_options(options)
+
+    end
+
+    def is_up_to_date?(path)
+      context_repo = Rugged::Repository.new(path)
+      return unless context_repo.branches['master'].head?
+      return if context_repo.branches['master'].upstream.nil?
+      Dir.chdir path do
+        # update remote ref
+        `git fetch #{context_repo.branches['master'].upstream.name.split("/").join(" ")} > /dev/null 2>&1`
+        status_output = `git status`
+        if status_output =~ /Your branch is behind .* and can be fast-forwarded./
+
+          puts "Repo is not up to date!".color(:red)
+          puts "Would you like to update it (Y/N)?"
+          input = STDIN.gets
+          if input.strip == "Y"
+            `git pull --ff-only #{context_repo.branches['master'].upstream.name.split("/").join(" ")}`
+          else
+            exit 1
+          end
+        end
+      end
+    rescue Rugged::RepositoryError => e
+      # noop
+    end
+
+    def include_paths(include_paths = [])
+      $:.unshift(*include_paths)
+    end
+
+    def require_files(files)
+      files.each do |file|
+        require file
+      end
+    end
+  end
+end

data/lib/lintrunner/executor.rb

@@ -0,0 +1,23 @@
+# Encapsulates how to execute a lint either through a command line string with a parser or with a plugin
+module Lintrunner
+  class Executor
+
+    attr_reader :command, :parser, :plugin
+
+    def initialize(options = {})
+      @command = options[:command]
+      @parser = options[:parser]
+      @plugin = options[:plugin]
+    end
+
+    def execute(filename, options = {})
+      if command && parser
+        output = `#{command} #{filename} 2>/dev/null`
+        exit_code = $?.exitstatus
+        parser.parse(output, exit_code, options)
+      elsif plugin
+        plugin.new(filename).run(options)
+      end
+    end
+  end
+end

data/lib/lintrunner/git_helpers.rb

@@ -0,0 +1,11 @@
+module Lintrunner
+  module GitHelpers
+    def git_common_ancestor
+      git.merge_base('master', 'HEAD')
+    end
+
+    def git_changeset
+      git.diff(git_common_ancestor, 'HEAD', context_lines: 1000)
+    end
+  end
+end

data/lib/lintrunner/message.rb

@@ -0,0 +1,14 @@
+module Lintrunner
+  class Message
+
+    attr_accessor :filename, :line, :name, :description
+
+    def initialize(filename:, line:, name:, description:)
+      self.filename = filename
+      self.line = line
+      self.name = name
+      self.description = description
+    end
+
+  end
+end

data/lib/lintrunner/options.rb

@@ -0,0 +1,78 @@
+require "optparse"
+
+module Lintrunner
+  class Options
+
+    attr_reader :options
+
+    def test; require 'pry'; binding.pry;end
+    def initialize
+      @options = {}
+      @option_parser = OptionParser.new do |opts|
+        add_banner(opts)
+        add_config_option(opts)
+        add_context_option(opts)
+        add_include_path_option(opts)
+        add_reporter_option(opts)
+      end
+    end
+
+    def parse(args)
+      @option_parser.parse!(args)
+      add_defaults
+      options[:path] = args.first if args.first
+      options
+    end
+
+    private
+
+    def add_defaults
+      options[:config] ||= ".lintrunner_config"
+      options[:context] ||= Dir.pwd
+      options[:include_paths] = Array(options[:include_paths]) << options[:context]
+      options[:include_paths].uniq!
+      options[:reporter] ||= "text"
+      options[:path] = Dir.pwd
+    end
+
+    def add_banner(opts)
+      opts.banner = unindent(<<-BANNER)
+        Run multiple linters with various runners
+        Usage: #{opts.program_name} [options] [path]
+      BANNER
+    end
+
+    def add_config_option(opts)
+      message = "the configuration file for lintrunner (default: .lintrunner_config)"
+      opts.on("-c", "--config config", message, String) do |config|
+        self.options[:config] = config
+      end
+    end
+
+    def add_context_option(opts)
+      message = "the path on which lintrunner will execute in (default: current path)"
+      opts.on("-x", "--context path", message, String) do |path|
+        self.options[:context] = Pathname.new(path).realpath.to_s
+      end
+    end
+
+    def add_include_path_option(opts)
+      message = "the paths to add to load paths (the context is in the load path)"
+      opts.on("--include_path path1,...", message, Array) do |paths|
+        self.options[:include_paths] = paths
+      end
+    end
+
+    def add_reporter_option(opts)
+      message = "the reporter that lintrunner uses to report results"
+      opts.on("--reporter reporter", message, String) do |reporter|
+        self.options[:reporter] = reporter
+      end
+    end
+
+    def unindent(str)
+      str.gsub(/^#{str.scan(/^[ ]+(?=\S)/).min}/, "")
+    end
+
+  end
+end

data/lib/lintrunner/parser/base.rb

@@ -0,0 +1,19 @@
+# Parsers are responsible for parsing the output of a linter command and returning an array of
+# Lintrunner::Message for each warning produced
+module Lintrunner
+  module Parser
+    class Base
+
+      # Parse the output of a linter so that lintrunner can understand what the warnings are
+      # @param [String] output The output of running the linter command
+      # @param [Integer] exit_code The exit code of the linter command
+      # @param [Hash] options
+      # @option opts [String] :filename Allow the caller to set the filename of the results
+      # @return [Array<Lintrunner::Message>] An array of warnings produced by the linter command
+      def parse(output, exit_code, options = {})
+        raise "Parser must implement #parser method"
+      end
+
+    end
+  end
+end

data/lib/lintrunner/parser/eslint.rb

@@ -0,0 +1,28 @@
+module Lintrunner
+  module Parser
+    class Eslint < Base
+
+      # Example output of eslint (using the compact formatter):
+      # app/javascripts/delivery_page/components/add_guests.js: line 256, col 5, Error - Missing semicolon. (semi)
+      # app/javascripts/delivery_page/components/add_guests.js: line 277, col 18, Error - Props should be sorted alphabetically (react/jsx-sort-props)
+      def parse(output, exit_code, options = {})
+        return [] unless exit_code == 1
+
+        messages = []
+        output.each_line do |line|
+
+          match = /(?<filename>.*): line (?<line>\d*), .*Error - (?<description>.*) \((?<name>.*)\)/.match(line)
+          if match
+            messages << Lintrunner::Message.new(
+              filename: options[:filename] || match[:filename],
+              line: match["line"].to_i,
+              name: match["name"],
+              description: match["description"])
+          end
+        end
+        messages
+      end
+
+    end
+  end
+end

data/lib/lintrunner/parser/rubocop.rb

@@ -0,0 +1,57 @@
+module Lintrunner
+  module Parser
+    class Rubocop
+
+      # Example output of rubocop (using the json formatter):
+      # {
+      #   "metadata": {
+      #     "rubocop_version": "0.32.1",
+      #     "ruby_engine": "ruby",
+      #     "ruby_version": "2.1.1",
+      #     "ruby_patchlevel": "76",
+      #     "ruby_platform": "x86_64-darwin14.0"
+      #   },
+      #   "files": [
+      #     {
+      #       "path": "lib\/lintrunner\/options.rb",
+      #       "offenses": [
+      #         {
+      #           "severity": "warning",
+      #           "message": "Remove debugger entry point `binding.pry`.",
+      #           "cop_name": "Lint\/Debugger",
+      #           "corrected": null,
+      #           "location": {
+      #             "line": 73,
+      #             "column": 22,
+      #             "length": 11
+      #           }
+      #         }
+      #       ]
+      #     }
+      #   ],
+      #   "summary": {
+      #     "offense_count": 1,
+      #     "target_file_count": 1,
+      #     "inspected_file_count": 1
+      #   }
+      # }
+      def parse(output, exit_code, options = {})
+        return [] unless exit_code == 1
+
+        messages = []
+        JSON.parse(output)["files"].each do |file_results|
+          filename = file_results["path"]
+          file_results["offenses"].each do |lint|
+            messages << Lintrunner::Message.new(
+              filename: options[:filename] || filename,
+              line: lint["location"]["line"],
+              name: lint["cop_name"],
+              description: lint["message"])
+          end
+        end
+        messages
+      end
+
+    end
+  end
+end

data/lib/lintrunner/parser/scss_lint.rb

@@ -0,0 +1,36 @@
+module Lintrunner
+  module Parser
+    class SCSSLint
+
+      # Example output of scss-lint (using the json formatter):
+      # {
+      #   "app/styles/pages/delivery/_add_guests.scss": [
+      #     {
+      #       "line": 9,
+      #       "column": 14,
+      #       "length": 16,
+      #       "severity": "warning",
+      #       "reason": "Shorthand form for property `padding` should be written more concisely as `32px 70px 0` instead of `32px 70px 0 70px`",
+      #       "linter": "Shorthand"
+      #     }
+      #   ]
+      # }
+      def parse(output, exit_code, options = {})
+        return [] unless exit_code == 1
+
+        messages = []
+        JSON.parse(output).each do |filename, lints|
+          lints.each do |lint|
+            messages << Lintrunner::Message.new(
+              filename: options[:filename] || filename,
+              line: lint["line"],
+              name: lint["linter"],
+              description: lint["reason"])
+          end
+        end
+        messages
+      end
+
+    end
+  end
+end

data/lib/lintrunner/plugin.rb

@@ -0,0 +1,5 @@
+module Lintrunner
+  module Plugin
+
+  end
+end

data/lib/lintrunner/reporter/base.rb

@@ -0,0 +1,30 @@
+# Reporters are responsible for generating the output of lintrunner
+# Default behavior is noop for #start, #report, and #finish
+module Lintrunner
+  module Reporter
+    class Base
+
+      attr_reader :path
+
+      def initialize(path)
+        @path = path
+      end
+
+      # Called when a lintrunner is started
+      # @param [String] name The name of the lintrunner (ex. "binding.pry check")
+      def start(name); end
+
+      # Called when a message is discovered from the lintrunner
+      # @param [Lintrunner::Message] message
+      def report(message); end
+
+      # Called when the lintrunner is finished executing
+      # @param [Array<Lintrunner::Message>] messages
+      def finish(messages); end
+
+      # The description of this reporter. Used for CLI when listing possible reporters
+      def description; end
+
+    end
+  end
+end

data/lib/lintrunner/reporter/context.rb

@@ -0,0 +1,24 @@
+module Lintrunner
+  module Reporter
+    class Context < Text
+
+      def report(message)
+        puts "#{location(message)} #{message.description} #{message_name(message)}"
+        puts context(message)
+        puts
+      end
+
+      private
+
+      def context(message)
+        lineno = message.line - 1
+        start = lineno > 2 ? lineno - 3 : 0
+        range = start..(message.line + 2)
+        lines = ::File.readlines(::File.join(path, message.filename))[range]
+        message_index = lineno - start
+        lines[message_index] = lines[message_index].color(:red)
+        lines.join
+      end
+    end
+  end
+end