goodcheck 2.6.0 → 3.0.2

data/lib/goodcheck/config.rb

@@ -1,11 +1,43 @@
 module Goodcheck
   class Config
+    DEFAULT_EXCLUDE_BINARY = false
+
+    # https://www.iana.org/assignments/media-types/media-types.xhtml
+    BINARY_MIME_TYPES = %w[
+      audio
+      font
+      image
+      model
+      multipart
+      video
+    ].to_set.freeze
+    BINARY_MIME_FULLTYPES = %w[
+      application/gzip
+      application/illustrator
+      application/pdf
+      application/zip
+    ].to_set.freeze
+
     attr_reader :rules
     attr_reader :exclude_paths
+    attr_reader :exclude_binary
+    alias exclude_binary? exclude_binary
+    attr_reader :allowed_severities
+    attr_reader :severity_required
+    alias severity_required? severity_required
 
-    def initialize(rules:, exclude_paths:)
+    def initialize(rules:, exclude_paths:, exclude_binary: DEFAULT_EXCLUDE_BINARY, severity: nil)
       @rules = rules
       @exclude_paths = exclude_paths
+      @exclude_binary = exclude_binary || DEFAULT_EXCLUDE_BINARY
+      severity ||= {}
+      @allowed_severities = Set.new(severity.fetch(:allow, []))
+      @severity_required = severity.fetch(:required, false)
+    end
+
+    def severity_allowed?(severity)
+      return true if allowed_severities.empty?
+      allowed_severities.include?(severity)
     end
 
     def each_rule(filter:, &block)
@@ -44,5 +76,40 @@ module Goodcheck
         enum_for(:rules_for_path, path, rules_filter: rules_filter)
       end
     end
+
+    def exclude_path?(path)
+      excluded = exclude_paths.any? do |pattern|
+        path.fnmatch?(pattern, File::FNM_PATHNAME | File::FNM_EXTGLOB)
+      end
+
+      return true if excluded
+      return excluded unless exclude_binary?
+      return excluded unless path.file?
+
+      exclude_file_by_mime_type?(path)
+    end
+
+    private
+
+    def exclude_file_by_mime_type?(file)
+      # NOTE: Lazy load to save memory
+      require "marcel"
+
+      fulltype = Marcel::MimeType.for(file)
+      type, subtype = fulltype.split("/")
+
+      case
+      when subtype.end_with?("+xml") # e.g. "image/svg+xml"
+        false
+      when BINARY_MIME_TYPES.include?(type)
+        Goodcheck.logger.debug "Exclude file: #{file} (#{fulltype})"
+        true
+      when BINARY_MIME_FULLTYPES.include?(fulltype)
+        Goodcheck.logger.debug "Exclude file: #{file} (#{fulltype})"
+        true
+      else
+        false
+      end
+    end
   end
 end

data/lib/goodcheck/config_loader.rb

@@ -103,7 +103,8 @@ module Goodcheck
         justification: optional(array_or(string)),
         glob: optional(glob),
         pass: optional(array_or(string)),
-        fail: optional(array_or(string))
+        fail: optional(array_or(string)),
+        severity: optional(string)
       )
 
       let :negative_rule, object(
@@ -113,14 +114,16 @@ module Goodcheck
         justification: optional(array_or(string)),
         glob: optional(glob),
         pass: optional(array_or(string)),
-        fail: optional(array_or(string))
+        fail: optional(array_or(string)),
+        severity: optional(string)
       )
 
       let :nopattern_rule, object(
         id: string,
         message: string,
         justification: optional(array_or(string)),
-        glob: glob
+        glob: glob,
+        severity: optional(string)
       )
 
       let :positive_trigger, object(
@@ -163,7 +166,8 @@ module Goodcheck
         id: string,
         message: string,
         justification: optional(array_or(string)),
-        trigger: array_or(trigger)
+        trigger: array_or(trigger),
+        severity: optional(string)
       )
 
       let :rule, enum(positive_rule,
@@ -187,14 +191,17 @@ module Goodcheck
 
       let :rules, array(rule)
 
-      let :import_target, string
-      let :imports, array(import_target)
-      let :exclude, array_or(string)
+      let :severity, object(
+        allow: optional(array(string)),
+        required: boolean?
+      )
 
       let :config, object(
         rules: optional(rules),
-        import: optional(imports),
-        exclude: optional(exclude)
+        import: optional(array(string)),
+        exclude: optional(array_or(string)),
+        exclude_binary: boolean?,
+        severity: optional(severity)
       )
     end
 
@@ -214,39 +221,40 @@ 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]))
-
-        Array(content[:import]).each do |import|
-          load_import rules, import
-        end
+      load_rules(rules, array(content[:rules]))
 
-        exclude_paths = Array(content[:exclude])
-
-        Config.new(rules: rules, exclude_paths: exclude_paths)
+      Array(content[:import]).each do |import|
+        load_import rules, import
       end
+
+      Config.new(
+        rules: rules,
+        exclude_paths: Array(content[:exclude]),
+        exclude_binary: content[:exclude_binary],
+        severity: content[:severity]
+      )
     end
 
     def load_rules(rules, array)
       array.each do |hash|
         rules << load_rule(hash)
