goodcheck 0.1.0

data/README.md

@@ -0,0 +1,200 @@
+# Goodcheck - Regexp based customizable linter
+
+Are you reviewing a pull request if the change contains deprecated API calls?
+Do you want to post a comment to ask the developer if a method call satisfies some condition to use that without causing an issue?
+What if a misspelling like `Github` for `GitHub` can be found automatically?
+
+Give Goodcheck a try to do them instead of you! 🎉
+
+Goodcheck is a customizable linter.
+You can define pairs of patterns and messages.
+It checks your program and when it detects a piece of text matching with the defined patterns, it prints your message which tells your teammates why it should be revised and how.
+Some part of code reviewing process can be automated.
+Everything you have to do is to define the rules, pairs of patterns and messages, and nothing will bother you. 😆
+
+## Installation
+
+```bash
+$ gem install goodcheck
+```
+
+Or you can use `bundler`!
+
+## Quickstart
+
+```bash
+$ goodcheck init
+$ vim goodcheck.yml
+$ goodcheck check
+```
+
+The `init` command generates template of `goodcheck.yml` configuration file for you.
+Edit the config file to define patterns you want to check.
+Then run `check` command, and it will print matched texts.
+
+## `goodcheck.yml`
+
+An example of configuration is like the following:
+
+```yaml
+rules:
+  - id: com.example.github
+    pattern: Github
+    message: |
+      GitHub is GitHub, not Github
+      
+      You may misspelling the name of the service!
+    justifications:
+      - When you mean a service different from GitHub
+      - When GitHub is renamed
+    glob:
+      - app/views/**/*.html.slim
+      - config/locales/**/*.yaml
+    pass:
+      - <a>Signup via GitHub</a>
+    fail:
+      - <a>Signup via Github</a>
+```
+
+The *rule* hash contains the following keys.
+
+* `id`: a string to identify rules (required)
+* `pattern`: a *pattern* or a sequence of *pattern*s (required)
+* `message`: a string to tell writers why the code piece should be revised (required)
+* `justification`: a sequence of strings to tell writers when a exception can be allowed (optional)
+* `glob`: a *glob* or a sequence of *glob*s (optional)
+* `pass`: a string, or a sequence of strings, which does not match given pattern (optional)
+* `fail`: a string, or a sequence of strings, which does match given pattern (optional)
+
+### *pattern*
+
+A *pattern* can be a *literal pattern*, *regexp pattern*, *token pattern*, or a string.
+When a string is given, it is interpreted as a *literal pattern* with `case_insensitive: false`.
+
+#### *literal pattern*
+ 
+*literal pattern* allows you to construct a regexp which matches exactly to the `literal` string.
+
+```yaml
+id: com.sample.GitHub
+pattern:
+  literal: Github
+  case_insensitive: false
+message: Write GitHub, not Github
+```
+
+All regexp meta characters included in the `literal` value will be escaped.
+`case_insensitive` is an optional key and the default is `false`.
+
+#### *regexp pattern*
+
+*regexp pattern* allows you to write a regexp with meta chars.
+
+```yaml
+id: com.sample.digits
+pattern:
+  regexp: \d{4,}
+  case_insensitive: true
+  multiline: false
+message: Insert delimiters when writing large numbers
+justification:
+  - When you are not writing numbers, including phone numbers, zip code, ...
+```
+
+It accepts two optional attributes, `case_insensitive` and `multiline`.
+The default value of `case_insensitive` and `multiline` are `true` and `false` correspondingly.
+
+The regexp will be passed to `Regexp.compile`.
+The precise definition of regular expression can be found in the documentation for Ruby.
+
+#### *token pattern*
+
+*token pattern* compiles to a *tokenized* regexp.
+
+```yaml
+id: com.sample.no-blink
+pattern:
+  token: "<blink"
+message: Stop using <blink> tag 
+glob: "**/*.html"
+justifications:
+  - If Lynx is the major target of the web site
+```
+
+It tries to tokenize the input and generates a regexp which matches sequence of tokens.
+The tokenization is heuristic and may not work well for your programming language.
+In that case, try using *regexp pattern*.
+
+The generated regexp of `<blink` is `<\s*blink\b`.
+It matches with `<blink />` and `< BLINK>`, but does not match with `https://www.chromium.org/blink`.
+
+### *glob*
+
+A *glob* can be a string, or a hash.
+
+```yaml
+glob:
+  pattern: "legacy/**/*.rb"
+  encoding: EUC-JP
+```
+
+The hash can have an optional `encoding` attribute.
+You can specify encoding of the file by the names defined for ruby.
+The list of all available encoding names can be found by `$ ruby -e "puts Encoding.name_list"`.
+The default value is `UTF-8`.
+
+If you write a string as a `glob`, the string value can be the `pattern` of the glob, without `encoding` attribute.
+
+If you omit `glob` attribute in a rule, the rule will be applied to all files given to `goodcheck`.
+
+## Commands
+
+### `goodcheck init [options]`
+
+The `init` command generates an example of configuration file.
+
+Available options are:
+
+* `-c=[CONFIG]`, `--config=[CONFIG]` to specify the configuration file name to generate.
+* `--force` to allow overwriting existing config file.
+
+### `goodcheck check [options] targets...`
+
+The `check` command checks your programs under `targets...`.
+You can pass:
+
+* Directory paths, or
+* Paths to files.
+
+When you omit `targets`, it checks all files in `.`.
+
+Available options are:
+
+* `-c [CONFIG]`, `--config=[CONFIG]` to specify the configuration file.
+* `-R [rule]`, `--rule=[rule]` to specify the rules you want to check.
+* `--format=[text|json]` to specify output format.
+
+### `goodcheck test [options]`
+
+The `test` command tests rules.
+The test contains:
+
+* Validation of rule `id` uniqueness.
+* If `pass` examples does not match with any of `pattern`s.
+* If `fail` examples matches with some of `pattern`s.
+
+Use `test` command when you add new rule to be sure you are writing rules correctly.
+
+Available options is:
+
+* `-c [CONFIG]`, `--config=[CONFIG]` to specify the configuration file.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/sideci/goodcheck.

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "goodcheck"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/goodcheck

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH << File.join(__dir__, "../lib")
+require "goodcheck"
+require "goodcheck/cli"
+
+exit Goodcheck::CLI.new(stdout: STDOUT, stderr: STDERR).run(ARGV.dup)

