goodcheck 2.5.2 → 3.0.1

data/lib/goodcheck/commands/config_loading.rb

@@ -1,11 +1,29 @@
 module Goodcheck
   module Commands
     module ConfigLoading
+      include ExitStatus
+
+      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,20 +31,25 @@ module Goodcheck
       def handle_config_errors(stderr)
         begin
           yield
-
+        rescue ConfigFileNotFound => exn
+          stderr.puts "Configuration file not found: #{exn.path}"
+          EXIT_ERROR
+        rescue ConfigLoader::InvalidPattern => exn
+          stderr.puts exn.message
+          EXIT_ERROR
         rescue Psych::Exception => exn
           stderr.puts "Unexpected error happens while loading YAML file: #{exn.inspect}"
           exn.backtrace.each do |trace_loc|
             stderr.puts "  #{trace_loc}"
           end
-          1
+          EXIT_ERROR
         rescue StrongJSON::Type::TypeError, StrongJSON::Type::UnexpectedAttributeError => exn
           stderr.puts "Invalid config: #{exn.message}"
           stderr.puts StrongJSON::ErrorReporter.new(path: exn.path).to_s
-          1
+          EXIT_ERROR
         rescue Errno::ENOENT => exn
           stderr.puts "#{exn}"
-          1
+          EXIT_ERROR
         end
       end
     end

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,18 +25,18 @@ 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_TEST_FAILED
+          validate_rules or return EXIT_TEST_FAILED
 
-          0
+          EXIT_SUCCESS
         end
       end
 
       def validate_rule_uniqueness
-        stdout.puts "Validating rule id uniqueness..."
+        stdout.puts "Validating rule ID uniqueness..."
 
         duplicated_ids = []
 
@@ -46,36 +47,35 @@ module Goodcheck
         end
 
         if duplicated_ids.empty?
-          stdout.puts "  OK!👍"
+          stdout.puts Rainbow("  OK! 👍").green
           true
         else
           count = duplicated_ids.size
-          stdout.puts(Rainbow("  Found #{count} #{'duplication'.pluralize(count)}.😞").red)
+          duplication = count == 1 ? 'duplication' : 'duplications'
+          stdout.puts "  Found #{Rainbow(count).bold} #{duplication}. 😱"
           duplicated_ids.each do |id|
-            stdout.puts "    #{id}"
+            stdout.puts "    - #{Rainbow(id).background(:red)}"
           end
           false
         end
       end
 
       def validate_rules
-        test_pass = true
         success_count = 0
-        failure_count = 0
         failed_rule_ids = Set[]
 
         config.rules.each do |rule|
-          if rule.triggers.any? {|trigger| !trigger.passes.empty? || !trigger.fails.empty?}
-            stdout.puts "Testing rule #{Rainbow(rule.id).cyan}..."
+          stdout.puts "Testing rule #{Rainbow(rule.id).cyan}..."
 
-            rule_ok = true
+          rule_ok = true
 
+          if rule.triggers.any? {|trigger| !trigger.passes.empty? || !trigger.fails.empty?}
             rule.triggers.each.with_index do |trigger, index|
               if !trigger.passes.empty? || !trigger.fails.empty?
                 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, _|
@@ -87,21 +87,19 @@ module Goodcheck
                 end
 
                 unless pass_errors.empty?
-                  test_pass = false
                   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
 
                 unless fail_errors.empty?
-                  test_pass = false
                   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
@@ -109,16 +107,27 @@ module Goodcheck
             end
 
             if rule.triggers.any?(&:skips_fail_examples?)
-              stdout.puts "  🚨 The rule contains a `pattern` with `glob`, which is not supported by the test command."
+              stdout.puts "    The rule contains a `pattern` with `glob`, which is not supported by the test command. 🚨"
               stdout.puts "    Skips testing `fail` examples."
             end
+          end
 
-            if rule_ok
-              stdout.puts "  OK!🎉"
-              success_count += 1
-            else
-              failure_count += 1
-            end
+          if rule.severity && !config.severity_allowed?(rule.severity)
+            allowed_severities = config.allowed_severities.map { |s| %("#{s}") }.join(', ')
+            stdout.puts Rainbow("  \"#{rule.severity}\" severity isn’t allowed. Must be one of #{allowed_severities}. 😱").red
+            rule_ok = false
+            failed_rule_ids << rule.id
+          end
+
+          if !rule.severity && config.severity_required?
+            stdout.puts Rainbow("  Severity is required. 😱").red
+            rule_ok = false
+            failed_rule_ids << rule.id
+          end
+
+          if rule_ok
+            stdout.puts Rainbow("  OK! 👍").green
+            success_count += 1
           end
         end
 
@@ -130,13 +139,12 @@ module Goodcheck
           end
         end
 
-        rule_count = success_count + failure_count
+        total = success_count + failed_rule_ids.size
         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 "#{Rainbow(total).bold} #{total == 1 ? 'rule' : 'rules'} tested: " \
+                    "#{Rainbow(success_count.to_s + ' successful').green.bold}, #{Rainbow(failed_rule_ids.size.to_s + ' failed').red.bold}"
 
-        test_pass
+        failed_rule_ids.empty?
       end
 
       def rule_matches_example?(rule, trigger, example)

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

@@ -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) {
@@ -102,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(
@@ -112,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(
@@ -162,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,
@@ -186,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
 
@@ -213,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
 
@@ -256,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)
@@ -344,9 +354,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