goodcheck 1.3.1 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4541711a6d0096718ec3099d059ea57c3af16b2b
-  data.tar.gz: 88619a7566f492738fd93213896edeaedc05a076
+  metadata.gz: 9f4ea78ef7a3b4901947a2f42fd9a66789bcba33
+  data.tar.gz: 9a0b7b9028ae1c17ee38b0fd1225fb5e7dbca6f5
 SHA512:
-  metadata.gz: 3226d5daece6e067f7ae2e123c3e43f4b2a7a0838e60cd92fef38f08721b3a91351782ed0a9c5d9ad96d38ad592355a3567e57eed292d7e053ede00f0874c3d5
-  data.tar.gz: eecdde8f34d52b0b4479df6c3a7b16228b2ac89b2cfd642f7f3e4820dc3ea1f3d0ec828779227144931748e744eb164ee5b5d37a7791084f603544a74806d5c2
+  metadata.gz: 24db9a20284d894904e8fc8e4a631b2472363c958a9ee4bd3d007b1abad9eec0c00815d3e92b55b51f108011ec8d599132333b0af39857904818274134abd836
+  data.tar.gz: bd81681a1bee7c60a689f4ff9c3f4dd8f9296716dd5c16fda2af51ec55b92f4fa8b9d652821514ea4905bc7192ba5d955911a7fccd974a12459c1a4ac1a7a5ea

data/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## master
 
+## 1.4.0 (2018-10-11)
+
+* Exit with `2` when it find matching text #27
+* Import rules from another location #26
+
 ## 1.3.1 (2018-08-16)
 
 * Delete Gemfile.lock

data/README.md

@@ -154,6 +154,26 @@ If you write a string as a `glob`, the string value can be the `pattern` of the
 
 If you omit `glob` attribute in a rule, the rule will be applied to all files given to `goodcheck`.
 
+## Importing rules
+
+`goodcheck.yml` can have optional `import` attribute.
+
+```yaml
+rules: []
+import:
+  - /usr/share/goodcheck/rules.yml
+  - lib/goodcheck/rules.yml
+  - https://some.host/shared/rules.yml
+```
+
+Value of `import` can be an array of:
+
+- A string which represents an absolute file path,
+- A string which represents an relative file path from config file, or
+- A http/https URL which represents the location of rules
+
+The rules file is a YAML file with array of rules.
+
 ## Commands
 
 ### `goodcheck init [options]`
@@ -180,6 +200,17 @@ 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.
+* `-v`, `--verbose` to be verbose.
+* `--debug` to print all debug messages.
+* `--force` to ignore downloaded caches
+
+`goodcheck check` exits with:
+ 
+* `0` when it does not find any matching text fragment
+* `2` when it finds some matching text
+* `1` when it finds some error
+
+You can check its exit status to identify if the tool find some pattern or not.
 
 ### `goodcheck test [options]`
 
@@ -195,6 +226,16 @@ Use `test` command when you add new rule to be sure you are writing rules correc
 Available options is:
 
 * `-c [CONFIG]`, `--config=[CONFIG]` to specify the configuration file.
+* `-v`, `--verbose` to be verbose.
+* `--debug` to print all debug messages.
+* `--force` to ignore downloaded caches
+
+## Downloaded rules
+
+Downloaded rules are cached in `cache` directory in *goodcheck home directory*.
+The *goodcheck home directory* is `~/.goodcheck`, but you can customize the location with `GOODCHECK_HOME` environment variable.
+
+The cache expires in 3 minutes.
 
 ## Docker image
 

data/goodcheck.gemspec

@@ -29,4 +29,5 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "activesupport", "~> 5.0"
   spec.add_runtime_dependency "strong_json", "~> 0.5.0"
   spec.add_runtime_dependency "rainbow", "~> 3.0.0"
+  spec.add_runtime_dependency "httpclient", "~> 2.8.3"
 end

data/lib/goodcheck.rb

@@ -5,9 +5,14 @@ require "yaml"
 require "json"
 require "active_support/core_ext/hash/indifferent_access"
 require "active_support/core_ext/integer/inflections"
