pennyworth 9.5.0 → 11.1.0

data/lib/pennyworth/cli/parsers/git_hub.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "refinements/structs"
+
+module Pennyworth
+  module CLI
+    module Parsers
+      # Handles parsing of Command Line Interface (CLI) GitHub options.
+      class GitHub
+        using Refinements::Structs
+
+        def self.call(...) = new(...).call
+
+        def initialize configuration = Configuration::Loader.call, client: CLIENT
+          @configuration = configuration
+          @client = client
+        end
+
+        def call arguments = []
+          client.separator "\nGITHUB OPTIONS:\n"
+          private_methods.sort.grep(/add_/).each { |method| __send__ method }
+          arguments.empty? ? arguments : client.parse!(arguments)
+        end
+
+        private
+
+        attr_reader :configuration, :client
+
+        def add_organization
+          client.on(
+            "--organization [HANDLE]",
+            %(Set organization. Default: "#{organization}".)
+          ) do |handle|
+            configuration.merge! action_git_hub: :organization,
+                                 git_hub_organization: handle || organization
+          end
+        end
+
+        def add_user
+          client.on "--user [HANDLE]", %(Set user. Default: "#{user}".) do |handle|
+            configuration.merge! action_git_hub: :user, git_hub_user: handle || user
+          end
+        end
+
+        def organization = configuration.git_hub_organization
+
+        def user = configuration.git_hub_user
+      end
+    end
+  end
+end

data/lib/pennyworth/cli/parsers/ruby_gems.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Pennyworth
+  module CLI
+    module Parsers
+      # Handles parsing of Command Line Interface (CLI) RubyGems options.
+      class RubyGems
+        def self.call(...) = new(...).call
+
+        def initialize configuration = Configuration::Loader.call, client: CLIENT
+          @configuration = configuration
+          @client = client
+        end
+
+        def call arguments = []
+          client.separator "\nRUBYGEMS OPTIONS:\n"
+          add_owner
+          arguments.empty? ? arguments : client.parse!(arguments)
+        end
+
+        private
+
+        attr_reader :configuration, :client
+
+        def add_owner
+          client.on "--owner [HANDLE]", %(Set owner. Default: "#{owner}".) do |handle|
+            configuration.ruby_gems_owner = handle || owner
+          end
+        end
+
+        def owner = configuration.ruby_gems_owner
+      end
+    end
+  end
+end

data/lib/pennyworth/cli/shell.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Pennyworth
+  module CLI
+    # The main Command Line Interface (CLI) object.
+    class Shell
+      ACTIONS = {
+        config: Actions::Config.new,
+        encodings: Actions::Encodings.new,
+        git_hub: Actions::GitHub.new,
+        http_statuses: Actions::HTTPStatuses.new,
+        ruby_gems: Actions::RubyGems.new,
+        system_errors: Actions::System::Errors.new,
+        system_signals: Actions::System::Signals.new,
+        text: Actions::Text.new
+      }.freeze
+
+      def initialize parser: Parsers::Assembler.new, actions: ACTIONS, container: Container
+        @parser = parser
+        @actions = actions
+        @container = container
+      end
+
+      def call arguments = []
+        perform parser.call(arguments)
+      rescue OptionParser::ParseError, KeyError => error
+        logger.error error.message
+      end
+
+      private
+
+      attr_reader :parser, :actions, :container
+
+      # rubocop:disable Metrics/MethodLength
+      def perform configuration
+        case configuration
+          in action_config: Symbol => action then config action
+          in action_encodings: true then encodings
+          in action_git_hub: :organization then git_hub_organization configuration
+          in action_git_hub: :user then git_hub_user configuration
+          in action_http_statuses: true then http_statuses
+          in action_ruby_gems: true then ruby_gems configuration
+          in action_system_signals: true then system_signals
+          in action_system_errors: true then system_errors
+          in action_text: String => content then text content
+          in action_version: String => version then logger.info version
+          in action_help: then usage
+          else usage
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def config(action) = actions.fetch(__method__).call(action)
+
+      def encodings = actions.fetch(__method__).call
+
+      def git_hub_organization configuration
+        actions.fetch(:git_hub).call("orgs/#{configuration.git_hub_organization}/repos")
+      end
+
+      def git_hub_user configuration
+        actions.fetch(:git_hub).call("users/#{configuration.git_hub_user}/repos")
+      end
+
+      def http_statuses = actions.fetch(__method__).call
+
+      def ruby_gems configuration
+        actions.fetch(__method__).call("owners/#{configuration.ruby_gems_owner}/gems.json")
+      end
+
+      def system_errors = actions.fetch(__method__).call
+
+      def system_signals = actions.fetch(__method__).call
+
+      def text(content) = actions.fetch(__method__).call(content)
+
+      def usage = logger.unknown { parser.to_s }
+
+      def logger = container[__method__]
+    end
+  end
+end

