bundler-alive 0.1.1 → 0.1.4

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

data/lib/bundler/alive/report.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Bundler
+  module Alive
+    #
+    # Represents Report
+    #
+    class Report
+      attr_reader :result, :error_messages, :rate_limit_exceeded
+
+      #
+      # A result of report
+      #
+      # @param [StatusResult] result
+      #
+      def initialize(result)
+        @result = result.collection
+        @error_messages = result.error_messages
+        @rate_limit_exceeded = result.rate_limit_exceeded
+
+        freeze
+      end
+
+      #
+      # Save result to file
+      #
+      # @param [String] file_path
+      #
+      def save_as_file(file_path)
+        body = TomlRB.dump(result.to_h)
+        File.write(file_path, body)
+      end
+    end
+  end
+end

data/lib/bundler/alive/reportable.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "bundler"
+
+require "thor"
+
+module Bundler
+  module Alive
+    class CLI < ::Thor
+      #
+      # Reports
+      #
+      module Reportable
+        #
+        # Reports result
+        #
+        # @param [Report] report
+        #
+        def print_report(report)
+          result = report.result
+          error_messages = report.error_messages
+          print_error(error_messages)
+
+          gems = result.need_to_report_gems
+          $stdout.puts if gems.size.positive?
+          gems.each do |_name, gem|
+            $stdout.puts gem.report
+          end
+
+          print_summary(result)
+          print_message(result, report.rate_limit_exceeded)
+        end
+
+        private
+
+        def print_error(error_messages)
+          return if error_messages.nil?
+
+          $stdout.puts <<~ERROR
+
+            #{error_messages.join("\n")}
+          ERROR
+        end
+
+        def print_summary(result)
+          $stdout.puts <<~RESULT
+            Total: #{result.total_size} (Dead: #{result.dead_size}, Alive: #{result.alive_size}, Unknown: #{result.unknown_size})
+          RESULT
+        end
+
+        def print_message(result, rate_limit_exceeded)
+          if result.all_alive?
+            say "All gems are alive!", :green
+            return
+          end
+
+          say "Too many requested! Retry later.", :yellow if rate_limit_exceeded
+          if result.dead_size.positive?
+            say "Not alive gems are found!", :red
+            return
+          end
+          say "Unknown gems are found!", :yellow if result.unknown_size.positive?
+        end
+      end
+    end
+  end
+end

data/lib/bundler/alive/source_code_repository.rb

@@ -17,21 +17,11 @@ module Bundler
         raise ArgumentError, "Unknown url: #{url}" unless url.instance_of?(SourceCodeRepositoryUrl)
 
         @url = url
-        @client = Client::SourceCodeClient.new(service_name: url.service_name)
-      end
-
-      #
-      # Returns alive or not
-      #
-      # @return [Boolean]
-      #
-      def alive?
-        !client.archived?(url)
       end
 
       private
 
-      attr_reader :url, :client
+      attr_reader :url
     end
   end
 end

data/lib/bundler/alive/source_code_repository_url.rb

@@ -4,41 +4,74 @@ module Bundler
   module Alive
     # Represents a source code repository
     class SourceCodeRepositoryUrl
+      # service domain with service
       DOMAIN_WITH_SERVICES = {
-        "github.com" => SourceCodeRepository::Service::GITHUB
+        "github.com" => SourceCodeRepository::Service::GITHUB,
+        "www.github.com" => SourceCodeRepository::Service::GITHUB
       }.freeze
 
       private_constant :DOMAIN_WITH_SERVICES
 
+      #
+      # Judge supported url or not
+      #
+      # @param [String] url
+      #
+      # @return [Boolean]
+      #
+      def self.support_url?(url)
+        return false if url.nil?
+
+        uri = URI.parse(url)
+        host = uri.host
+
+        DOMAIN_WITH_SERVICES.key?(host)
+      end
+
       # No supported URL Error
       class UnSupportedUrl < StandardError
-        def initialize(url)
-          message = "UnSupported URL: #{url}"
+        #
+        # @param [String] :url
+        # @param [String] :name
+        #
+        # @return [UnSupportedUrl]
+        #
+        def initialize(url:, name:)
+          decorated_url = if url.nil? || url == ""
+                            "(blank)"
+                          else
+                            url
+                          end
+          message = "[#{name}] is not support URL: #{decorated_url}"
           super(message)
         end
       end
 