+require "active_support/tagged_logging"
 require "rainbow"
+require "digest/sha2"
+require "httpclient"
 
 require "goodcheck/version"
+require "goodcheck/logger"
+require "goodcheck/home_path"
 
 require "goodcheck/glob"
 require "goodcheck/buffer"
@@ -25,3 +30,4 @@ require "goodcheck/commands/config_loading"
 require "goodcheck/commands/check"
 require "goodcheck/commands/init"
 require "goodcheck/commands/test"
+require "goodcheck/import_loader"

data/lib/goodcheck/cli.rb

@@ -1,5 +1,7 @@
 require "optparse"
 
+Version = Goodcheck::VERSION
+
 module Goodcheck
   class CLI
     attr_reader :stdout
@@ -35,11 +37,21 @@ module Goodcheck
       1
     end
 
+    def home_path
+      if (path = ENV["GOODCHECK_HOME"])
+        Pathname(path)
+      else
+        Pathname(Dir.home) + ".goodcheck"
+      end
+    end
+
     def check(args)
       config_path = Pathname("goodcheck.yml")
       targets = []
       rules = []
       format = nil
+      loglevel = Logger::ERROR
+      force_download = false
 
       OptionParser.new("Usage: goodcheck check [options] dirs...") do |opts|
         opts.on("-c CONFIG", "--config=CONFIG") do |config|
@@ -51,8 +63,19 @@ module Goodcheck
         opts.on("--format=<text|json> [default: 'text']") do |f|
           format = f
         end
+        opts.on("-v", "--verbose") do
+          loglevel = Logger::INFO
+        end
+        opts.on("-d", "--debug") do
+          loglevel = Logger::DEBUG
+        end
+        opts.on("--force") do
+          force_download = true
+        end
       end.parse!(args)
 
+      Goodcheck.logger.level = loglevel
+
       if args.empty?
         targets << Pathname(".")
       else
@@ -69,19 +92,43 @@ module Goodcheck
                    return 1
                  end
 
-      Commands::Check.new(reporter: reporter, config_path: config_path, rules: rules, targets: targets, stderr: stderr).run
+      Goodcheck.logger.info "Configuration = #{config_path}"
+      Goodcheck.logger.info "Rules = [#{rules.join(", ")}]"
+      Goodcheck.logger.info "Format = #{format}"
+      Goodcheck.logger.info "Targets = [#{targets.join(", ")}]"
+      Goodcheck.logger.info "Force download = #{force_download}"
+      Goodcheck.logger.info "Home path = #{home_path}"
+
+      Commands::Check.new(reporter: reporter, config_path: config_path, rules: rules, targets: targets, stderr: stderr, force_download: force_download, home_path: home_path).run
     end
 
     def test(args)
       config_path = Pathname("goodcheck.yml")
+      loglevel = Logger::ERROR
+      force_download = false
 
       OptionParser.new("Usage: goodcheck test [options]") do |opts|
         opts.on("-c CONFIG", "--config=CONFIG") do |config|
           config_path = Pathname(config)
         end
+        opts.on("-v", "--verbose") do
+          loglevel = Logger::INFO
+        end
+        opts.on("-d", "--debug") do
+          loglevel = Logger::DEBUG
+        end
+        opts.on("--force") do
+          force_download = true
+        end
       end.parse!(args)
 
-      Commands::Test.new(stdout: stdout, stderr: stderr, config_path: config_path).run
+      Goodcheck.logger.level = loglevel
+
+      Goodcheck.logger.info "Configuration = #{config_path}"
+      Goodcheck.logger.info "Force download = #{force_download}"
+      Goodcheck.logger.info "Home path = #{home_path}"
+
+      Commands::Test.new(stdout: stdout, stderr: stderr, config_path: config_path, force_download: force_download, home_path: home_path).run
     end
 
     def init(args)

data/lib/goodcheck/commands/check.rb

@@ -6,30 +6,39 @@ module Goodcheck
       attr_reader :targets
       attr_reader :reporter
       attr_reader :stderr
