gemsmith 15.5.0 → 16.0.0

data/lib/gemsmith/builders/git/commit.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Gemsmith
+  module Builders
+    module Git
+      # Builds project skeleton initial Git commit message.
+      class Commit
+        def self.call(...) = new(...).call
+
+        def initialize configuration, builder: Rubysmith::Builder, container: Container
+          @configuration = configuration
+          @builder = builder
+          @container = container
+        end
+
+        def call
+          return configuration unless configuration.build_git
+
+          builder.call(configuration)
+                 .run("git add .", chdir: project_name)
+                 .run(
+                   %(git commit --all --message "Added project skeleton" --message "#{body}"),
+                   chdir: project_name
+                 )
+
+          configuration
+        end
+
+        private
+
+        attr_reader :configuration, :builder, :container
+
+        def body
+          <<~CONTENT
+            Generated with [#{specification.label}](#{specification.homepage_url})
+            #{specification.version}.
+          CONTENT
+        end
+
+        def project_name = configuration.project_name
+
+        def specification = container[__method__]
+      end
+    end
+  end
+end

data/lib/gemsmith/builders/git/ignore.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "refinements/structs"
+
+module Gemsmith
+  module Builders
+    module Git
+      # Builds project skeleton Git ignore.
+      class Ignore
+        using Refinements::Structs
+
+        def self.call(...) = new(...).call
+
+        def initialize configuration, builder: Rubysmith::Builder
+          @configuration = configuration
+          @builder = builder
+        end
+
+        def call
+          return configuration unless configuration.build_git
+
+          builder.call(configuration.merge(template_path: "%project_name%/.gitignore.erb"))
+                 .touch
+                 .prepend("*.gem\n")
+                 .insert_before("tmp\n", "Gemfile.lock\n")
+                 .insert_before("tmp\n", "pkg\n")
+
+          configuration
+        end
+
+        private
+
+        attr_reader :configuration, :builder
+      end
+    end
+  end
+end

data/lib/gemsmith/builders/rspec/helper.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "refinements/structs"
+
+module Gemsmith
+  module Builders
+    module RSpec
+      # Builds RSpec spec helper for project skeleton.
+      class Helper
+        using Refinements::Structs
+
+        def self.call(...) = new(...).call
+
+        def initialize configuration, builder: Rubysmith::Builder
+          @configuration = configuration
+          @builder = builder
+        end
+
+        def call
+          return configuration unless configuration.build_rspec && configuration.build_cli
+
+          update_spec_helper
+          render_shared_example
+          configuration
+        end
+
+        private
+
+        attr_reader :configuration, :builder
+
+        def update_spec_helper
+          builder.call(configuration.merge(template_path: "%project_name%/spec/spec_helper.rb.erb"))
+                 .touch
+                 .insert_after(
+                   %r(support/shared_contexts),
+                   %(Pathname.require_tree __dir__, "support/shared_examples/**/*.rb"\n)
+                 )
+        end
+
+        def render_shared_example
+          path = "%project_name%/spec/support/shared_examples/a_parser.rb.erb"
+          builder.call(configuration.merge(template_path: path)).render
+        end
+      end
+    end
+  end
+end

data/lib/gemsmith/builders/specification.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "refinements/structs"
+
+module Gemsmith
+  module Builders
+    # Builds project skeleton gem specification for use by RubyGems.
+    class Specification
+      using Refinements::Structs
+
+      def self.call(...) = new(...).call
+
+      def initialize configuration, builder: Rubysmith::Builder
+        @configuration = configuration
+        @builder = builder
+      end
+
+      def call
+        config = configuration.merge template_path: "%project_name%/%project_name%.gemspec.erb"
+
+        builder.call(config)
+               .render
+               .replace("  \n", "")
+               .replace("    spec", "  spec")
+               .replace(/\}\s+s/m, "}\n\n  s")
+
+        configuration
+      end
+
+      private
+
+      attr_reader :configuration, :builder
+    end
+  end
+end