-      attr_reader :url, :service_name
+      attr_reader :url, :service_name, :gem_name
 
       #
       # Creates a `SourceCodeRepositoryUrl`
       #
       # @param [String] url
+      # @param [String] name
       #
       # @raise [UnSupportedUrl]
       #
-      def initialize(url)
+      def initialize(url, name)
+        raise UnSupportedUrl.new(url: url, name: name) if url.nil?
+
         @url = url
-        @service_name = service(url)
+        @service_name = service(url: url, name: name)
+        @gem_name = name
       end
 
       private
 
-      def service(url)
+      def service(url:, name:)
         uri = URI.parse(url)
         host = uri.host
 
-        raise UnSupportedUrl, url unless DOMAIN_WITH_SERVICES.key?(host)
+        raise UnSupportedUrl.new(url: url, name: name) unless DOMAIN_WITH_SERVICES.key?(host)
 
         DOMAIN_WITH_SERVICES[host]
       end

data/lib/bundler/alive/{gem_status.rb → status.rb}

@@ -3,15 +3,30 @@
 module Bundler
   module Alive
     #
-    # Result of gem status
+    # Represents Status
     #
-    class GemStatus
-      REPOSITORY_URL_UNKNOWN = :unknown
-      ALIVE_UNKNOWN = :unknown
+    class Status
+      # Value of repository URL unknown
+      REPOSITORY_URL_UNKNOWN = "unknown"
+
+      # Value off alive unknown
+      ALIVE_UNKNOWN = "unknown"
 
       attr_reader :name, :repository_url, :alive, :checked_at
 
+      #
+      # Creates instance of `Status`
+      #
+      # @param [String] :name
+      # @param [SourceCodeRepositoryUrl] :repository_url
+      # @param [Boolean] :alive
+      # @param [] :checked_at
+      #
+      # @return [Status]
+      #
       def initialize(name:, repository_url:, alive:, checked_at:)
+        raise ArgumentError if !repository_url.nil? && !repository_url.instance_of?(SourceCodeRepositoryUrl)
+
         repository_url = REPOSITORY_URL_UNKNOWN if repository_url.nil?
         alive = ALIVE_UNKNOWN if alive.nil?
 
@@ -24,7 +39,7 @@ module Bundler
       end
 
       #
-      # Alive?
+      # Is status of alive unknown?
       #
       # @return [Boolean]
       #
@@ -39,7 +54,7 @@ module Bundler
         {
           repository_url: decorated_repository_url,
           alive: decorated_alive,
-          checked_at: checked_at
+          checked_at: checked_at || ""
         }
       end
 
@@ -61,7 +76,7 @@ module Bundler
 
       def decorated_repository_url
         if repository_url == REPOSITORY_URL_UNKNOWN
-          REPOSITORY_URL_UNKNOWN.to_s
+          REPOSITORY_URL_UNKNOWN
         else
           repository_url.url
         end
@@ -69,7 +84,7 @@ module Bundler
 
       def decorated_alive
         if alive == ALIVE_UNKNOWN
-          ALIVE_UNKNOWN.to_s
+          ALIVE_UNKNOWN
         else
           alive
         end

