bundler-alive 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f2a89085af5b9f1ee492cdbbe0e51fc27026c90760f77ebe0e7aa219b038d423
-  data.tar.gz: 619562e866a25a255516cbaaedf1a0ccc08c741d3f00bd6c5bd86455793d9db5
+  metadata.gz: cf64468693c247f87a2ffbce58960dd82d1313614d1433d0d032210f080e8fd4
+  data.tar.gz: a3d9f48ce1e8a932ae954897448acf7ab5cc82123992bd82b72ab33b7a8902b0
 SHA512:
-  metadata.gz: 5929a845890c5b50b6bd629296f4bd3f1c457791c6938f53203f464f99ac86634122500cd2e0dc5fc4276e42ef04ba30898ad91ede8546eb2c2cdf8fc9f6ac18
-  data.tar.gz: 4845907f1e0eedab0c1746a186dc613d31f2e680b8b0f24c08aa660dbd9467840c42a240cb22ab97e9ba46594be185158ae8c8f69752f4f7150585b849e239da
+  metadata.gz: 0c4d5747e3b1a133bcc8e1d757fb0ca790b280c667b7f2aa865c95363db66a878f2b0383d436a3b83cb43c19b28d06815c226d7fde09411d626ecdbc0508836f
+  data.tar.gz: e4ad9d70fb50258517e8cfbde02aea45435575e0e41435a26e9c5e35141b6df5e71bbebd85f11837afc6fdaa2b76c89508191234417214471f64c18b43d5f8d9

data/.rspec

@@ -2,3 +2,4 @@
 --color
 --warnings
 --require spec_helper
+--backtrace

data/Gemfile

@@ -17,7 +17,11 @@ group :development do
 end
 
 group :test do
-  gem "simplecov"
+  # Workaround for cc-test-reporter with SimpleCov 0.18.
+  # Stop upgrading SimpleCov until the following issue will be resolved.
+  # https://github.com/codeclimate/test-reporter/issues/418
+  gem "factory_bot"
+  gem "simplecov", "~> 0.10", "< 0.18"
   gem "vcr"
   gem "webmock"
 end

data/README.md

@@ -1,7 +1,9 @@
 # bundler-alive
 
