gem_lookup 1.0.0

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+
+task default: :spec

data/bin/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+ENV['APP_ENV'] = 'development'
+require_relative '../booster_pack'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+Pry.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/booster_pack.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative 'init/environment'
+require_relative 'init/bundler'
+require_relative 'init/zeitwerk'

data/exe/gems

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+# frozen_string_literal: true
+
+ENV['APP_ENV'] = 'production'
+require_relative '../booster_pack'
+
+GemLookup::RubyGems.new(ARGV).find_all

data/gem_lookup.gemspec

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'lib/gem_lookup/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'gem_lookup'
+  spec.version       = GemLookup::VERSION
+  spec.authors       = ['Josh Mills']
+  spec.email         = ['josh@trueheart78.com']
+
+  spec.summary       = 'Retrieves gem-related information from https://rubygems.org'
+  spec.description   = <<~DESC
+    Simple but effective command line interface that looks up gems using RubyGems.org's public API
+    and displays results in an emoji-filled fashion.
+  DESC
+  spec.homepage      = 'https://github.com/trueheart78/gem_lookup'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.4.0')
+
+  spec.metadata = {
+    'bug_tracker_uri'   => 'https://github.com/trueheart78/gem_lookup/issues',
+    'changelog_uri'     => 'https://github.com/trueheart78/gem_lookup/blob/main/CHANGELOG.md',
+    'documentation_uri' => spec.homepage,
+    'homepage_uri'      => spec.homepage,
+    'source_code_uri'   => "https://github.com/trueheart78/gem_lookup/tree/v#{GemLookup::VERSION}"
+  }
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject {|f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{\Aexe/}) {|f| File.basename(f) }
+
+  # These gems need to be explicitly required to be utilized.
+  spec.add_runtime_dependency 'colorize', '~> 0.8.1'
+  spec.add_runtime_dependency 'typhoeus', '~> 1.4'
+  spec.add_runtime_dependency 'zeitwerk', '~> 2.4.2'
+
+  # Development and test dependencies are defined in the Gemfile due to ENV['APP_ENV'] usage.
+end

data/init/bundler.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'rubygems'
+require 'bundler'
+
+Bundler.require(:default, ENV['APP_ENV'].to_sym)

data/init/environment.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+ENV['APP_ENV'] = 'development' unless ENV['APP_ENV']

data/init/zeitwerk.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'zeitwerk'
+
+loader = Zeitwerk::Loader.new
+
+root_dir = File.expand_path(File.dirname(File.dirname(__FILE__)))
+
+loader.push_dir(File.join(root_dir, 'lib'))
+
+loader.push_dir(File.join(root_dir, 'spec'))
+loader.ignore(File.join(root_dir, '**', '*_spec.rb'))
+loader.setup

data/lib/gem_lookup.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative '../booster_pack'

data/lib/gem_lookup/errors.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module GemLookup
+  module Errors
+    class InvalidDisplayMode < StandardError; end
+
+    class UndefinedInterfaceMethod < StandardError; end
+
+    class UnsupportedFlags < StandardError; end
+
+    class UnsupportedFlag < StandardError; end
+  end
+end

data/lib/gem_lookup/flags.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'colorize'
+
+module GemLookup
+  class Flags
+    class << self
+      # Returns the supported flags.
+      # @return [Hash] the supported flags.
+      def supported
+        {
+          help:    { matches: %w[-h --help], desc: 'Display the help screen.' },
+          version: { matches: %w[-v --version], desc: 'Display version information.' },
+          json:    { matches: %w[-j --json], desc: 'Bulk the output results as raw JSON.' },
+          wordy:   { matches: %w[-w --wordy], desc: 'Stream the output using only words.' }
+        }
+      end
+
+      # Checks to see if any flags passed in match those defined by the type.
+      # @param type [Symbol] the type of flag (`:help`, `:version`, etc).
+      # @param flags [Array] an array that may or may not contain a supported flag.
+      # @return [Boolean] whether the flags passed in contain a flag supported by type.
+      def supported?(type, flags: [])
+        return false if type.nil?
+        return false if flags.empty?
+
+        type = type.to_sym
+        return false unless supported.key? type
+
+        supported[type][:matches].each do |flag|
+          return true if flags.include? flag
+        end
+
+        false
+      end
+
+      # Outputs the unsupported flags and exits with a code of 1.
+      # @param flags [Array] the list of unsupported flags.
+      def unsupported(flags:)
+        flags = flags.compact.reject(&:empty?)
+        return false unless flags.any?
+
+        raise Errors::UnsupportedFlag, flags.first if flags.size == 1
+
+        raise Errors::UnsupportedFlags, flags.join(', ')
+      end
+    end
+  end
+end