data/lib/bundler/alive/status_collection.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Bundler
+  module Alive
+    # Collection of `Status`
+    class StatusCollection
+      extend Forwardable
+      delegate each: :collection
+      delegate values: :collection
+
+      attr_reader :alive_size, :dead_size, :unknown_size
+
+      #
+      # Creates `StatusCollection` from TOML file
+      #
+      # @param [String] path
+      #
+      # @return [StatusCollection]
+      #
+      def self.new_from_toml_file(path)
+        return new unless File.exist?(path)
+
+        collection = new
+        TomlRB.load_file(path).each do |name, v|
+          next if v["alive"] == Status::ALIVE_UNKNOWN
+
+          url = SourceCodeRepositoryUrl.new(v["repository_url"], name)
+          status = Status.new(name: name, repository_url: url,
+                              alive: v["alive"], checked_at: v["checked_at"])
+          collection = collection.add(name, status)
+        end
+
+        collection
+      end
+
+      #
+      # Generates instance of `StatusCollection`
+      #
+      # @param [StatusCollection|nil] collection
+      #
+      # @return [StatusCollection]
+      #
+      def initialize(collection = {})
+        @collection = collection
+        @statuses_values = collection.values || []
+
+        @alive_size = _alive_size
+        @unknown_size = _unknown_size
+        @dead_size = _dead_size
+        freeze
+      end
+
+      #
+      # Fetch `Status` of `name`
+      #
+      # @param [String] name
+      #
+      # @return [Status]
+      #
+      def [](name)
+        collection[name]
+      end
+
+      #
+      # Names of gems
+      #
+      # @return [Array<String>]
+      #
+      def names
+        values.map(&:name)
+      end
+
+      #
+      # Add status
+      #
+      # @param [String] name
+      # @param [Status] status
+      #
+      # @return [StatusCollection]
+      #
+      def add(name, status)
+        collection[name] = status
+
+        self.class.new(collection)
+      end
+
+      #
+      # Merge collection
+      #
+      # @param [StatusCollection] collection
+      #
+      # @return [StatusCollection]
+      #
+      def merge(collection)
+        return self.class.new(self.collection) if collection.nil?
+
+        collection.each do |k, v|
+          self.collection[k] = v
+        end
+
+        self.class.new(self.collection)
+      end
+
+      def to_h
+        collection.transform_values(&:to_h)
+      end
+
+      def need_to_report_gems
+        collection.find_all { |_name, gem| !!!gem.alive }
+      end
+
+      #
+      # All of statuses are alive nor not
+      #
+      # @return [Boolean]
+      #
+      def all_alive?
+        collection.find { |_name, status| !!!status.alive || status.unknown? }.nil?
+      end
+
+      #
+      # Total size of collection
+      #
+      # @return [Integer]
+      #
+      def total_size
+        collection.size
+      end
+
+      private
+
+      attr_reader :collection, :statuses_values
+
+      def _alive_size
+        statuses_values.count { |gem| !!gem.alive && !gem.unknown? }
+      end
+
+      def _dead_size
+        statuses_values.count { |gem| !gem.alive && !gem.unknown? }
+      end
+
+      def _unknown_size
+        statuses_values.count { |gem| gem.alive == Status::ALIVE_UNKNOWN }
+      end
+    end
+  end
+end

data/lib/bundler/alive/status_result.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Bundler
+  module Alive
+    #
+    # Represents Result of Status
+    #
+    class StatusResult
+      attr_reader :collection, :error_messages, :rate_limit_exceeded
+
+      #
+      # Creates a new StatusResult instance
+      #
+      # @param [StatusCollection|nil] :collection
+      # @param [Array|nil] :error_messages
+      # @param [Boolean|nil] :rate_limit_exceeded
+      #
+      # @return [StatusResult]
+      #
+      def initialize(collection: nil, error_messages: nil, rate_limit_exceeded: nil)
+        @collection = collection
+        @error_messages = error_messages
+        @rate_limit_exceeded = rate_limit_exceeded
+      end
+
+      #
+      # Merge `StatusResult`, then returns new one
+      #
+      # @param [StatusResult] result
+      #
+      # @return [StatusResult]
+      #
+      def merge(result)
+        self.class.new(collection: result.collection,
+                       error_messages: result.error_messages,
+                       rate_limit_exceeded: result.rate_limit_exceeded)
+      end
+    end
+  end
+end

data/lib/bundler/alive/version.rb

@@ -2,6 +2,6 @@
 
 module Bundler
   module Alive
-    VERSION = "0.1.1"
+    VERSION = "0.1.4"
   end
 end

data/lib/bundler/alive.rb

@@ -4,8 +4,13 @@ require_relative "alive/version"
 require_relative "alive/doctor"
 require_relative "alive/source_code_repository"
 require_relative "alive/source_code_repository_url"
-require_relative "alive/gem_status"
-require_relative "alive/gem_status_collection"
-require_relative "alive/client/gems_api"
+require_relative "alive/status"
+require_relative "alive/status_result"
+require_relative "alive/status_collection"
+require_relative "alive/announcer"
+require_relative "alive/report"
+require_relative "alive/client/gems_api_client"
+require_relative "alive/client/gems_api_response"
 require_relative "alive/client/git_hub_api"
 require_relative "alive/client/source_code_client"
+require_relative "alive/reportable"