data/lib/pennyworth/container.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "dry-container"
+require "logger"
+require "http"
+require "pastel"
+
+module Pennyworth
+  # Provides a global gem container for injection into other objects.
+  module Container
+    extend Dry::Container::Mixin
+
+    register(:configuration) { CLI::Configuration::Loader.call }
+    register(:environment) { ENV }
+    register(:kernel) { Kernel }
+    register(:http) { HTTP }
+    register(:colorizer) { Pastel.new enabled: $stdout.tty? }
+
+    register :log_colors do
+      {
+        "DEBUG" => self[:colorizer].white.detach,
+        "INFO" => self[:colorizer].green.detach,
+        "WARN" => self[:colorizer].yellow.detach,
+        "ERROR" => self[:colorizer].red.detach,
+        "FATAL" => self[:colorizer].white.bold.on_red.detach,
+        "ANY" => self[:colorizer].white.bold.detach
+      }
+    end
+
+    register :logger do
+      Logger.new $stdout,
+                 level: Logger.const_get(ENV.fetch("LOG_LEVEL", "INFO")),
+                 formatter: (
+                   lambda do |severity, _at, _name, message|
+                     self[:log_colors][severity].call "#{message}\n"
+                   end
+                 )
+    end
+  end
+end

data/lib/pennyworth/identity.rb

@@ -5,7 +5,8 @@ module Pennyworth
   module Identity
     NAME = "pennyworth"
     LABEL = "Pennyworth"
-    VERSION = "9.5.0"
+    SUMMARY = "A command line interface that augments Alfred workflows."
+    VERSION = "11.1.0"
     VERSION_LABEL = "#{LABEL} #{VERSION}"
   end
 end

data/lib/pennyworth/inflector.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pennyworth
+  # Overrides any string to desired form if matched, otherwise answers the original string.
+  class Inflector
+    DEFAULTS = Array(CLI::Configuration::Loader.call.inflections).reduce({}, :merge)
+
+    def initialize overrides = DEFAULTS
+      @overrides = overrides
+    end
+
+    def call(key) = overrides.fetch(key) { |fallback| fallback }
+
+    private
+
+    attr_reader :overrides
+  end
+end

data/lib/pennyworth/integrations/git_hub/client.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "refinements/arrays"
+
+module Pennyworth
+  module Integrations
+    module GitHub
+      # Provides low-level API access to the GitHub API.
+      class Client
+        using Refinements::Arrays
+
+        HEADERS = {
+          accept: "application/vnd.github.v3+json",
+          content_type: "Content-Type: application/json; charset=utf-8"
+        }.freeze
+
+        def initialize headers: HEADERS, container: Container
+          @headers = headers
+          @container = container
+        end
+
+        def get endpoint, parameters: {}
+          paginate ->(page) { sole_get endpoint, parameters: parameters.merge(page: page) }
+        end
+
+        private
+
+        attr_reader :headers, :container
+
+        # :reek:FeatureEnvy
+        def paginate request, records: [], page: 1
+          response = request.call page
+
+          records.including(response.records)
+                 .then do |updated_records|
+                   return updated_records if response.last_page.zero?
+
+                   paginate request, records: updated_records, page: response.next_page
+                 end
+        end
+
+        def sole_get endpoint, parameters: {}
+          http.headers(headers)
+              .basic_auth(user: api_login, pass: api_token)
+              .get("#{api_url}/#{endpoint}", params: parameters)
+              .then { |response| Response.new response }
+        end
+
+        def http = container[__method__]
+
+        def api_url = container[:configuration].git_hub_api_url
+
+        def api_login = container[:environment].fetch("GITHUB_API_LOGIN")
+
+        def api_token = container[:environment].fetch("GITHUB_API_TOKEN")
+      end
+    end
+  end
+end

