goodcheck 2.5.0 → 2.7.0

data/lib/goodcheck/commands/config_loading.rb

@@ -1,11 +1,27 @@
 module Goodcheck
   module Commands
     module ConfigLoading
+      class ConfigFileNotFound < Error
+        attr_reader :path
+
+        def initialize(path:)
+          super(path.to_s)
+          @path = path
+        end
+      end
+
       attr_reader :config
 
       def load_config!(force_download:, cache_path:)
+        config_content =
+          begin
+            config_path.read
+          rescue Errno::ENOENT
+            raise ConfigFileNotFound.new(path: config_path)
+          end
+
         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, filename: config_path.to_s)), symbolize_names: true)
+        content = JSON.parse(JSON.dump(YAML.safe_load(config_content, filename: config_path.to_s)), symbolize_names: true)
         loader = ConfigLoader.new(path: config_path, content: content, stderr: stderr, import_loader: import_loader)
         @config = loader.load
       end
@@ -13,7 +29,9 @@ module Goodcheck
       def handle_config_errors(stderr)
         begin
           yield
-
+        rescue ConfigFileNotFound => exn
+          stderr.puts "Configuration file not found: #{exn.path}"
+          1
         rescue Psych::Exception => exn
           stderr.puts "Unexpected error happens while loading YAML file: #{exn.inspect}"
           exn.backtrace.each do |trace_loc|

data/lib/goodcheck/commands/init.rb

@@ -58,6 +58,8 @@ rules:
 #   - vendor
       EOC
 
+      include ExitStatus
+
       attr_reader :stdout
       attr_reader :stderr
       attr_reader :path
@@ -73,7 +75,7 @@ rules:
       def run
         if path.file? && !force
           stderr.puts "#{path} already exists. Try --force option to overwrite the file."
-          return 1
+          return EXIT_ERROR
         end
 
         path.open("w") do |io|
@@ -82,7 +84,7 @@ rules:
 
         stdout.puts "Wrote #{path}. ✍️"
 
-        0
+        EXIT_SUCCESS
       end
     end
   end

data/lib/goodcheck/commands/pattern.rb

@@ -9,6 +9,7 @@ module Goodcheck
 
       include ConfigLoading
       include HomePath
+      include ExitStatus
 
       def initialize(stdout:, stderr:, path:, ids:, home_path:)
         @stdout = stdout
@@ -34,7 +35,7 @@ module Goodcheck
           end
         end
 
-        0
+        EXIT_SUCCESS
       end
     end
   end

data/lib/goodcheck/commands/test.rb

@@ -3,6 +3,7 @@ module Goodcheck
     class Test
       include ConfigLoading
       include HomePath
+      include ExitStatus
 
       attr_reader :stdout
       attr_reader :stderr
@@ -24,13 +25,13 @@ module Goodcheck
 
           if config.rules.empty?
             stdout.puts "No rules."
-            return 0
+            return EXIT_SUCCESS
           end
 
-          validate_rule_uniqueness or return 1
-          validate_rules or return 1
+          validate_rule_uniqueness or return EXIT_ERROR
+          validate_rules or return EXIT_ERROR
 
-          0
+          EXIT_SUCCESS
         end
       end
 
@@ -50,7 +51,8 @@ module Goodcheck
           true
         else
           count = duplicated_ids.size
-          stdout.puts(Rainbow("  Found #{count} #{'duplication'.pluralize(count)}.😞").red)
+          duplication = count == 1 ? 'duplication' : 'duplications'
+          stdout.puts(Rainbow("  Found #{count} #{duplication}.😞").red)
           duplicated_ids.each do |id|
             stdout.puts "    #{id}"
           end
@@ -75,7 +77,7 @@ module Goodcheck
                 if trigger.by_pattern?
                   stdout.puts "  Testing pattern..."
                 else
-                  stdout.puts "  Testing #{(index+1).ordinalize} trigger..."
+                  stdout.puts "  #{index + 1}. Testing trigger..."
                 end
 
                 pass_errors = trigger.passes.each.with_index.select do |pass, _|
@@ -91,7 +93,7 @@ module Goodcheck
                   rule_ok = false
 
                   pass_errors.each do |_, index|
-                    stdout.puts "    #{(index+1).ordinalize} #{Rainbow('pass').green} example matched.😱"
+                    stdout.puts "    #{index + 1}. #{Rainbow('pass').green} example matched.😱"
                     failed_rule_ids << rule.id
                   end
                 end
@@ -101,7 +103,7 @@ module Goodcheck
                   rule_ok = false
 
                   fail_errors.each do |_, index|
-                    stdout.puts "    #{(index+1).ordinalize} #{Rainbow('fail').red} example didn't match.😱"
+                    stdout.puts "    #{index + 1}. #{Rainbow('fail').red} example didn't match.😱"
                     failed_rule_ids << rule.id
                   end
                 end