data/lib/gemsmith/cli/actions/build.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Gemsmith
+  module CLI
+    module Actions
+      # Handles the build action.
+      class Build
+        # Order is important.
+        BUILDERS = [
+          Rubysmith::Builders::Core,
+          Rubysmith::Builders::Version,
+          Builders::Specification,
+          Rubysmith::Builders::Documentation::Readme,
+          Rubysmith::Builders::Documentation::Citation,
+          Rubysmith::Builders::Documentation::License,
+          Rubysmith::Builders::Documentation::Version,
+          Rubysmith::Builders::Git::Setup,
+          Rubysmith::Builders::Git::Ignore,
+          Builders::Git::Ignore,
+          Rubysmith::Builders::Bundler,
+          Builders::Bundler,
+          Builders::CLI,
+          Rubysmith::Builders::Rake,
+          Rubysmith::Builders::Console,
+          Rubysmith::Builders::CircleCI,
+          Rubysmith::Builders::Setup,
+          Rubysmith::Builders::GitHub,
+          Rubysmith::Builders::Guard,
+          Rubysmith::Builders::Reek,
+          Rubysmith::Builders::RSpec::Context,
+          Rubysmith::Builders::RSpec::Helper,
+          Builders::RSpec::Helper,
+          Rubysmith::Builders::Rubocop,
+          Rubysmith::Extensions::Bundler,
+          Rubysmith::Extensions::Pragmater,
+          Rubysmith::Extensions::Tocer,
+          Rubysmith::Extensions::Rubocop,
+          Builders::Git::Commit
+        ].freeze
+
+        def initialize builders: BUILDERS
+          @builders = builders
+        end
+
+        def call(configuration) = builders.each { |builder| builder.call configuration }
+
+        private
+
+        attr_reader :configuration, :builders
+      end
+    end
+  end
+end

data/lib/gemsmith/cli/actions/config.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Gemsmith
+  module CLI
+    module Actions
+      # Handles the config action.
+      class Config
+        def initialize client: Configuration::Loader::CLIENT, container: Container
+          @client = client
+          @container = container
+        end
+
+        def call selection
+          case selection
+            when :edit then edit
+            when :view then view
+            else logger.error { "Invalid configuration selection: #{selection}." }
+          end
+        end
+
+        private
+
+        attr_reader :client, :container
+
+        def edit = kernel.system("$EDITOR #{client.current}")
+
+        def view = kernel.system("cat #{client.current}")
+
+        def kernel = container[__method__]
+
+        def logger = container[__method__]
+      end
+    end
+  end
+end

data/lib/gemsmith/cli/actions/edit.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "dry/monads"
+
+module Gemsmith
+  module CLI
+    module Actions
+      # Handles the edit action for editing an installed gem.
+      class Edit
+        include Dry::Monads[:result]
+
+        def initialize picker: Gems::Picker, editor: Tools::Editor.new, container: Container
+          @picker = picker
+          @editor = editor
+          @container = container
+        end
+
+        def call gem_name
+          case picker.call(gem_name).bind { |spec| editor.call spec }
+            in Success(spec) then logger.info { "Editing: #{spec.named_version}." }
+            in Failure(message) then error { message }
+            else error { "Unable to handle edit action." }
+          end
+        end
+
+        private
+
+        attr_reader :picker, :editor, :container
+
+        def error(&) = logger.error(&)
+
+        def kernel = container[__method__]
+
+        def logger = container[__method__]
+      end
+    end
+  end
+end

data/lib/gemsmith/cli/actions/install.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "dry/monads"
+
+module Gemsmith
+  module CLI
+    module Actions
+      # Handles the install action.
+      class Install
+        include Dry::Monads[:result]
+
+        def initialize installer: Tools::Installer.new, loader: Gems::Loader, container: Container
+          @installer = installer
+          @loader = loader
+          @container = container
+        end
+
+        def call configuration
+          case installer.call loader.call("#{configuration.project_name}.gemspec")
+            in Success(spec) then logger.info { "Installed: #{spec.package_name}." }
+            in Failure(message) then error { message }
+            else error { "Unable to handle install action." }
+          end
+        end
+
+        private
+
+        attr_reader :installer, :loader, :container
+
+        def error(&) = logger.error(&)
+
+        def logger = container[__method__]
+      end
+    end
+  end
+end