data/lib/gem_lookup/gems.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module GemLookup
+  class Gems
+    extend Forwardable
+
+    def_delegators :@serializer, :display, :batch_iterator, :gem_count, :querying, :streaming?
+
+    def initialize(gem_list, serializer:)
+      @gem_list = gem_list
+      @serializer = serializer
+      @batches = []
+      @json = { gems: [] }
+    end
+
+    def process
+      batch_gems
+      process_batches
+    end
+
+    private
+
+    def process_batches
+      display_gem_count
+
+      @batches.each_with_index {|batch, index| process_batch batch: batch, index: index }
+
+      display(json: @json) unless streaming?
+    end
+
+    def process_batch(batch:, index:)
+      display_batch_details(index + 1, @batches.size, batch)
+
+      make_requests batch: batch
+      display_results
+
+      sleep RateLimit.interval if batch_mode?
+    end
+
+    def make_requests(batch:)
+      @json = Requests.new(batch: batch, json: @json).process
+    end
+
+    def batch_gems
+      gems = @gem_list.dup
+
+      @batches.push gems.shift(RateLimit.number) while gems.any?
+    end
+
+    def batch_mode?
+      @batches.size > 1
+    end
+
+    def display_gem_count
+      return unless streaming?
+
+      gem_count(num: @gem_list.size) if @gem_list.size > 1
+    end
+
+    def display_batch_details(num, total, batch)
+      return unless streaming?
+
+      batch_iterator(num: num, total: total) if batch_mode?
+      querying(batch: batch)
+    end
+
+    def display_results
+      return unless streaming?
+
+      display(json: @json[:gems].shift) while @json[:gems].any?
+    end
+  end
+end

data/lib/gem_lookup/help.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module GemLookup
+  class Help
+    # @return [Numeric] the spacing for output options
+    OUTPUT_OPTION_SPACING = 21
+
+    class << self
+      # Outputs the generated content.
+      # @param exit_code [Numeric, nil] the exit code (if any) to exit with.
+      def display(exit_code: nil)
+        puts documentation
+
+        exit exit_code unless exit_code.nil?
+      end
+
+      # Outputs the gem name and current gem version.
+      # @param exit_code [Numeric, nil] the exit code (if any) to exit with.
+      def version(exit_code: nil)
+        puts "#{NAME} #{VERSION}"
+
+        exit exit_code unless exit_code.nil?
+      end
+
+      # Generates the help documentation.
+      # @return [String] the help documentation.
+      def documentation
+        <<~HELP
+
+          Usage: gems [OPTIONS] GEMS
+
+            Retrieves gem-related information from https://rubygems.org
+
+          Example: gems -j rails rspec
+
+          This application's purpose is to make working with with RubyGems.org easier. 💖
+          It uses the RubyGems public API to perform lookups, and parses the JSON response
+          body to provide details about the most recent version, as well as links to
+          the home page, source code, changelog, and mailing list.
+
+          Feel free to pass in as many gems that you like, as it makes requests in
+          parallel. There is a rate limit, #{RateLimit.number}/sec. If it detects the amount of gems it
+          has been passed is more than the rate limit, the application will run in Batch
+          mode, and introduce a one second delay between batch lookups.
+
+          #{options}
+
+          Rate limit documentation: #{RateLimit.documentation_url}
+        HELP
+      end
+
+      private
+
+      # Generates an Output Options string that includes the supported flag details.
+      # @return [String] the supported output options.
+      def options
+        <<~OPTIONS.chomp
+          Output Options:
+          #{flag_output}
+        OPTIONS
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      # Generates a formatted string that displays the supported flag details.
+      # @return [String] the supported flags and their details.
+      def flag_output
+        [].tap do |output|
+          Flags.supported.keys.sort.each do |key|
+            matches = Flags.supported[key][:matches].join ' '
+            spaces = ' ' * (OUTPUT_OPTION_SPACING - matches.length)
+            output.push "  #{matches}#{spaces}#{Flags.supported[key][:desc]}"
+          end
+        end.join "\n"
+      end
+      # rubocop:enable Metrics/AbcSize
+    end
+  end
+end