@@ -131,10 +133,11 @@ module Goodcheck
         end
 
         rule_count = success_count + failure_count
+        rule = rule_count == 1 ? "1 rule" : "#{rule_count} rules"
+        success = Rainbow(success_count == 1 ? "1 success" : "#{success_count} successes").green
+        failure = Rainbow(failure_count == 1 ? "1 failure" : "#{failure_count} failures").red
         stdout.puts ""
-        stdout.puts ["Tested #{rule_count} #{'rule'.pluralize(rule_count)}",
-                     Rainbow("#{success_count} #{'success'.pluralize(success_count)}").green,
-                     Rainbow("#{failure_count} #{'failure'.pluralize(failure_count)}").red].join(", ")
+        stdout.puts "Tested #{rule}, #{success}, #{failure}"
 
         test_pass
       end

data/lib/goodcheck/config_loader.rb

@@ -2,7 +2,7 @@ module Goodcheck
   class ConfigLoader
     include ArrayHelper
 
-    class InvalidPattern < StandardError; end
+    class InvalidPattern < Error; end
 
     Schema = StrongJSON.new do
       def self.array_or(type)
@@ -22,7 +22,8 @@ module Goodcheck
       let :deprecated_token_pattern, object(token: string, case_insensitive: boolean?)
 
       let :encoding, enum(*Encoding.name_list.map {|name| literal(name) })
-      let :glob_obj, object(pattern: string, encoding: optional(encoding))
+      let :glob_obj, object(pattern: string, encoding: optional(encoding),
+                            exclude: enum?(string, array(string)))
       let :one_glob, enum(glob_obj,
                           string,
                           detector: -> (value) {
@@ -213,21 +214,19 @@ module Goodcheck
 
     def load
       Goodcheck.logger.info "Loading configuration: #{path}"
-      Goodcheck.logger.tagged "#{path}" do
-        Schema.config.coerce(content)
+      Schema.config.coerce(content)
 
-        rules = []
+      rules = []
 
-        load_rules(rules, array(content[:rules]))
+      load_rules(rules, array(content[:rules]))
 
-        Array(content[:import]).each do |import|
-          load_import rules, import
-        end
+      Array(content[:import]).each do |import|
+        load_import rules, import
+      end
 
-        exclude_paths = Array(content[:exclude])
+      exclude_paths = Array(content[:exclude])
 
-        Config.new(rules: rules, exclude_paths: exclude_paths)
-      end
+      Config.new(rules: rules, exclude_paths: exclude_paths)
     end
 
     def load_rules(rules, array)
@@ -239,13 +238,11 @@ module Goodcheck
     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, filename: import)), symbolize_names: true)
+      import_loader.load(import) do |content|
+        json = JSON.parse(JSON.dump(YAML.load(content, filename: import)), symbolize_names: true)
 
-          Schema.rules.coerce json
-          load_rules(rules, json)
-        end
+        Schema.rules.coerce json
+        load_rules(rules, json)
       end
     end
 
@@ -344,9 +341,9 @@ module Goodcheck
       globs.map do |glob|
         case glob
         when String
-          Glob.new(pattern: glob, encoding: nil)
+          Glob.new(pattern: glob, encoding: nil, exclude: nil)
         when Hash
-          Glob.new(pattern: glob[:pattern], encoding: glob[:encoding])
+          Glob.new(pattern: glob[:pattern], encoding: glob[:encoding], exclude: glob[:exclude])
         end
       end
     end

data/lib/goodcheck/error.rb

@@ -0,0 +1,3 @@
+module Goodcheck
+  class Error < StandardError; end
+end

data/lib/goodcheck/exit_status.rb

@@ -0,0 +1,6 @@
+module Goodcheck
+  module ExitStatus
+    EXIT_SUCCESS = 0
+    EXIT_ERROR = 1
+  end
+end

data/lib/goodcheck/glob.rb

@@ -1,21 +1,32 @@
 module Goodcheck
   class Glob
+    FNM_FLAGS = File::FNM_PATHNAME | File::FNM_EXTGLOB | File::FNM_DOTMATCH
+
     attr_reader :pattern
     attr_reader :encoding
+    attr_reader :exclude
 
-    def initialize(pattern:, encoding:)
+    def initialize(pattern:, encoding:, exclude:)
       @pattern = pattern
       @encoding = encoding
+      @exclude = exclude
     end
 
     def test(path)
-      path.fnmatch?(pattern, File::FNM_PATHNAME | File::FNM_EXTGLOB | File::FNM_DOTMATCH)
+      path.fnmatch?(pattern, FNM_FLAGS) && !excluded?(path)
     end
 
     def ==(other)
       other.is_a?(Glob) &&
         other.pattern == pattern &&
-        other.encoding == encoding
+        other.encoding == encoding &&
+        other.exclude == exclude
+    end
+
+    private
+
+    def excluded?(path)
+      Array(exclude).any? { |exc| path.fnmatch?(exc, FNM_FLAGS) }
     end
   end
 end