data/lib/gemsmith/cli/actions/publish.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "dry/monads"
+
+module Gemsmith
+  module CLI
+    module Actions
+      # Handles the publish action.
+      class Publish
+        include Dry::Monads[:result]
+
+        def initialize publisher: Tools::Publisher.new, loader: Gems::Loader, container: Container
+          @publisher = publisher
+          @loader = loader
+          @container = container
+        end
+
+        def call configuration
+          case publisher.call loader.call("#{configuration.project_name}.gemspec")
+            in Success(spec) then logger.info { "Published: #{spec.package_name}." }
+            in Failure(message) then error { message }
+            else error { "Unable to handle publish action." }
+          end
+        end
+
+        private
+
+        attr_reader :publisher, :loader, :container
+
+        def error(&) = logger.error(&)
+
+        def logger = container[__method__]
+      end
+    end
+  end
+end

data/lib/gemsmith/cli/actions/view.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "dry/monads"
+
+module Gemsmith
+  module CLI
+    module Actions
+      # Handles the view action for viewing an installed gem in default browser.
+      class View
+        include Dry::Monads[:result]
+
+        def initialize picker: Gems::Picker, viewer: Tools::Viewer.new, container: Container
+          @picker = picker
+          @viewer = viewer
+          @container = container
+        end
+
+        def call gem_name
+          case picker.call(gem_name).bind { |spec| viewer.call spec }
+            in Success(spec) then logger.info { "Viewing: #{spec.named_version}." }
+            in Failure(message) then error { message }
+            else error { "Unable to handle view action." }
+          end
+        end
+
+        private
+
+        attr_reader :picker, :viewer, :container
+
+        def error(&) = logger.error(&)
+
+        def kernel = container[__method__]
+
+        def logger = container[__method__]
+      end
+    end
+  end
+end

data/lib/gemsmith/cli/parser.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module Gemsmith
+  module CLI
+    # Assembles and parses all Command Line Interface (CLI) options.
+    class Parser
+      CLIENT = OptionParser.new nil, 40, "  "
+
+      # Order is important.
+      SECTIONS = [Parsers::Core, Rubysmith::CLI::Parsers::Build, Parsers::Build].freeze
+
+      def initialize sections: SECTIONS, client: CLIENT, container: Container
+        @sections = sections
+        @client = client
+        @configuration = container[:configuration].dup
+      end
+
+      def call arguments = []
+        sections.each { |section| section.call configuration, client: }
+        client.parse arguments
+        configuration.freeze
+      end
+
+      def to_s = client.to_s
+
+      private
+
+      attr_reader :sections, :client, :configuration
+    end
+  end
+end

data/lib/gemsmith/cli/parsers/build.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "refinements/structs"
+
+module Gemsmith
+  module CLI
+    module Parsers
+      # Handles parsing of Command Line Interface (CLI) build options.
+      class Build
+        using Refinements::Structs
+
+        def self.call(...) = new(...).call
+
+        def initialize configuration = Container[:configuration],
+                       client: Parser::CLIENT,
+                       container: Container
+          @configuration = configuration
+          @client = client
+          @container = container
+        end
+
+        def call arguments = []
+          add_cli
+          client.parse arguments
+          configuration
+        end
+
+        private
+
+        attr_reader :configuration, :client, :container
+
+        def add_cli
+          client.on(
+            "--[no-]cli",
+            "Add command line interface. #{default __method__}."
+          ) do |value|
+            configuration.merge! build_refinements: value, build_zeitwerk: value if value
+            configuration.merge! build_cli: value
+          end
+        end
+
+        def default option
+          option.to_s
+                .sub("add_", "build_")
+                .then { |attribute| configuration.public_send attribute }
+                .then { |boolean| boolean ? colorizer.green(boolean) : colorizer.red(boolean) }
+                .then { |colored_boolean| "Default: #{colored_boolean}" }
+        end
+
+        def colorizer = container[__method__]
+      end
+    end
+  end
+end