data/lib/gem_lookup/rate_limit.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module GemLookup
+  module RateLimit
+    # @return [Numeric] the max requests that can be made per interval.
+    MAX_REQUESTS_PER_INTERVAL = 10
+
+    # @return [Numeric] the frequency interval, in seconds.
+    FREQUENCY_INTERVAL_IN_SECONDS = 1
+
+    # @return [String] the url that documents the rate limit
+    RATE_LIMIT_DOCUMENTATION_URL = 'https://guides.rubygems.org/rubygems-org-rate-limits/'
+
+    class << self
+      # Calls MAX_REQUESTS_PER_SECOND.
+      # @return [Numeric] the max requests that can be made per interval.
+      def number
+        MAX_REQUESTS_PER_INTERVAL
+      end
+
+      # Calls FREQUENCY_INTERVAL_IN_SECONDS
+      # @return [Numeric] the frequency interval, in seconds.
+      def interval
+        FREQUENCY_INTERVAL_IN_SECONDS
+      end
+
+      # Calls RATE_LIMIT_DOCUMENTATION_URL.
+      # @return [String] the url that documents the rate limit.
+      def documentation_url
+        RATE_LIMIT_DOCUMENTATION_URL
+      end
+    end
+  end
+end

data/lib/gem_lookup/requests.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'typhoeus'
+require 'json'
+
+module GemLookup
+  class Requests
+    # @return [Numeric] the seconds to wait before a response is considered timed out.
+    TIMEOUT_THRESHOLD = 10
+
+    def initialize(batch:, json: nil)
+      @batch = batch
+      @json = json || { gems: [] }
+    end
+
+    def process
+      Typhoeus::Hydra.hydra.tap do |hydra|
+        populate_requests hydra: hydra, batch: @batch
+      end.run
+
+      @json
+    end
+
+    private
+
+    def populate_requests(hydra:, batch:)
+      batch.each do |gem_name|
+        hydra.queue build_request gem_name: gem_name
+      end
+    end
+
+    # rubocop:disable Layout/LineLength
+    def build_request(gem_name:)
+      url = api_url gem_name: gem_name
+      Typhoeus::Request.new(url, accept_encoding: 'gzip', timeout: TIMEOUT_THRESHOLD).tap do |request|
+        request.on_complete do |response|
+          if response.success?
+            handle_successful_response json: JSON.parse(response.body, symbolize_names: true)
+          elsif response.timed_out?
+            handle_timed_out_response gem_name: gem_name
+          else
+            handle_failed_response gem_name: gem_name
+          end
+        end
+      end
+    end
+    # rubocop:enable Layout/LineLength
+
+    def handle_successful_response(json:)
+      json[:exists] = true
+      json[:timeout] = false
+      @json[:gems].push json
+    end
+
+    def handle_timed_out_response(gem_name:)
+      json = { name: gem_name, exists: false, timeout: true }
+      @json[:gems].push json
+    end
+
+    def handle_failed_response(gem_name:)
+      json = { name: gem_name, exists: false, timeout: false }
+      @json[:gems].push json
+    end
+
+    def api_url(gem_name:)
+      "https://rubygems.org/api/v1/gems/#{gem_name}.json"
+    end
+  end
+end