data/lib/goodcheck/import_loader.rb

@@ -1,13 +1,23 @@
 module Goodcheck
   class ImportLoader
-    class UnexpectedSchemaError < StandardError
+    class UnexpectedSchemaError < Error
       attr_reader :uri
 
       def initialize(uri)
+        super("Unexpected URI schema: #{uri.scheme}")
         @uri = uri
       end
     end
 
+    class FileNotFound < Error
+      attr_reader :path
+
+      def initialize(path)
+        super("No such a file: #{path}")
+        @path = path
+      end
+    end
+
     attr_reader :cache_path
     attr_reader :expires_in
     attr_reader :force_download
@@ -24,20 +34,26 @@ module Goodcheck
       uri = URI.parse(name)
 
       case uri.scheme
-      when nil, "file"
-        load_file uri, &block
+      when nil
+        load_file name, &block
+      when "file"
+        load_file uri.path, &block
       when "http", "https"
         load_http uri, &block
       else
-        raise UnexpectedSchemaError.new("Unexpected URI schema: #{uri.class.name}")
+        raise UnexpectedSchemaError.new(uri)
       end
     end
 
-    def load_file(uri)
-      path = (config_path.parent + uri.path)
-
-      begin
-        yield path.read
+    def load_file(path)
+      files = Dir.glob(File.join(config_path.parent.to_path, path), File::FNM_DOTMATCH | File::FNM_EXTGLOB).sort
+      if files.empty?
+        raise FileNotFound.new(path)
+      else
+        files.each do |file|
+          Goodcheck.logger.info "Reading file: #{file}"
+          yield File.read(file)
+        end
       end
     end
 
@@ -71,7 +87,7 @@ module Goodcheck
       if download
         path.rmtree if path.exist?
         Goodcheck.logger.info "Downloading content..."
-        content = HTTPClient.new.get_content(uri)
+        content = http_get uri
         Goodcheck.logger.debug "Downloaded content: #{content[0, 1024].inspect}#{content.size > 1024 ? "..." : ""}"
         yield content
         write_cache uri, content
@@ -85,5 +101,21 @@ module Goodcheck
       path = cache_path + cache_name(uri)
       path.write(content)
     end
+
+    # @see https://ruby-doc.org/stdlib-2.7.0/libdoc/net/http/rdoc/Net/HTTP.html#class-Net::HTTP-label-Following+Redirection
+    def http_get(uri, limit = 10)
+      raise ArgumentError, "Too many HTTP redirects" if limit == 0
+
+      res = Net::HTTP.get_response URI(uri)
+      case res
+      when Net::HTTPSuccess
+        res.body
+      when Net::HTTPRedirection
+        location = res['Location']
+        http_get location, limit - 1
+      else
+        raise "Error: HTTP GET #{uri.inspect} #{res.inspect}"
+      end
+    end
   end
 end

data/lib/goodcheck/issue.rb

@@ -1,15 +1,15 @@
 module Goodcheck
   class Issue
     attr_reader :buffer
-    attr_reader :range
     attr_reader :rule
     attr_reader :text
+    attr_reader :range
 
-    def initialize(buffer:, range:, rule:, text:)
+    def initialize(buffer:, rule:, text: nil, text_begin_pos: nil)
       @buffer = buffer
-      @range = range
       @rule = rule
       @text = text
+      @range = text ? text_begin_pos..(text_begin_pos + text.bytesize - 1) : nil
       @location = nil
     end
 

data/lib/goodcheck/location.rb

@@ -1,4 +1,18 @@
 module Goodcheck
+  # In the example below, each attribute is:
+  #
+  # - start_line: 2
+  # - start_column: 3
+  # - end_line: 2
+  # - end_column: 9
+  #
+  # @example
+  #
+  #   1 |
+  #   2 | A matched text
+  #   3 |   ^~~~~~~
+  #         3456789
+  #
   class Location
     attr_reader :start_line
     attr_reader :start_column
@@ -12,6 +26,14 @@ module Goodcheck
       @end_column = end_column
     end
 
+    def one_line?
+      start_line == end_line
+    end
+
+    def column_size
+      end_column - start_column + 1
+    end
+
     def ==(other)
       other.is_a?(Location) &&
         other.start_line == start_line &&
@@ -19,5 +41,11 @@ module Goodcheck
         other.end_line == end_line &&
         other.end_column == end_column
     end
+
+    alias eql? ==
+
+    def hash
+      self.class.hash ^ start_line.hash ^ start_column.hash ^ end_line.hash ^ end_column.hash
+    end
   end
 end

data/lib/goodcheck/logger.rb

@@ -1,8 +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
+    @logger ||= Logger.new(
+      STDERR, level: Logger::ERROR,
+      formatter: ->(severity, time, progname, msg) { "[#{severity}] #{msg}\n" }
+    )
   end
 end