-![bundler-alive](https://github.com/kyoshidajp/bundler-alive/actions/workflows/ci.yml/badge.svg)
 [![Gem Version](https://badge.fury.io/rb/bundler-alive.svg)](https://badge.fury.io/rb/bundler-alive)
+![bundler-alive](https://github.com/kyoshidajp/bundler-alive/actions/workflows/ci.yml/badge.svg)
+[![Maintainability](https://api.codeclimate.com/v1/badges/a79d53257bc5e93842f6/maintainability)](https://codeclimate.com/github/kyoshidajp/bundler-alive/maintainability)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/a79d53257bc5e93842f6/test_coverage)](https://codeclimate.com/github/kyoshidajp/bundler-alive/test_coverage)
 
 `bunder-alive` checks if gems in a RubyGem's `Gemfile.lock` are active.
 
@@ -17,10 +19,17 @@ $ gem install bunlder-alive
 
 ```
 $ bundle-alive
+6 gems are in Gemfile.lock
+..W....
+Get all source code repository URLs of gems are done!
+.....
 Name: journey
 URL: http://github.com/rails/journey
 Status: false
 
+Gem: bundle-alive is not found in RubyGems.org.
+
+Total: 6 (Dead: 1, Alive: 4, Unknown: 1)
 Not alive gems are found!
 ```
 
@@ -30,7 +39,7 @@ Default `Gemfile.lock` location is in your current directory. You can specify it
 $ bundle-alive -G /path/to/Gemfile.lock
 ```
 
-In most cases, the following error is output.
+In some cases, the following error is output.
 
 ```
 Too many requested! Retry later.

data/lib/bundler/alive/announcer.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "bundler"
+
+module Bundler
+  module Alive
+    #
+    # Announces check progress
+    #
+    class Announcer
+      DOT = "."
+
+      private_constant :DOT
+
+      #
+      # A new instance of Reporter
+      #
+      def initialize
+        @output = $stdout
+      end
+
+      def announce
+        output.write DOT
+      end
+
+      private
+
+      attr_reader :output
+    end
+  end
+end

data/lib/bundler/alive/cli.rb

@@ -2,6 +2,7 @@
 
 require "bundler/alive"
 require "bundler/alive/doctor"
+require "bundler/alive/reportable"
 
 require "thor"
 
@@ -17,19 +18,17 @@ module Bundler
       desc "check [DIR]", "Checks the Gemfile.lock"
       method_option :gemfile_lock, type: :string, aliases: "-G",
                                    default: "Gemfile.lock"
+      method_option :result, type: :string, aliases: "-r",
+                             default: "result.toml"
 
       def check(_dir = Dir.pwd)
-        doctor = check_by_doctor
+        extend Reportable
+        report = check_by_doctor
+        report.save_as_file(options[:result])
+        print_report(report)
 
-        if doctor.rate_limit_exceeded_error
-          puts "Too many requested! Retry later."
-          exit 1
-        end
-
-        exit 0 if doctor.all_alive
-
-        puts "Not alive gems are found!"
-        exit 1
+        exit_status = report.result.all_alive? ? 0 : 1
+        exit exit_status
       end
 
       desc "version", "Prints the bundler-alive version"
@@ -41,15 +40,12 @@ module Bundler
 
       def check_by_doctor
         doctor = begin
-          Doctor.new(options[:gemfile_lock])
+          Doctor.new(options[:gemfile_lock], options[:result])
         rescue Bundler::GemfileLockNotFound
           exit 1
         end
 
         doctor.diagnose
-        doctor.report
-        doctor.save_as_file
-        doctor
       end
     end
   end

data/lib/bundler/alive/client/gems_api_client.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+
+module Bundler
+  module Alive
+    module Client
+      #
+      # RubyGems.org API Client
+      #
+      # @see https://guides.rubygems.org/rubygems-org-api/
+      #
+      class GemsApiClient
+        #
+        # Not found in rubygems.org error
+        #
+        class NotFound < StandardError
+        end
+
+        def initialize
+          @error_messages = []
+        end
+
+        #
+        # Gets gems from RubyGems.org
+        #
+        # @param [Array<String>] gem_names
+        #
+        # @return [Client::GemsApiResponse]
+        #
+        def gems_api_response(gem_names, &block)
+          urls = service_with_urls(gem_names, &block)
+          $stdout.puts <<~MESSAGE
+
+            Get all source code repository URLs of gems are done!
+          MESSAGE
+          Client::GemsApiResponse.new(
+            service_with_urls: urls,
+            error_messages: error_messages
+          )
+        end
+
+        private
+
+        attr_accessor :error_messages
+
+        def api_url(gem_name)
+          "https://rubygems.org/api/v1/gems/#{gem_name}.json"
+        end
+
+        def connection
+          Faraday.new do |connection|
+            connection.adapter :net_http
+          end
+        end
+
+        def service_with_urls(gem_names, &block)
+          urls = get_repository_urls(gem_names, &block)
+          urls.each_with_object({}) do |url, hash|
+            service_name = url.service_name
+            hash[service_name] = Array(hash[service_name]) << url
+          end
+        end
+
+        #
+        # Returns repository url
+        #
+        # @param [String] gem_name
+        #
+        # @return [SourceCodeRepositoryUrl]
+        #
+        def get_repository_url(gem_name)
+          url = api_url(gem_name)
+          response = connection.get(url)
+
+          raise NotFound, "Gem: #{gem_name} is not found in RubyGems.org." unless response.success?
+
+          body = JSON.parse(response.body)
+          raw_url = source_code_url(body: body, gem_name: gem_name)
+          SourceCodeRepositoryUrl.new(raw_url, gem_name)
+        end
+
+        def source_code_url(body:, gem_name:)
+          url = body["source_code_uri"]
+          return url if SourceCodeRepositoryUrl.support_url?(url)
+
+          url = body["homepage_uri"]
+          return url if SourceCodeRepositoryUrl.support_url?(url)
+
+          raise NotFound, "[#{gem_name}] source code repository is not found in RubyGems.org."
+        end
+
+        def get_repository_urls(gem_names)
+          result = gem_names.map do |gem_name|
+            yield if block_given?
+            get_repository_url(gem_name)
+          rescue StandardError => e
+            $stdout.write "W"
+            error_messages << e.message
+          end
+
+          result.find_all { |obj| obj.instance_of?(Alive::SourceCodeRepositoryUrl) }
+        end
+      end
+    end
+  end
+end

data/lib/bundler/alive/client/gems_api_response.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Bundler
+  module Alive
+    module Client
+      #
+      # Represents API Response of RubyGems.org
+      #
+      class GemsApiResponse
+        attr_reader :service_with_urls, :error_messages
+
+        #
+        # Creates a new StatusResult instance
+        #
+        # @param [StatusCollection|nil] :collection
+        # @param [Array] :error_messages
+        #
+        # @return [GemsApiResponse]
+        #
+        def initialize(service_with_urls:, error_messages:)
+          @service_with_urls = service_with_urls
+          @error_messages = error_messages
+
+          freeze
+        end
+      end
+    end
+  end
+end

data/lib/bundler/alive/client/git_hub_api.rb

@@ -9,9 +9,36 @@ module Bundler
       #
       # API Client for GitHub API
       #
+      # @see https://docs.github.com/en/rest/search#search-repositories
+      #
       module GitHubApi
+        # Environment variable name of GitHub Access Token
         ACCESS_TOKEN_ENV_NAME = "BUNDLER_ALIVE_GITHUB_TOKEN"
 
+        # Separator of query condition
+        QUERY_CONDITION_SEPARATOR = " "
+
+        # Number of attempts to request after too many requests
+        RETRIES_ON_TOO_MANY_REQUESTS = 3
+
+        # Interval second when retrying request
+        RETRY_INTERVAL_SEC_ON_TOO_MANY_REQUESTS = 120
+
+        #
+        # Max number of conditional operator at once
+        #
+        # @see https://docs.github.com/en/rest/search#limitations-on-query-length
+        QUERY_MAX_OPERATORS_AT_ONCE = 6
+
+        private_constant :QUERY_MAX_OPERATORS_AT_ONCE
+
+        def self.extended(base)
+          base.instance_eval do
+            @rate_limit_exceeded = false
+            @retries_on_too_many_requests = 0
+          end
+        end
+
         #
         # Creates a GitHub client
         #
@@ -22,39 +49,112 @@ module Bundler
         end
 
         #
-        # Returns repository URL is archived?
+        # Query repository statuses
+        #
+        # @param [Array<RepositoryUrl>] :urls
+        #
+        # @return [StatusResult]
+        #
+        # rubocop:disable Metrics/MethodLength
+        def query(urls:)
+          collection = StatusCollection.new
+          name_with_archived = get_name_with_statuses(urls)
+          urls.each do |url|
+            yield if block_given?
+
+            gem_name = url.gem_name
+            alive = !name_with_archived[gem_name]
+            status = Status.new(name: gem_name, repository_url: url, alive: alive, checked_at: Time.now)
+            collection = collection.add(gem_name, status)
+          end
+
+          StatusResult.new(collection: collection, error_messages: @error_messages,
+                           rate_limit_exceeded: @rate_limit_exceeded)
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        private
+
+        #
+        # Search status of repositories
         #
-        # @param [SourceCodeRepositoryUrl] repository_url
+        # @param [Array<RepositoryUrl>] urls
         #
-        # @raise [ArgumentError]
-        #   when repository_uri is not `SourceCodeRepositoryUrl`
+        # @return [Hash<String, Boolean>]
+        #   gem name with archived or not
+        #
+        # rubocop:disable Metrics/MethodLength
+        def get_name_with_statuses(urls)
+          raise ArgumentError unless urls.instance_of?(Array)
+
+          name_with_status = {}
+          urls.each_slice(QUERY_MAX_OPERATORS_AT_ONCE) do |sliced_urls|
+            q = search_query(sliced_urls)
+            repositories = search_repositories_with_retry(q)
+            next if repositories.nil?
+
+            repositories.each do |repository|
+              name = repository["name"]
+              name_with_status[name] = repository["archived"]
+            end
+          end
+          name_with_status
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        #
+        # Search query of repositories
+        #
+        # @param [Array<RepositoryUrl>] urls
+        #
+        # @return [String]
+        #
+        def search_query(urls)
+          urls.map do |url|
+            "repo:#{slug(url.url)}"
+          end.join(QUERY_CONDITION_SEPARATOR)
+        end
+
+        #
+        # Search repositories
+        #
+        # @param [String] query
         #
         # @raise [Octokit::TooManyRequests]
         #   when too many requested to GitHub.com
-        #
         # @raise [SourceCodeClient::SearchRepositoryError]
         #   when Error without `Octokit::TooManyRequests`
         #
-        # @return [Boolean]
+        # @return [Array<Sawyer::Resource>|nil]
         #
-        # rubocop:disable Metrics/MethodLength
-        def archived?(repository_url)
-          unless repository_url.instance_of?(SourceCodeRepositoryUrl)
-            raise ArgumentError, "UnSupported url: #{repository_url}"
+        def search_repositories(query)
+          result = @client.search_repositories(query)
+          result[:items]
+        rescue Octokit::TooManyRequests => e
+          raise e
+        rescue StandardError => e
+          @error_messages << e.message
+          []
+        end
+
+        def search_repositories_with_retry(query)
+          search_repositories(query)
+        rescue Octokit::TooManyRequests
+          if @retries_on_too_many_requests < RETRIES_ON_TOO_MANY_REQUESTS
+            @retries_on_too_many_requests += 1
+            sleep_with_message
+            retry
           end
 
-          query = "repo:#{slug(repository_url.url)}"
+          @rate_limit_exceeded = true
+          []
+        end
 
-          begin
-            result = @client.search_repositories(query)
-            result[:items][0][:archived]
-          rescue Octokit::TooManyRequests => e
-            raise SourceCodeClient::RateLimitExceededError, e.message
-          rescue StandardError => e
-            raise SourceCodeClient::SearchRepositoryError, e.message
-          end
+        def sleep_with_message
+          puts "Too many requested. Sleep #{RETRY_INTERVAL_SEC_ON_TOO_MANY_REQUESTS} sec."
+          sleep RETRY_INTERVAL_SEC_ON_TOO_MANY_REQUESTS
+          puts "Retry request (#{@retries_on_too_many_requests}/#{RETRIES_ON_TOO_MANY_REQUESTS})"
         end
-        # rubocop:enable Metrics/MethodLength
 
         #
         # Returns slug of repository URL

data/lib/bundler/alive/client/source_code_client.rb

@@ -7,9 +7,11 @@ module Bundler
       # Represents a source code client
       #
       class SourceCodeClient
+        # Error of searching repository
         class SearchRepositoryError < StandardError
         end
 
+        # Error of rate limit exceeded
         class RateLimitExceededError < StandardError
         end
 
@@ -31,10 +33,11 @@ module Bundler
         def initialize(service_name:)
           raise ArgumentError, "Unknown service: #{service_name}" unless SERVICE_WITH_STRATEGIES.key?(service_name)
 
-          service = SERVICE_WITH_STRATEGIES[service_name]
-          extend service
+          strategy = SERVICE_WITH_STRATEGIES[service_name]
+          extend strategy
 
           @client = create_client
+          @error_messages = []
 
           super()
         end

data/lib/bundler/alive/doctor.rb

@@ -10,113 +10,118 @@ module Bundler
     # Diagnoses a `Gemfile.lock` with a TOML file
     #
     class Doctor
-      attr_reader :all_alive, :rate_limit_exceeded_error
-
       #
       # A new instance of Doctor
       #
       # @param [String] lock_file lock file of gem
       # @param [String] result_file file of result
       #
-      def initialize(lock_file, result_file = "result.toml")
+      def initialize(lock_file, result_file)
         @lock_file = lock_file
         @result_file = result_file
-        @gem_client = Client::GemsApi.new
+        @gem_client = Client::GemsApiClient.new
         @result = nil
-        @all_alive = nil
-        @rate_limit_exceeded_error = false
+        @rate_limit_exceeded = false
+        @announcer = Announcer.new
+        @error_messages = []
       end
 
       #
       # Diagnoses gems in lock file of gem
       #
+      # @raise [Client::SourceCodeClient::RateLimitExceededError]
+      #   When exceeded access rate limit
+      #
+      # @raise [StandardError]
+      #   When raised unexpected error
+      #
+      # @return [Report]
+      #
       def diagnose
-        @result = gems.each_with_object(GemStatusCollection.new) do |spec, collection|
-          gem_name = spec.name
-          gem_status = diagnose_gem(gem_name)
-
-          collection.add(gem_name, gem_status)
-        end
+        $stdout.puts "#{collection_from_gemfile.total_size} gems are in Gemfile.lock"
+        result = _diagnose
+        Report.new(result)
       end
 
+      private
+
+      attr_reader :lock_file, :result_file, :gem_client, :announcer,
+                  :result, :error_messages, :rate_limit_exceeded
+
       #
-      # Reports the result
+      # @return [Array<String>]
       #
-      def report
-        need_to_report_gems = result.need_to_report_gems
-        @all_alive = need_to_report_gems.size.zero?
-        need_to_report_gems.each do |_name, gem_status|
-          print gem_status.report
+      def no_need_to_get_gems
+        return [] unless File.exist?(result_file)
+
+        toml_hash = TomlRB.load_file(result_file)
+        toml_hash.each_with_object([]) do |(gem_name, v), array|
+          alive = v["alive"]
+          array << gem_name unless alive
         end
       end
 
-      #
-      # Saves result to file
-      #
-      def save_as_file
-        body = TomlRB.dump(result.to_h)
-        File.write(result_file, body)
+      def diagnose_by_service(service, urls)
+        client = Client::SourceCodeClient.new(service_name: service)
+        client.query(urls: urls) do
+          announcer.announce
+        end
       end
 
-      private
+      def result_by_search(collection)
+        gems_api_response = gem_client.gems_api_response(collection.names) do
+          announcer.announce
+        end
 
-      attr_reader :lock_file, :result_file, :gem_client, :result
+        service_with_urls = gems_api_response.service_with_urls
+        error_messages.concat(gems_api_response.error_messages)
 
-      def diagnosed_gem?(gem_status)
-        !gem_status.nil? && !gem_status.unknown?
+        result = StatusResult.new
+        service_with_urls.each do |service, urls|
+          result = result.merge(diagnose_by_service(service, urls))
+        end
+        result
       end
 
-      def collection_from_file
-        return @collection_from_file if instance_variable_defined?(:@collection_from_file)
-
-        return GemStatusCollection.new unless File.exist?(result_file)
+      def fetch_target_collection(base_collection, gem_names)
+        collection = StatusCollection.new
+        base_collection.each do |name, status|
+          next if gem_names.include?(name)
 
-        toml_hash = TomlRB.load_file(result_file)
-        @collection_from_file = collection_from_hash(toml_hash)
+          collection = collection.add(name, status)
+        end
+        collection
       end
 
-      def collection_from_hash(hash)
-        hash.each_with_object(GemStatusCollection.new) do |(gem_name, v), collection|
-          url = v["repository_url"]
-          next if url.to_sym == GemStatus::REPOSITORY_URL_UNKNOWN
-
-          gem_status = GemStatus.new(name: gem_name,
-                                     repository_url: SourceCodeRepositoryUrl.new(url),
-                                     alive: v["alive"],
-                                     checked_at: v["checked_at"])
-          collection.add(gem_name, gem_status)
+      def collection_from_gemfile
+        gems_from_lockfile.each_with_object(StatusCollection.new) do |gem, collection|
+          gem_name = gem.name
+          status = Status.new(name: gem_name,
+                              repository_url: nil,
+                              alive: nil,
+                              checked_at: nil)
+          collection.add(gem_name, status)
         end
       end
 
-      def gems
-        lock_file_body = File.read(@lock_file)
-        lock_file = Bundler::LockfileParser.new(lock_file_body)
-        lock_file.specs.each
+      def _diagnose
+        collection = fetch_target_collection(collection_from_gemfile, no_need_to_get_gems)
+        result = result_by_search(collection)
+        collection_from_toml_file = StatusCollection.new_from_toml_file(result_file)
+        new_collection = collection_from_gemfile.merge(collection_from_toml_file)
+                                                .merge(result.collection)
+
+        messages = error_messages.concat(result.error_messages)
+        StatusResult.new(collection: new_collection,
+                         error_messages: messages,
+                         rate_limit_exceeded: result.rate_limit_exceeded)
       end
 
-      # rubocop:disable Metrics/MethodLength
-      def diagnose_gem(gem_name)
-        gem_status = collection_from_file.get_unchecked(gem_name)
-        return gem_status if diagnosed_gem?(gem_status)
-
-        unless @rate_limit_exceeded_error
-          begin
-            source_code_url = gem_client.get_repository_url(gem_name)
-            is_alive = SourceCodeRepository.new(url: source_code_url).alive?
-          rescue Client::SourceCodeClient::RateLimitExceededError => e
-            @rate_limit_exceeded_error = true
-            puts e.message
-          rescue StandardError => e
-            puts e.message
-          end
-        end
-
-        GemStatus.new(name: gem_name,
-                      repository_url: source_code_url,
-                      alive: is_alive,
-                      checked_at: Time.now)
+      def gems_from_lockfile
+        lock_file_body = File.read(@lock_file)
+        lock_file = Bundler::LockfileParser.new(lock_file_body)
+        lock_file.specs
       end
-      # rubocop:enable Metrics/MethodLength
     end
   end
 end