data/lib/gemsmith/cli/parsers/core.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "refinements/structs"
+
+module Gemsmith
+  module CLI
+    module Parsers
+      # Handles parsing of Command Line Interface (CLI) core options.
+      class Core
+        using Refinements::Structs
+
+        def self.call(...) = new(...).call
+
+        def initialize configuration = Container[:configuration],
+                       client: Parser::CLIENT,
+                       container: Container
+          @configuration = configuration
+          @client = client
+          @container = container
+        end
+
+        def call arguments = []
+          client.banner = specification.labeled_summary
+          client.separator "\nUSAGE:\n"
+          collate
+          client.parse arguments
+          configuration
+        end
+
+        private
+
+        attr_reader :configuration, :client, :container
+
+        def collate = private_methods.sort.grep(/add_/).each { |method| __send__ method }
+
+        def add_config
+          client.on "-c",
+                    "--config ACTION",
+                    %i[edit view],
+                    "Manage gem configuration: edit or view." do |action|
+            configuration.merge! action_config: action
+          end
+        end
+
+        def add_build
+          client.on "-b", "--build NAME [options]", "Build new project." do |name|
+            configuration.merge! action_build: true, project_name: name
+          end
+        end
+
+        def add_edit
+          client.on "--edit GEM", "Edit installed gem in default editor." do |gem_name|
+            configuration.merge! action_edit: gem_name
+          end
+        end
+
+        def add_install
+          client.on "-i", "--install [NAME]", "Install gem for local development." do |name|
+            configuration.merge! action_install: true,
+                                 project_name: name || Pathname.pwd.basename.to_s
+          end
+        end
+
+        def add_publish
+          client.on "-p", "--publish [NAME]", "Publish gem to remote gem server." do |name|
+            configuration.merge! action_publish: true,
+                                 project_name: name || Pathname.pwd.basename.to_s
+          end
+        end
+
+        def add_view
+          client.on "--view GEM", "View installed gem in default browser." do |gem_name|
+            configuration.merge! action_view: gem_name
+          end
+        end
+
+        def add_version
+          client.on "-v", "--version", "Show gem version." do
+            configuration.merge! action_version: true
+          end
+        end
+
+        def add_help
+          client.on "-h", "--help", "Show this message." do
+            configuration.merge! action_help: true
+          end
+        end
+
+        def specification = container[__method__]
+      end
+    end
+  end
+end

data/lib/gemsmith/cli/shell.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Gemsmith
+  module CLI
+    # The main Command Line Interface (CLI) object.
+    class Shell
+      ACTIONS = {
+        config: Actions::Config.new,
+        build: Actions::Build.new,
+        install: Actions::Install.new,
+        publish: Actions::Publish.new,
+        edit: Actions::Edit.new,
+        view: Actions::View.new
+      }.freeze
+
+      def initialize parser: Parser.new, actions: ACTIONS, container: Container
+        @parser = parser
+        @actions = actions
+        @container = container
+      end
+
+      def call arguments = []
+        perform parser.call(arguments)
+      rescue OptionParser::ParseError => error
+        logger.error { error.message }
+      end
+
+      private
+
+      attr_reader :parser, :actions, :container
+
+      def perform configuration
+        case configuration
+          in action_config: Symbol => action then config action
+          in action_build: true then build configuration
+          in action_install: true then install configuration
+          in action_publish: true then publish configuration
+          in action_edit: String => gem_name then edit gem_name
+          in action_view: String => gem_name then view gem_name
+          in action_version: true then logger.info specification.labeled_version
+          else usage
+        end
+      end
+
+      def config(action) = actions.fetch(__method__).call(action)
+
+      def build(configuration) = actions.fetch(__method__).call(configuration)
+
+      def install(configuration) = actions.fetch(__method__).call(configuration)
+
+      def publish(configuration) = actions.fetch(__method__).call(configuration)
+
+      def edit(gem_name) = actions.fetch(__method__).call(gem_name)
+
+      def view(gem_name) = actions.fetch(__method__).call(gem_name)
+
+      def usage = logger.unknown(parser.to_s)
+
+      def logger = container[__method__]
+
+      def specification = container[__method__]
+
+      def process = container[__method__]
+    end
+  end
+end

data/lib/gemsmith/configuration/enhancers/template_root.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Gemsmith
+  module Configuration
+    module Enhancers
+      # Adds gem specific roots to existing content.
+      class TemplateRoot
+        def initialize overrides = Pathname(__dir__).join("../../templates")
+          @overrides = Array overrides
+        end
+
+        def call(content) = content.add_template_roots(overrides)
+
+        private
+
+        attr_reader :overrides
+      end
+    end
+  end
+end