+      attr_reader :force_download
+      attr_reader :home_path
 
       include ConfigLoading
+      include HomePath
 
-      def initialize(config_path:, rules:, targets:, reporter:, stderr:)
+      def initialize(config_path:, rules:, targets:, reporter:, stderr:, home_path:, force_download:)
         @config_path = config_path
         @rules = rules
         @targets = targets
         @reporter = reporter
         @stderr = stderr
+        @force_download = force_download
+        @home_path = home_path
       end
 
       def run
+        issue_reported = false
+
         reporter.analysis do
-          load_config!
+          load_config!(force_download: force_download, cache_path: cache_dir_path)
           each_check do |buffer, rule|
             reporter.rule(rule) do
               analyzer = Analyzer.new(rule: rule, buffer: buffer)
               analyzer.scan do |issue|
+                issue_reported = true
                 reporter.issue(issue)
               end
             end
           end
         end
-        0
+
+        issue_reported ? 2 : 0
       rescue Psych::Exception => exn
         stderr.puts "Unexpected error happens while loading YAML file: #{exn.inspect}"
         exn.backtrace.each do |trace_loc|
@@ -46,25 +55,32 @@ module Goodcheck
 
       def each_check
         targets.each do |target|
-          each_file target, immediate: true do |path|
-            reporter.file(path) do
-              buffers = {}
+          Goodcheck.logger.info "Checking target: #{target}"
+          Goodcheck.logger.tagged target.to_s do
+            each_file target, immediate: true do |path|
+              Goodcheck.logger.debug "Checking file: #{path}"
+              Goodcheck.logger.tagged path.to_s do
+                reporter.file(path) do
+                  buffers = {}
 
-              config.rules_for_path(path, rules_filter: rules) do |rule, glob|
-                begin
-                  encoding = glob&.encoding || Encoding.default_external.name
+                  config.rules_for_path(path, rules_filter: rules) do |rule, glob|
+                    Goodcheck.logger.debug "Checking rule: #{rule.id}"
+                    begin
+                      encoding = glob&.encoding || Encoding.default_external.name
 
-                  if buffers[encoding]
-                    buffer = buffers[encoding]
-                  else
-                    content = path.read(encoding: encoding).encode(Encoding.default_internal || Encoding::UTF_8)
-                    buffer = Buffer.new(path: path, content: content)
-                    buffers[encoding] = buffer
-                  end
+                      if buffers[encoding]
+                        buffer = buffers[encoding]
+                      else
+                        content = path.read(encoding: encoding).encode(Encoding.default_internal || Encoding::UTF_8)
+                        buffer = Buffer.new(path: path, content: content)
+                        buffers[encoding] = buffer
+                      end
 
-                  yield buffer, rule
-                rescue ArgumentError => exn
-                  stderr.puts "#{path}: #{exn.inspect}"
+                      yield buffer, rule
+                    rescue ArgumentError => exn
+                      stderr.puts "#{path}: #{exn.inspect}"
+                    end
+                  end
                 end
               end
             end

data/lib/goodcheck/commands/config_loading.rb

@@ -3,9 +3,10 @@ module Goodcheck
     module ConfigLoading
       attr_reader :config
 
-      def load_config!
+      def load_config!(force_download:, cache_path:)
+        import_loader = ImportLoader.new(cache_path: cache_path, force_download: force_download, config_path: config_path)
         content = JSON.parse(JSON.dump(YAML.load(config_path.read, config_path.to_s)), symbolize_names: true)
-        loader = ConfigLoader.new(path: config_path, content: content, stderr: stderr)
+        loader = ConfigLoader.new(path: config_path, content: content, stderr: stderr, import_loader: import_loader)
         @config = loader.load
       end
     end

data/lib/goodcheck/commands/test.rb

@@ -2,19 +2,24 @@ module Goodcheck
   module Commands
     class Test
       include ConfigLoading
+      include HomePath
 
       attr_reader :stdout
       attr_reader :stderr
       attr_reader :config_path
+      attr_reader :home_path
+      attr_reader :force_download
 