data/lib/pennyworth/integrations/git_hub/response.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Pennyworth
+  module Integrations
+    module GitHub
+      # Represents a generic GitHub API response.
+      class Response
+        def initialize raw
+          @raw = raw
+        end
+
+        def next_page = page("next")
+
+        def last_page = page("last")
+
+        def records = success? ? JSON(raw.body, symbolize_names: true) : []
+
+        def success? = raw.status.success?
+
+        private
+
+        attr_reader :raw
+
+        def page reference
+          links.find { |link| link.include? reference }
+               .then { |link| String(link)[/page=(?<page>\d+)/, :page].to_i }
+        end
+
+        def links = String(raw.headers["Link"]).split(", ")
+      end
+    end
+  end
+end

data/lib/pennyworth/integrations/ruby_gems/client.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Pennyworth
+  module Integrations
+    module RubyGems
+      # Provides low-level API access to the RubyGems API.
+      class Client
+        def initialize container: Container
+          @container = container
+        end
+
+        def get endpoint
+          http.get("#{api_url}/#{endpoint}")
+              .then do |response|
+                response.status.success? ? JSON(response.body.to_s, symbolize_names: true) : {}
+              end
+        end
+
+        private
+
+        attr_reader :container
+
+        def http = container[__method__]
+
+        def api_url = container[:configuration].ruby_gems_api_url
+      end
+    end
+  end
+end

data/lib/pennyworth/loaders/encodings.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "refinements/arrays"
+
+module Pennyworth
+  module Loaders
+    # Loads an array of encoding records.
+    class Encodings
+      using Refinements::Arrays
+
+      def initialize encoding: Encoding, model: Models::Encoding
+        @encoding = encoding
+        @model = model
+      end
+
+      def call _omit = nil
+        encoding.aliases
+                .map { |_second, first| first }
+                .uniq
+                .sort
+                .map do |first|
+                  model[name: first, aliases: encoding.find(first).names.sort.excluding(first)]
+                end
+      end
+
+      private
+
+      attr_reader :encoding, :model
+    end
+  end
+end

data/lib/pennyworth/loaders/http_statuses.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "rack"
+
+module Pennyworth
+  module Loaders
+    # Loads an array of HTTP status records.
+    class HTTPStatuses
+      def initialize codes: Rack::Utils::HTTP_STATUS_CODES,
+                     model: Models::HTTPStatus,
+                     configuration: CLI::Configuration::Loader.call
+        @codes = codes
+        @model = model
+        @configuration = configuration
+      end
+
+      def call _omit = nil
+        codes.map { |(code, label)| model[code: code, label: label, url: "#{url}/#{code}"] }
+      end
+
+      private
+
+      attr_reader :codes, :model, :configuration
+
+      def url = configuration.http_statuses_url
+    end
+  end
+end

data/lib/pennyworth/loaders/projects.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Pennyworth
+  module Loaders
+    # Loads projects from API requests for further processing.
+    class Projects
+      def self.for_git_hub = new(client: Integrations::GitHub::Client.new)
+
+      def self.for_ruby_gems = new(client: Integrations::RubyGems::Client.new)
+
+      def initialize client:
+        @client = client
+      end
+
+      def call(endpoint) = client.get(endpoint)
+
+      private
+
+      attr_reader :client
+    end
+  end
+end