bundler-gem_bytes 0.1.0 → 0.2.2

data/lib/bundler/gem_bytes/actions/gemspec/gem_specification.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Bundler
+  module GemBytes
+    module Actions
+      class Gemspec < Parser::TreeRewriter
+        # Holds information about the gemspec file
+        # @!attribute [r] gemspec_object
+        # @api private
+        class GemSpecification
+          # Create a new GemSpecification object
+          #
+          # @param source [String] The contents of the gemspec file
+          # @param source_path [String] The path to the gemspec file
+          # @api private
+          #
+          def initialize(source, source_path)
+            @source = source
+            @source_path = source_path
+
+            @dependencies = []
+            @attributes = []
+
+            @source_buffer, @source_ast = parse(source, source_path)
+          end
+
+          # The contents of the gemspec file
+          # @example
+          #   data.source # => "Gem::Specification.new do |spec|\n  spec.name = 'example'\nend"
+          # @return [String]
+          attr_reader :source
+
+          # The path to the gemspec file (used for error reporting)
+          # @example
+          #   data.source_path # => "example.gemspec"
+          # @return [String]
+          attr_reader :soure_path
+
+          # The source buffer used when updating the gemspec file
+          # @return [Parser::Source::Buffer]
+          # @api private
+          attr_reader :source_buffer
+
+          # The parsed AST for the gemspec file source
+          # @example
+          #   data.source_ast # => (send nil :puts)
+          # @return [Parser::AST::Node]
+          attr_reader :source_ast
+
+          # The Gem::Specification object
+          # @example
+          #   data.gemspec_object # => #<Gem::Specification:0x00007f9b1b8b3f10>
+          # @return [Gem::Specification]
+          def gemspec_object
+            @gemspec_object ||= load_gem_specification
+          end
+
+          # The name of the Gem::Specification object within the gemspec block
+          # @example When the gemspec block starts `Gem::Specification.new do |spec|`
+          #   data.gemspec_object_name # => :spec
+          # @return [Symbol]
+          attr_accessor :gemspec_object_name
+
+          # The AST node for the Gem::Specification block within the source
+          # @return [Parser::AST::Node]
+          attr_accessor :gemspec_ast
+
+          # The dependencies found in the gemspec file
+          # @return [Array<Dependency>]
+          attr_reader :dependencies
+
+          # The attributes found in the gemspec file
+          # @return [Array<Attribute>]
+          attr_reader :attributes
+
+          private
+
+          # Parses the given code into an AST
+          # @param source [String] The code to parse
+          # @param source_path [String] The path to the file being parsed (used for error messages only)
+          # @return [Array<Parser::AST::Node, Parser::Source::Buffer>] The AST and buffer
+          # @api private
+          def parse(source, source_path)
+            source_buffer = Parser::Source::Buffer.new(source_path, source: source)
+            processed_source = RuboCop::AST::ProcessedSource.new(source, ruby_version, source_path)
+            unless processed_source.valid_syntax?
+              raise "Invalid syntax in #{source_path}\n#{processed_source.diagnostics.map(&:render).join("\n")}"
+            end
+
+            source_ast = processed_source.ast
+            [source_buffer, source_ast]
+          end
+
+          # The currently running Ruby version as a float (MAJOR.MINOR only)
+          #
+          # @return [Float] The Ruby version number, e.g., 3.0
+          # @api private
+          def ruby_version = RUBY_VERSION.match(/^(?<version>\d+\.\d+)/)['version'].to_f
+
+          # Load the gemspec file into a Gem::Specification object
+          # @return [Gem::Specification] The Gem::Specification object
+          # @api private
+          def load_gem_specification
+            # Store the current $LOAD_PATH
+            original_load_path = $LOAD_PATH.dup
+
+            # Temporarily add 'lib' to the $LOAD_PATH
+            lib_path = File.expand_path('lib', Dir.pwd)
+            $LOAD_PATH.unshift(lib_path)
+
+            # Evaluate the gemspec file
+            eval(source, binding, '.').tap do # rubocop:disable Security/Eval
+              # Restore the original $LOAD_PATH
+              $LOAD_PATH.replace(original_load_path)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bundler/gem_bytes/actions/gemspec/upsert_dependency.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+require 'parser/current'
+require 'rubocop-ast'
+require 'active_support/core_ext/object'
+
+module Bundler
+  module GemBytes
+    module Actions
+      class Gemspec < Parser::TreeRewriter
+        # Add or update a dependency in a gemspec
+        #
+        # If a dependency on the given gem is not found, a new dependency is added to
+        # the end of the Gem::Specification block.
+        #
+        # If one or more dependencies are found on the same gem as new_dependency,
+        # the version constraint is updated to the new_dependency version constraint.
+        #
+        # The gemspec is updated via calls to the tree_rewriter object.
+        #
+        # @!attribute [r] tree_rewriter
+        #   The object that updates the source
+        #   @return [Parser::TreeRewriter]
+        #   @api private
+        #
+        # @!attribute [r] gemspec_block
+        #   The root AST node of the Gem::Specification block from the gemspec
+        #   @return [Parser::AST::Node]
+        #   @api private
+        #
+        # @!attribute [r] receiver_name
+        #   The name of the receiver for the Gem::Specification block
+        #   @return [Symbol]
+        #   @api private
+        #
+        # @!attribute [r] dependencies
+        #   The dependency declarations found in the gemspec file
+        #   @return [Array<DependencyNode>]
+        #   @api private
+        #
+        # @!attribute [r] new_dependency
+        #   The dependency declaration to add or update
+        #   @return [Dependency]
+        #   @api private
+        #
+        # @api public
+        class UpsertDependency
+          # Initializes the upsert dependency action
+          # @param tree_rewriter [Parser::TreeRewriter] The object that updates the source
+          # @param gemspec_block [Parser::AST::Node] The Gem::Specification block
+          # @param receiver_name [Symbol] The name of the receiver for the Gem::Specification block
+          # @param dependencies [Array<DependencyNode>] The dependency declarations found in the gemspec file
+          # @api private
+          def initialize(tree_rewriter, gemspec_block, receiver_name, dependencies)
+            @tree_rewriter = tree_rewriter
+            @gemspec_block = gemspec_block
+            @receiver_name = receiver_name
+            @dependencies = dependencies
+          end
+
+          attr_reader :tree_rewriter, :gemspec_block, :receiver_name, :dependencies, :new_dependency
+
+          # Adds or updates a dependency to the Gem::Specification block
+          #
+          # @example
+          #   upsert_dependency = UpsertDependency.new(tree_rewriter, gemspec_block, receiver_name, dependencies)
+          #   new_dependency = Dependency.new(:add_runtime_dependency, 'rubocop', '~> 1.68')
+          #   upsert_dependency.call(new_dependency)
+          # @param new_dependency [Dependency] The dependency declaration to add or update
+          # @return [void]
+          # @api public
+          def call(new_dependency)
+            @new_dependency = new_dependency
+            matching_dependencies = dependencies.select { |d| d.dependency.gem_name == new_dependency.gem_name }
+
+            if matching_dependencies.any?
+              update_dependencies(matching_dependencies)
+            else
+              add_dependency
+            end
+          end
+
+          # Update the version constraint of the existing dependency(s)
+          # @param matching_dependencies [Array<DependencyNode>] The existing dependencies that match new_dependency
+          # @return [void]
+          # @api private
+          def update_dependencies(matching_dependencies)
+            matching_dependencies.each do |found_dependency|
+              raise(dependency_type_conflict_error(found_dependency)) unless dependency_type_match?(found_dependency)
+
+              tree_rewriter.replace(found_dependency.node.loc.expression, dependency_source_code(found_dependency))
+            end
+          end
+
+          # Add the new_dependency to the end of the Gem::Specification block
+          # @return [void]
+          # @api private
+          def add_dependency
+            # Add the dependency to the end of the Gem::Specification block
+            internal_block = gemspec_block.children[2]
+            if internal_block
+              tree_rewriter.insert_after(internal_block.children.last.loc.expression, "\n  #{dependency_source_code}")
+            else
+              # When the Gem::Specification block is empty, it require special handling
+              add_dependency_to_empty_gemspec_block
+            end
+          end
+
+          # Error message for a dependency type conflict
+          # @param existing_dependency [DependencyNode] The existing dependency
+          # @return [String] The error message
+          # @api private
+          def dependency_type_conflict_error(existing_dependency)
+            # :nocov: JRuby give false positive for this line being uncovered by tests
+            <<~MESSAGE.chomp.gsub("\n", ' ')
+              Trying to add a
+              #{dependency_method_to_type(new_dependency.method_name).upcase}
+              dependency on "#{new_dependency.gem_name}" which conflicts with the existing
+              #{dependency_method_to_type(existing_dependency.dependency.method_name).upcase}
+              dependency.
+            MESSAGE
+            # :nocov:
+          end
+
+          # The dependency type (:runtime or :development) based on a given method name
+          # @param method [Symbol] The method name to convert to a dependency type
+          # @return [Symbol] The dependency type
+          # @api private
+          def dependency_method_to_type(method)
+            method == :add_development_dependency ? :development : :runtime
+          end
+
+          # Checks if the new dependency type is the same as the existing dependency type
+          #
+          # @param existing_dependency [DependencyNode] The existing dependency
+          # @return [Boolean] Whether the dependency type conflicts
+          # @api private
+          def dependency_type_match?(existing_dependency)
+            # Either both are :add_development_dependency or both are not
+            (existing_dependency.dependency.method_name == :add_development_dependency) ==
+              (new_dependency.method_name == :add_development_dependency)
+          end
+
+          # Add new_dependency to an empty Gem::Specification block
+          # @return [void]
+          # @api private
+          def add_dependency_to_empty_gemspec_block
+            source = gemspec_block.loc.expression.source
+            # :nocov: supress false reporting of no coverage of multiline string literals on JRuby
+            tree_rewriter.replace(gemspec_block.loc.expression, <<~GEMSPEC_BLOCK.chomp)
+              #{source[0..-5]}
+                #{dependency_source_code}
+              #{source[-3..]}
+            GEMSPEC_BLOCK
+            # :nocov:
+          end
+
+          # The source code for the updated dependency declaration
+          # @param existing_dependency [DependencyNode] The existing dependency
+          # @return [String] The source code for the dependency declaration
+          # @api private
+          def dependency_source_code(existing_dependency = nil)
+            # Use existing quote character for string literals
+            q = new_quote_char(existing_dependency)
+
+            # :nocov: supress false reporting of no coverage of multiline string literals on JRuby
+            "#{receiver_name}.#{new_method_name(existing_dependency)} " \
+              "#{q}#{new_dependency.gem_name}#{q}, " \
+              "#{new_dependency.version_constraints.map { |vc| "#{q}#{vc}#{q}" }.join(', ')}"
+            # :nocov:
+          end
+
+          # Use the same quote char as the existing dependency or default to single quote
+          # @param existing_dependency [DependencyNode, nil] The existing dependency being updated
+          # @return [String] The quote character to use
+          # @api private
+          def new_quote_char(existing_dependency)
+            if existing_dependency
+              existing_dependency.node.children[3].loc.expression.source[0]
+            else
+              "'"
+            end
+          end
+
+          # The method to use for the new dependency
+          #
+          # If `existing_dependency` is given and the dependency type (runtime vs.
+          # development) matches, the existing dependency method is used. Otherwise,
+          # the new_dependency method is used.
+          #
+          # The purpose of this method is ensure that an #add_dependency call is not
+          # replaced with an #add_runtime_dependency call or vice versa. This
+          # maintains consistency within the user's gemspec even though these methods
+          # are functionally equivalent.
+          #
+          # @param existing_dependency [DependencyNode, nil] The existing dependency being updated
+          # @return [Symbol] The method to use for the new dependency
+          # @api private
+          def new_method_name(existing_dependency)
+            if existing_dependency && dependency_type_match?(existing_dependency)
+              existing_dependency.dependency.method_name
+            else
+              new_dependency.method_name
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bundler/gem_bytes/actions/gemspec.rb

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'parser/current'
+require 'rubocop-ast'
+require 'active_support/core_ext/object'
+
+module Bundler
+  module GemBytes
+    module Actions
+      # Updates a gemspec according to the given block
+      #
+      # This class enables you to programmatically update a gemspec file by adding or
+      # removing dependencies, updating configuration parameters, and manipulating
+      # metadata. It processes the gemspec file as an Abstract Syntax Tree (AST),
+      # which allows granular control over gemspec updates.
+      #
+      # Key terms:
+      # * `gemspec_block`: The AST node representing the Gem::Specification block in
+      #   the gemspec file.
+      # * `receiver_name`: The receiver of the Gem::Specification block (e.g., 'spec'
+      #   in `spec.add_dependency`).
+      # * `dependency declarations`: Calls to methods like `add_dependency` or
+      #   `add_runtime_dependency` within the gemspec.
+      #
+      # @example
+      #   gemspec_path = Dir['*.gemspec'].first
+      #   gemspec_content = File.read(gemspec_path)
+      #   updated_gemspec_content = Gemspec.new.call(gemspec_content, path: gemspec_path) do
+      #     add_dependency 'activesupport', '~> 7.0'
+      #     add_runtime_dependency 'process_executer', '~> 1.1'
+      #     add_development_dependency 'rubocop', '~> 1.68'
+      #     remove_dependency 'byebug'
+      #     config 'required_ruby_version', '>= 2.5.0'
+      #     remove_config 'required_ruby_version'
+      #     config_metadata 'homepage', 'https://example.com'
+      #     remove_config_metadata 'homepage'
+      #   end
+      #
+      # @api public
+      #
+      class Gemspec < Parser::TreeRewriter
+        extend Forwardable
+
+        # Create a new Gemspec action
+        #
+        # @example
+        #   Gemspec.new(context: self)
+        # @param context [Bundler::GemBytes::ScriptExecuter] The context in which the action is being run
+        #
+        def initialize(context:)
+          @context = context
+          super()
+        end
+
+        def_delegators :data, :attributes, :dependencies, :gemspec_ast, :gemspec_object,
+                       :gemspec_object_name, :source, :source_path, :source_ast, :source_buffer
+
+        # Processes the given gemspec file and returns the updated content
+        #
+        # @example
+        #   updated_gemspec_content = Gemspec.new.call(gemspec_content, source_path: gemspec_path) do
+        #     add_dependency 'activesupport', '~> 7.0'
+        #   end
+        # @param code [String] The content of the gemspec file
+        # @param path [String] The path to the gemspec file (used for error reporting)
+        # @return [String] The updated gemspec file content
+        # @raise [ArgumentError] if the Gem Specification block is not found in the given gemspec content
+        #
+        def call(source, source_path: '(string)', &action_block)
+          @data = GemSpecification.new(source, source_path)
+          @action_block = action_block
+          @processing_gemspec_block = false
+          rewrite(source_buffer, source_ast).tap do |_result|
+            raise ArgumentError, 'Gem::Specification block not found' unless gemspec_ast.present?
+          end
+        end
+
+        # The ScriptExecuter object that called this action (used for testing)
+        # @return [Bundler::GemBytes::ScriptExecuter]
+        # @api private
+        attr_reader :context
+
+        # Indicates that the gemspec block was found and is being processed
+        # @return [Boolean]
+        # @api private
+        attr_reader :processing_gemspec_block
+
+        # The block passed to #call containing the instructions to update the gemspec
+        # @return [Proc]
+        # @api private
+        attr_reader :action_block
+
+        # The GemSpecification object containing information about the gemspec file
+        # @return [GemSpecification]
+        # @api private
+        attr_reader :data
+
+        alias processing_gemspec_block? processing_gemspec_block
+
+        # Handles block nodes within the AST to locate the Gem Specification block
+        #
+        # @param node [Parser::AST::Node] The block node within the AST
+        # @return [void]
+        # @api private
+        def on_block(node)
+          # If already processing the Gem Specification block, this must be some other nested block
+          return if processing_gemspec_block?
+
+          data.gemspec_object_name = gem_specification_pattern.match(node)
+
+          return unless gemspec_object_name
+
+          @processing_gemspec_block = true
+          data.gemspec_ast = node
+
+          super # process the children of this node to find interesting parts of the Gem::Specification block
+
+          @processing_gemspec_block = false
+
+          # Call the action_block to do requested modifications the Gem::Specification block.
+          # The default receiver in the block is this object.
+          # receiver_name and gem_specification are passed as arguments.
+          return unless action_block
+
+          instance_exec(gemspec_object_name, gemspec_object, &action_block)
+        end
+
+        # Handles `send` nodes within the AST to locate dependency calls
+        #
+        # Only processes `send` nodes within the Gem::Specification block.
+        #
+        # @param node [Parser::AST::Node] The `send` node to check for dependency patterns
+        # @return [void]
+        # @api private
+        def on_send(node)
+          return unless processing_gemspec_block?
+
+          handle_dependency(node) || handle_attribute(node)
+        end
+
+        # Removes a dependency from the Gem::Specification block
+        #
+        # @example
+        #   remove_dependency 'rubocop'
+        #   # Removes the dependency on 'rubocop' from the Gem::Specification block:
+        #   # spec.add_development_dependency 'rubocop', '~> 1.68'
+        # @param gem_name [String] the name of the gem to remove a dependency on
+        # @return [void]
+        #
+        # TODO: just pass data to DeleteDependency.new
+        def remove_dependency(gem_name)
+          DeleteDependency.new(self, gemspec_ast, gemspec_object_name, dependencies).call(gem_name)
+        end
+
+        # Adds or updates a dependency to the Gem::Specification block
+        #
+        # @example
+        #   add_dependency 'rails', '~> 7.0'
+        #   # Adds (or updates) the following line to the Gem::Specification block:
+        #   # spec.add_dependency 'rails', '~> 7.0'
+        # @param gem_name [String] the name of the gem to add a dependency on
+        # @param version_constraints [Array[String]] one or more version constraints on the gem
+        # @param method_name [String] the name of the method to use to add the dependency
+        # @return [void]
+        #
+        # TODO: just pass data to DeleteDependency.new
+        def add_dependency(gem_name, *version_constraints, method_name: :add_dependency)
+          new_dependency = Dependency.new(method_name, gem_name, version_constraints)
+          UpsertDependency.new(self, gemspec_ast, gemspec_object_name, dependencies).call(new_dependency)
+        end
+
+        # Adds or updates a dependency to the Gem::Specification block
+        #
+        # @example
+        #   add_runtime_dependency 'rails', '~> 7.0'
+        #   # Adds (or updates) the following line to the Gem::Specification block:
+        #   # spec.add_runtime_dependency 'rails', '~> 7.0'
+        # @param gem_name [String] the name of the gem to add a dependency on
+        # @param version_constraint [String] the version constraint on the gem
+        # @return [void]
+        #
+        def add_runtime_dependency(gem_name, version_constraint)
+          add_dependency(gem_name, version_constraint, method_name: :add_runtime_dependency)
+        end
+
+        # Adds or updates a development dependency to the Gem::Specification block
+        #
+        # @example
+        #   add_runtime_development_dependency 'rubocop', '~> 1.68'
+        #   # Adds (or updates) the following line to the Gem::Specification block:
+        #   # spec.add_development_dependency 'rubocop', '~> 1.68'
+        # @param gem_name [String] the name of the gem to add a dependency on
+        # @param version_constraint [String] the version constraint on the gem
+        # @return [void]
+        #
+        def add_development_dependency(gem_name, version_constraint)
+          add_dependency(gem_name, version_constraint, method_name: :add_development_dependency)
+        end
+
+        private
+
+        # Save the dependency if the node is a dependency
+        # @param node [Parser::AST::Node] the node to check if it is a dependency
+        # @return [Boolean] true if the node is a dependency, false otherwise
+        # @api private
+        def handle_dependency(node)
+          return false unless (match = dependency_pattern.match(node))
+
+          dependencies << DependencyNode.new(node, Dependency.new(*match))
+
+          true
+        end
+
+        # Save the attribute if the node is an attribute
+        # @param node [Parser::AST::Node] the node to check if it is an attribute
+        # @return [Boolean] true if the node is an attribute, false otherwise
+        # @api private
+        def handle_attribute(node)
+          return false unless (match = attribute_pattern.match(node))
+          return false unless match[0].end_with?('=')
+
+          name = match[0][0..-2]
+          value = match[1]
+          attributes << AttributeNode.new(node, Attribute.new(name, value))
+
+          true
+        end
+
+        # The pattern to match the Gem::Specification block in the AST
+        # @return [RuboCop::AST::NodePattern] The Gem::Specification pattern
+        # @api private
+        def gem_specification_pattern
+          @gem_specification_pattern ||=
+            RuboCop::AST::NodePattern.new(<<~PATTERN)
+              (block (send (const (const nil? :Gem) :Specification) :new)(args (arg $_)) ...)
+            PATTERN
+        end
+
+        # The pattern to match a dependency declaration in the AST
+        # @return [RuboCop::AST::NodePattern] The dependency pattern
+        # @api private
+        def dependency_pattern
+          # :nocov: JRuby give false positive for this line being uncovered by tests
+          @dependency_pattern ||=
+            RuboCop::AST::NodePattern.new(<<~PATTERN)
+              (send
+                { (send _ :#{gemspec_object_name}) | (lvar :#{gemspec_object_name}) }
+                ${ :add_dependency :add_runtime_dependency :add_development_dependency }
+                (str $_gem_name)
+                <(str $_version_constraint) ...>
+              )
+            PATTERN
+          # :nocov:
+        end
+
+        # The pattern to match an attribute in the AST
+        # @return [RuboCop::AST::NodePattern] The attribute pattern
+        # @api private
+        def attribute_pattern
+          # :nocov: JRuby give false positive for this line being uncovered by tests
+          @attribute_pattern ||=
+            RuboCop::AST::NodePattern.new(<<~PATTERN)
+              (send
+                (lvar :#{gemspec_object_name}) $_name $_value
+              )
+            PATTERN
+          # :nocov:
+        end
+      end
+    end
+  end
+end
+
+require_relative 'gemspec/attribute'
+require_relative 'gemspec/attribute_node'
+require_relative 'gemspec/gem_specification'
+require_relative 'gemspec/delete_dependency'
+require_relative 'gemspec/dependency'
+require_relative 'gemspec/dependency_node'
+require_relative 'gemspec/upsert_dependency'

data/lib/bundler/gem_bytes/actions.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_bytes'
+
+module Bundler
+  module GemBytes
+    # The API for GemBytes templates
+    # @api public
+    module Actions
+      # The gemspec at `gemspec_path` is updated per instructions in `action_block`
+      #
+      # @example Adding a runtime dependency
+      #   actions = Actions.new
+      #   actions.gemspec(gemspec_path: 'test.gemspec') do
+      #     add_runtime_dependency 'rubocop', '~> 1.68'
+      #   end
+      #
+      # @param gemspec_path [String] the path to the gemspec file to process
+      #
+      #   Defaults to the first gemspec file found in the current directory.
+      #
+      # @yield a block with instructions to modify the gemspec
+      #
+      #   This block is run in the context of a {GemBytes::Actions::Gemspec} instance.
+      #   The instructions are methods defined by this instance (e.g.
+      #   `add_dependency`, `remove_dependency`, etc.)
+      #
+      # @yieldparam gemspec_name [Symbol] the name of the Gem::Specification varaible used in the gemspec
+      # @yieldparam gemspec [Gem::Specification] the evaluated gemspec
+      # @yieldreturn [String] the updated gemspec
+      #
+      # @return [void]
+      def gemspec(gemspec_path: Dir['*.gemspec'].first, &action_block)
+        source = File.read(gemspec_path)
+        action = Bundler::GemBytes::Actions::Gemspec.new(context: self)
+        updated_source = action.call(source, source_path: gemspec_path, &action_block)
+        File.write(gemspec_path, updated_source)
+      end
+    end
+  end
+end
+
+require_relative 'actions/gemspec'

data/lib/bundler/gem_bytes/bundler_command.rb

@@ -1,19 +1,19 @@
 # frozen_string_literal: true
 
+require 'bundler'
+
 module Bundler
   module GemBytes
     # A bundler command that adds features to your existing Ruby Gems project
-    #
     # @api public
-    #
     class BundlerCommand < Bundler::Plugin::API
-      # Called when the `gem-bytes` command is invoked
+      # Executes the `gem-bytes` command
       #
       # @example
-      #   BundlerCommand.new.exec('gem-bytes', ['path_or_uri_to_script'])
-      # @param _command [String] the command that was invoked (in this case, 'gem-bytes')
-      # @param args [Array<String>] any additional arguments passed to the command
-      # @raise [SystemExit] if there was an error executing the command
+      #   BundlerCommand.new.exec('gem-bytes', ['uri_or_path', *extra_args])
+      # @param _command [String] the invoked bundler command (in this case, 'gem-bytes')
+      # @param args [Array<String>] command arguments
+      # @raise [SystemExit] if an error occurs
       # @return [void]
       def exec(_command, args)
         uri_or_path = validate_args(args)