goodcheck 2.5.2 → 3.0.1

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,8 @@
+module Goodcheck
+  module ExitStatus
+    EXIT_SUCCESS = 0
+    EXIT_ERROR = 1
+    EXIT_MATCH = 2
+    EXIT_TEST_FAILED = 3
+  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,36 @@
 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
+
+    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
@@ -21,23 +44,39 @@ module Goodcheck
     end
 
     def load(name, &block)
-      uri = URI.parse(name)
+      uri = begin
+        URI.parse(name)
+      rescue URI::InvalidURIError
+        nil
+      end
 
-      case uri.scheme
-      when nil, "file"
-        load_file uri, &block
+      case uri&.scheme
+      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, &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}"
+          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
 
@@ -45,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
 
@@ -71,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
 
@@ -90,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 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

data/lib/goodcheck/reporters/text.rb

@@ -5,6 +5,8 @@ module Goodcheck
 
       def initialize(stdout:)
         @stdout = stdout
+        @file_count = 0
+        @issue_count = 0
       end
 
       def analysis
@@ -12,6 +14,7 @@ module Goodcheck
       end
 
       def file(path)
+        @file_count += 1
         yield
       end
 
@@ -20,21 +23,51 @@ module Goodcheck
       end
 
       def issue(issue)
+        @issue_count += 1
+
+        message = issue.rule.message.lines.first.chomp
+
         if issue.location
-          line = issue.buffer.line(issue.location.start_line)
-          end_column = if issue.location.start_line == issue.location.end_line
-                         issue.location.end_column
-                       else
-                         line.bytesize
-                       end
-          colored_line = line.byteslice(0, issue.location.start_column) + Rainbow(line.byteslice(issue.location.start_column, end_column - issue.location.start_column)).red + line.byteslice(end_column, line.bytesize)
-          stdout.puts "#{issue.path}:#{issue.location.start_line}:#{colored_line.chomp}:\t#{issue.rule.message.lines.first.chomp}"
+          start_line = issue.location.start_line
+          start_column = issue.location.start_column
+          start_column_index = start_column - 1
+          line = issue.buffer.line(start_line)
+          column_size = if issue.location.one_line?
+                          issue.location.column_size
+                        else
+                          line.bytesize - start_column
+                        end
+          rule = Rainbow("(#{issue.rule.id})").darkgray
+          severity = issue.rule.severity ? Rainbow("[#{issue.rule.severity}]").magenta : ""
+          stdout.puts "#{Rainbow(issue.path).cyan}:#{start_line}:#{start_column}: #{message}  #{rule}  #{severity}".strip
+          stdout.puts line.chomp
+          stdout.puts (" " * start_column_index) + Rainbow("^" + "~" * (column_size - 1)).yellow
         else
-          line = issue.buffer.line(1)&.chomp
-          line = line ? Rainbow(line).red : '-'
-          stdout.puts "#{issue.path}:-:#{line}:\t#{issue.rule.message.lines.first.chomp}"
+          stdout.puts "#{Rainbow(issue.path).cyan}:-:-: #{message}"
         end
       end
+
+      def summary
+        files = case @file_count
+                when 0
+                  "no files"
+                when 1
+                  "1 file"
+                else
+                  "#{@file_count} files"
+                end
+        issues = case @issue_count
+                 when 0
+                   Rainbow("no issues").green
+                 when 1
+                   Rainbow("1 issue").red
+                 else
+                   Rainbow("#{@issue_count} issues").red
+                 end
+
+        stdout.puts ""
+        stdout.puts "#{files} inspected, #{issues} detected"
+      end
     end
   end
 end

data/lib/goodcheck/rule.rb

@@ -4,12 +4,14 @@ module Goodcheck
     attr_reader :triggers
     attr_reader :message
     attr_reader :justifications
+    attr_reader :severity
 
-    def initialize(id:, triggers:, message:, justifications:)
+    def initialize(id:, triggers:, message:, justifications:, severity: nil)
       @id = id
       @triggers = triggers
       @message = message
       @justifications = justifications
+      @severity = severity
     end
   end
 end

data/lib/goodcheck/unarchiver.rb

@@ -0,0 +1,40 @@
+module Goodcheck
+  class Unarchiver
+    attr_reader :file_filter
+
+    def initialize(file_filter: ->(_filename) { true })
+      @file_filter = file_filter
+    end
+
+    def tar_gz?(filename)
+      name = filename.to_s.downcase
+      ext = ".tar.gz"
+      name.end_with?(ext) && name != ext
+    end
+
+    def tar_gz(content)
+      require "rubygems/package"
+
+      Gem::Package::TarReader.new(StringIO.new(gz(content))) do |tar_reader|
+        tar_reader.each do |file|
+          if file.file? && file_filter.call(file.full_name)
+            yield file.read, file.full_name
+          end
+        end
+      end
+    end
+
+    private
+
+    def gz(content)
+      require "zlib"
+
+      io = Zlib::GzipReader.new(StringIO.new(content))
+      begin
+        io.read
+      ensure
+        io.close
+      end
+    end
+  end
+end