+      rescue RegexpError => exn
+        raise InvalidPattern, "Invalid pattern of the `#{hash.fetch(:id)}` rule in `#{path}`: #{exn.message}"
       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, filename: import)), symbolize_names: true)
+      import_loader.load(import) do |content, filename|
+        json = JSON.parse(JSON.dump(YAML.safe_load(content, filename: filename)), symbolize_names: true)
 
-          Schema.rules.coerce json
-          load_rules(rules, json)
-        end
+        Schema.rules.coerce json
+        load_rules(rules, json)
       end
     end
 
@@ -257,8 +265,9 @@ module Goodcheck
       triggers = retrieve_triggers(hash)
       justifications = array(hash[:justification])
       message = hash[:message].chomp
+      severity = hash[:severity]
 
-      Rule.new(id: id, message: message, justifications: justifications, triggers: triggers)
+      Rule.new(id: id, message: message, justifications: justifications, triggers: triggers, severity: severity)
     end
 
     def retrieve_triggers(hash)

data/lib/goodcheck/exit_status.rb

@@ -2,5 +2,7 @@ module Goodcheck
   module ExitStatus
     EXIT_SUCCESS = 0
     EXIT_ERROR = 1
+    EXIT_MATCH = 2
+    EXIT_TEST_FAILED = 3
   end
 end

data/lib/goodcheck/import_loader.rb

@@ -18,6 +18,19 @@ module Goodcheck
       end
     end
 
+    class HTTPGetError < Error
+      attr_reader :response
+
+      def initialize(res)
+        super("HTTP GET #{res.uri} => #{res.code} #{res.message}")
+        @response = res
+      end
+
+      def error_response?
+        response.is_a?(Net::HTTPClientError) || response.is_a?(Net::HTTPServerError)
+      end
+    end
+
     attr_reader :cache_path
     attr_reader :expires_in
     attr_reader :force_download
@@ -31,9 +44,13 @@ module Goodcheck
     end
 
     def load(name, &block)
-      uri = URI.parse(name)
+      uri = begin
+        URI.parse(name)
+      rescue URI::InvalidURIError
+        nil
+      end
 
-      case uri.scheme
+      case uri&.scheme
       when nil
         load_file name, &block
       when "file"
@@ -45,14 +62,20 @@ module Goodcheck
       end
     end
 
-    def load_file(path)
-      files = Dir.glob(File.join(config_path.parent.to_path, path), File::FNM_DOTMATCH | File::FNM_EXTGLOB).sort
+    def load_file(path, &block)
+      files = Pathname.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)
+          if unarchiver.tar_gz?(file)
+            unarchiver.tar_gz(file.read) do |content, filename|
+              block.call(content, filename)
+            end
+          else
+            block.call(file.read, file.to_path)
+          end
         end
       end
     end
@@ -61,7 +84,7 @@ module Goodcheck
       Digest::SHA2.hexdigest(uri.to_s)
     end
 
-    def load_http(uri)
+    def load_http(uri, &block)
       hash = cache_name(uri)
       path = cache_path + hash
 
@@ -87,13 +110,19 @@ module Goodcheck
       if download
         path.rmtree if path.exist?
         Goodcheck.logger.info "Downloading content..."
-        content = http_get uri
-        Goodcheck.logger.debug "Downloaded content: #{content[0, 1024].inspect}#{content.size > 1024 ? "..." : ""}"
-        yield content
-        write_cache uri, content
+        if unarchiver.tar_gz?(uri.path)
+          unarchiver.tar_gz(http_get(uri)) do |content, filename|
+            block.call(content, filename)
+            write_cache "#{uri}/#{filename}", content
+          end
+        else
+          content = http_get(uri)
+          block.call(content, uri.path)
+          write_cache uri, content
+        end
       else
         Goodcheck.logger.info "Reading content from cache..."
-        yield path.read
+        block.call(path.read, path.to_path)
       end
     end
 
@@ -106,16 +135,41 @@ module Goodcheck
     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}"
+      max_retry_count = 2
+      retry_count = 0
+      begin
+        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 HTTPGetError.new(res)
+        end
+      rescue Net::OpenTimeout, HTTPGetError => exn
+        if retry_count < max_retry_count && exn.error_response?
+          retry_count += 1
+          Goodcheck.logger.info "#{retry_count} retry HTTP GET #{exn.response.uri} due to '#{exn.response.code} #{exn.response.message}'..."
+          sleep 1
+          retry
+        else
+          raise
+        end
       end
     end
+
+    private
+
+    def unarchiver
+      @unarchiver ||=
+        begin
+          filter = ->(filename) {
+            %w[.yml .yaml].include?(File.extname(filename).downcase) && File.basename(filename) != DEFAULT_CONFIG_FILE
+          }
+          Unarchiver.new(file_filter: filter)
+        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

data/lib/goodcheck/reporters/json.rb

@@ -26,7 +26,8 @@ module Goodcheck
               end_column: location.end_column
             },
             message: issue.rule.message,
-            justifications: issue.rule.justifications
+            justifications: issue.rule.justifications,
+            severity: issue.rule.severity
           }
         end
         stdout.puts ::JSON.dump(json)
@@ -44,6 +45,10 @@ module Goodcheck
       def issue(issue)
         issues << issue
       end
+
+      def summary
+        # noop
+      end
     end
   end
 end