-      def initialize(stdout:, stderr:, config_path:)
+      def initialize(stdout:, stderr:, config_path:, force_download:, home_path:)
         @stdout = stdout
         @stderr = stderr
         @config_path = config_path
+        @force_download = force_download
+        @home_path = home_path
       end
 
       def run
-        load_config!
+        load_config!(cache_path: cache_dir_path, force_download: force_download)
 
         validate_rule_uniqueness or return 1
         validate_rules or return 1

data/lib/goodcheck/config_loader.rb

@@ -32,28 +32,65 @@ module Goodcheck
 
       let :rules, array(rule)
 
-      let :config, object(rules: rules)
+      let :import_target, string
+      let :imports, array(import_target)
+
+      let :config, object(rules: rules, import: optional(imports))
     end
 
     attr_reader :path
     attr_reader :content
     attr_reader :stderr
     attr_reader :printed_warnings
+    attr_reader :import_loader
 
-    def initialize(path:, content:, stderr:)
+    def initialize(path:, content:, stderr:, import_loader:)
       @path = path
       @content = content
       @stderr = stderr
       @printed_warnings = Set.new
+      @import_loader = import_loader
     end
 
     def load
-      Schema.config.coerce(content)
-      rules = content[:rules].map {|hash| load_rule(hash) }
-      Config.new(rules: rules)
+      Goodcheck.logger.info "Loading configuration: #{path}"
+      Goodcheck.logger.tagged "#{path}" do
+        Schema.config.coerce(content)
+
+        rules = []
+
+        load_rules(rules, content[:rules])
+
+        Array(content[:import]).each do |import|
+          load_import rules, import
+        end
+
+        Config.new(rules: rules)
+      end
+    end
+
+    def load_rules(rules, array)
+      array.each do |hash|
+        rules << load_rule(hash)
+      end
+    end
+
+    def load_import(rules, import)
+      Goodcheck.logger.info "Importing rules from #{import}"
+
+      Goodcheck.logger.tagged import do
+        import_loader.load(import) do |content|
+          json = JSON.parse(JSON.dump(YAML.load(content, import)), symbolize_names: true)
+
+          Schema.rules.coerce json
+          load_rules(rules, json)
+        end
+      end
     end
 
     def load_rule(hash)
+      Goodcheck.logger.debug "Loading rule: #{hash[:id]}"
+
       id = hash[:id]
       patterns = retrieve_patterns(hash)
       justifications = array(hash[:justification])

data/lib/goodcheck/home_path.rb

@@ -0,0 +1,9 @@
+module Goodcheck
+  module HomePath
+    def cache_dir_path
+      @cache_dir_path ||= (home_path + "cache").tap do |path|
+        path.mkpath unless path.directory?
+      end
+    end
+  end
+end

data/lib/goodcheck/import_loader.rb

@@ -0,0 +1,89 @@
+module Goodcheck
+  class ImportLoader
+    class UnexpectedSchemaError < StandardError
+      attr_reader :uri
+
+      def initialize(uri)
+        @uri = uri
+      end
+    end
+
+    attr_reader :cache_path
+    attr_reader :expires_in
+    attr_reader :force_download
+    attr_reader :config_path
+
+    def initialize(cache_path:, expires_in: 3 * 60, force_download:, config_path:)
+      @cache_path = cache_path
+      @expires_in = expires_in
+      @force_download = force_download
+      @config_path = config_path
+    end
+
+    def load(name, &block)
+      uri = URI.parse(name)
+
+      case uri.scheme
+      when nil, "file"
+        load_file uri, &block
+      when "http", "https"
+        load_http uri, &block
+      else
+        raise UnexpectedSchemaError.new("Unexpected URI schema: #{uri.class.name}")
+      end
+    end
+
+    def load_file(uri)
+      path = (config_path.parent + uri.path)
+
+      begin
+        yield path.read
+      end
+    end
+
+    def cache_name(uri)
+      Digest::SHA2.hexdigest(uri.to_s)
+    end
+
+    def load_http(uri)
+      hash = cache_name(uri)
+      path = cache_path + hash
+
+      Goodcheck.logger.info "Calculated cache name: #{hash}"
+
+      download = false
+
+      if force_download
+        Goodcheck.logger.debug "Downloading: force flag"
+        download = true
+      end
+
+      if !download && !path.file?
+        Goodcheck.logger.debug "Downloading: no cache found"
+        download = true
+      end
+
+      if !download && path.mtime + expires_in < Time.now
+        Goodcheck.logger.debug "Downloading: cache expired"
+        download = true
+      end
+
+      if download
+        path.rmtree if path.exist?
+        Goodcheck.logger.info "Downloading content..."
+        content = HTTPClient.new.get_content(uri)
+        Goodcheck.logger.debug "Downloaded content: #{content[0, 1024].inspect}#{content.size > 1024 ? "..." : ""}"
+        yield content
+        write_cache uri, content
+      else
+        Goodcheck.logger.info "Reading content from cache..."
+        yield path.read
+      end
+    end
+
+    def write_cache(uri, content)
+      path = cache_path + cache_name(uri)
+      path.write(content)
+    end
+  end
+end