data/goodcheck.gemspec

@@ -0,0 +1,30 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "goodcheck/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "goodcheck"
+  spec.version       = Goodcheck::VERSION
+  spec.authors       = ["Soutaro Matsumoto"]
+  spec.email         = ["matsumoto@soutaro.com"]
+
+  spec.summary       = "Regexp based customizable linter"
+  spec.description   = "Regexp based customizable linter"
+  spec.homepage      = "https://github.com/sideci/goodcheck"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+
+  spec.add_runtime_dependency "activesupport", "~> 5.0"
+  spec.add_runtime_dependency "strong_json", "~> 0.5.0"
+  spec.add_runtime_dependency "rainbow", "~> 3.0.0"
+end

data/lib/goodcheck.rb

@@ -0,0 +1,28 @@
+require "strscan"
+require "pathname"
+require "strong_json"
+require "yaml"
+require "json"
+require "active_support/core_ext/hash/indifferent_access"
+require "active_support/core_ext/integer/inflections"
+require "rainbow"
+
+require "goodcheck/version"
+
+require "goodcheck/glob"
+require "goodcheck/buffer"
+require "goodcheck/location"
+require "goodcheck/reporters/text"
+require "goodcheck/reporters/json"
+require "goodcheck/array_helper"
+require "goodcheck/analyzer"
+require "goodcheck/issue"
+require "goodcheck/rule"
+require "goodcheck/matcher"
+require "goodcheck/pattern"
+require "goodcheck/config"
+require "goodcheck/config_loader"
+require "goodcheck/commands/config_loading"
+require "goodcheck/commands/check"
+require "goodcheck/commands/init"
+require "goodcheck/commands/test"

data/lib/goodcheck/analyzer.rb

@@ -0,0 +1,46 @@
+module Goodcheck
+  class Analyzer
+    attr_reader :rule
+    attr_reader :buffer
+
+    def initialize(rule:, buffer:)
+      @rule = rule
+      @buffer = buffer
+    end
+
+    def scan(&block)
+      if block_given?
+        issues = []
+
+        rule.patterns.each do |pattern|
+          scanner = StringScanner.new(buffer.content)
+
+          break_head = pattern.regexp.source.start_with?("\\b")
+          after_break = true
+
+          until scanner.eos?
+            case
+            when scanner.scan(pattern.regexp)
+              next if break_head && !after_break
+
+              text = scanner.matched
+              range = (scanner.pos - text.bytesize) .. scanner.pos
+              unless issues.any? {|issue| issue.range == range }
+                issues << Issue.new(buffer: buffer, range: range, rule: rule, text: text)
+              end
+            when scanner.scan(/.\b/m)
+              after_break = true
+            else
+              scanner.scan(/./m)
+              after_break = false
+            end
+          end
+        end
+
+        issues.each(&block)
+      else
+        enum_for(:scan, &block)
+      end
+    end
+  end
+end

data/lib/goodcheck/array_helper.rb

@@ -0,0 +1,12 @@
+module Goodcheck
+  module ArrayHelper
+    def array(obj)
+      case obj
+      when Hash
+        [obj]
+      else
+        Array(obj)
+      end
+    end
+  end
+end

data/lib/goodcheck/buffer.rb

@@ -0,0 +1,50 @@
+module Goodcheck
+  class Buffer
+    attr_reader :path
+    attr_reader :content
+
+    def initialize(path:, content:)
+      @path = path
+      @content = content
+    end
+
+    def line_starts
+      unless @line_starts
+        @line_starts = []
+
+        start_position = 0
+
+        content.lines.each do |line|
+          range = start_position..(start_position + line.bytesize)
+          @line_starts << range
+          start_position = range.end
+        end
+      end
+
+      @line_starts
+    end
+
+    def location_for_position(position)
+      line_index = line_starts.bsearch_index do |range|
+        position < range.end
+      end
+
+      if line_index
+        [line_index + 1, position - line_starts[line_index].begin]
+      end
+    end
+
+    def line(line_number)
+      content.lines[line_number-1]
+    end
+
+    def position_for_location(line, column)
+      if (range = line_starts[line-1])
+        pos = range.begin + column
+        if pos < range.end
+          pos
+        end
+      end
+    end
+  end
+end

data/lib/goodcheck/cli.rb

@@ -0,0 +1,112 @@
+require "optparse"
+
+module Goodcheck
+  class CLI
+    attr_reader :stdout
+    attr_reader :stderr
+
+    def initialize(stdout:, stderr:)
+      @stdout = stdout
+      @stderr = stderr
+    end
+
+    COMMANDS = {
+      init: "Generate a sample configuration file",
+      check: "Run check with a configuration",
+      test: "Test your configuration",
+      help: "Print this message"
+    }
+
+
+    def run(args)
+      command = args.shift&.to_sym
+
+      if COMMANDS.key?(command)
+        __send__(command, args)
+      else
+        help(args)
+      end
+    rescue => exn
+      stderr.puts exn.inspect
+      exn.backtrace.each do |bt|
+        stderr.puts "  #{bt}"
+      end
+      1
+    end
+
+    def check(args)
+      config_path = Pathname("goodcheck.yml")
+      targets = []
+      rules = []
+      format = nil
+
+      OptionParser.new("Usage: goodcheck check [options] dirs...") do |opts|
+        opts.on("-c CONFIG", "--config=CONFIG") do |config|
+          config_path = Pathname(config)
+        end
+        opts.on("-R RULE", "--rule=RULE") do |rule|
+          rules << rule
+        end
+        opts.on("--format=FORMAT") do |f|
+          format = f
+        end
+      end.parse!(args)
+
+      if args.empty?
+        targets << Pathname(".")
+      else
+        targets.push *args.map {|arg| Pathname(arg) }
+      end
+
+      reporter = case format
+                 when "text", nil
+                   Reporters::Text.new(stdout: stdout)
+                 when "json"
+                   Reporters::JSON.new(stdout: stdout, stderr: stderr)
+                 else
+                   stderr.puts "Unknown format: #{format}"
+                   return 1
+                 end
+
+      Commands::Check.new(reporter: reporter, config_path: config_path, rules: rules, targets: targets, stderr: stderr).run
+    end
+
+    def test(args)
+      config_path = Pathname("goodcheck.yml")
+
+      OptionParser.new("Usage: goodcheck test [options]") do |opts|
+        opts.on("-c CONFIG", "--config=CONFIG") do |config|
+          config_path = Pathname(config)
+        end
+      end.parse!(args)
+
+      Commands::Test.new(stdout: stdout, stderr: stderr, config_path: config_path).run
+    end
+
+    def init(args)
+      config_path = Pathname("goodcheck.yml")
+      force = false
+
+      OptionParser.new("Usage: goodcheck init [options]") do |opts|
+        opts.on("-c CONFIG", "--config=CONFIG") do |config|
+          config_path = Pathname(config)
+        end
+        opts.on("--force") do
+          force = true
+        end
+      end.parse!(args)
+
+      Commands::Init.new(stdout: stdout, stderr: stderr, path: config_path, force: force).run
+    end
+
+    def help(args)
+      stdout.puts "Usage: goodcheck <command> [options] [args...]"
+      stdout.puts ""
+      stdout.puts "Commands:"
+      COMMANDS.each do |c, msg|
+        stdout.puts "  goodcheck #{c}\t#{msg}"
+      end
+      0
+    end
+  end
+end