data/lib/goodcheck/logger.rb

@@ -0,0 +1,8 @@
+module Goodcheck
+  def self.logger
+    @logger ||= ActiveSupport::TaggedLogging.new(Logger.new(STDERR)).tap do |logger|
+      logger.push_tags VERSION
+      logger.level = Logger::ERROR
+    end
+  end
+end

data/lib/goodcheck/reporters/json.rb

@@ -12,7 +12,6 @@ module Goodcheck
       end
 
       def analysis
-        stderr.puts "Starting analysis..."
         yield
 
         json = issues.map do |issue|
@@ -34,12 +33,10 @@ module Goodcheck
       end
 
       def file(path)
-        stderr.puts "Checking #{path}..."
         yield
       end
 
       def rule(rule)
-        stderr.puts "  Checking #{rule.id}..."
         yield
       end
 

data/lib/goodcheck/version.rb

@@ -1,3 +1,3 @@
 module Goodcheck
-  VERSION = "1.3.1"
+  VERSION = "1.4.0"
 end

data/sample.yml

@@ -1,4 +1,15 @@
 rules:
+  - id: sample.typo
+    pattern:
+      - Github
+      - FaceBook
+    message: |
+      Write GitHub and Facebook
+
+      Their names are GitHub and Facebook.
+      Maybe, you are misspelling.
+    pass: GitHub
+    fail: Github
   - id: sample.debug_print
     pattern:
       - token: pp
@@ -10,19 +21,6 @@ rules:
       - render "app/views/welcome.html.erb"
     fail:
       - pp("Hello World")
-  - id: sample.index_zero
-    pattern:
-      - token: "[0]"
-    glob: "**/*.rb"
-    message: |
-      You can use #first instead of [0]
-    pass: array.first
-    fail: array[0]
-  - id: sample.closed_range
-    pattern:
-      - token: ...
-    glob: "**/*.rb"
-    message: |
-      Generally .. is better than ...
-    fail: 1...3
-    pass: 1..4
+
+import:
+  - https://gist.githubusercontent.com/soutaro/6362c89acd7d6771ae6ebfc615be402d/raw/7f04b973c2c8df70783cd7deb955ab95d1375b2d/sample.yml

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: goodcheck
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 1.4.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-08-16 00:00:00.000000000 Z
+date: 2018-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -94,6 +94,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: httpclient
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.8.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.8.3
 description: Regexp based customizable linter
 email:
 - matsumoto@soutaro.com
@@ -126,8 +140,11 @@ files:
 - lib/goodcheck/config.rb
 - lib/goodcheck/config_loader.rb
 - lib/goodcheck/glob.rb
+- lib/goodcheck/home_path.rb
+- lib/goodcheck/import_loader.rb
 - lib/goodcheck/issue.rb
 - lib/goodcheck/location.rb
+- lib/goodcheck/logger.rb
 - lib/goodcheck/pattern.rb
 - lib/goodcheck/reporters/json.rb
 - lib/goodcheck/reporters/text.rb