bundler-gem_bytes 0.2.0 → 0.2.2

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

@@ -7,47 +7,37 @@ module Bundler
     # The API for GemBytes templates
     # @api public
     module Actions
-      # Adds (or updates) a dependency in the project's gemspec file
+      # The gemspec at `gemspec_path` is updated per instructions in `action_block`
       #
-      # @example
-      #   add_dependency(:development, 'rspec', '~> 3.13')
-      #   add_dependency(:runtime, 'activesupport', '>= 6.0.0')
+      # @example Adding a runtime dependency
+      #   actions = Actions.new
+      #   actions.gemspec(gemspec_path: 'test.gemspec') do
+      #     add_runtime_dependency 'rubocop', '~> 1.68'
+      #   end
       #
-      # @param dependency_type [Symbol] the type of dependency to add (either :development or :runtime)
-      # @param gem_name [String] the name of the gem to add
-      # @param version_constraint [String] the version constraint for the gem
-      # @param force [Boolean] whether to overwrite the existing dependency
-      # @param gemspec [String] the path to the gemspec file
+      # @param gemspec_path [String] the path to the gemspec file to process
       #
-      # @return [void]
-      #
-      # @api public
+      #   Defaults to the first gemspec file found in the current directory.
       #
-      def add_dependency(dependency_type, gem_name, version_constraint, force: false, gemspec: Dir['*.gemspec'].first)
-        source = File.read(gemspec)
-        updated_source = Bundler::GemBytes::Gemspec::UpsertDependency.new(
-          dependency_type, gem_name, version_constraint, force: force
-        ).call(source, path: gemspec)
-        File.write(gemspec, updated_source)
-      end
-
-      # Removes a dependency from the project's gemspec file
+      # @yield a block with instructions to modify the gemspec
       #
-      # @example
-      #   remove_dependency('rspec')
+      #   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.)
       #
-      # @param gem_name [String] the name of the gem to add
-      # @param gemspec [String] the path to the gemspec file
+      # @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]
-      #
-      # @api public
-      #
-      def remove_dependency(gem_name, gemspec: Dir['*.gemspec'].first)
-        source = File.read(gemspec)
-        updated_source = Bundler::GemBytes::Gemspec::DeleteDependency.new(gem_name).call(source, path: gemspec)
-        File.write(gemspec, updated_source)
+      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

@@ -5,17 +5,15 @@ 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)

data/lib/bundler/gem_bytes/script_executor.rb

@@ -5,32 +5,52 @@ require_relative 'actions'
 
 module Bundler
   module GemBytes
-    # ScriptExecutor is responsible for executing scripts using Thor actions
+    # Responsible for executing scripts using Thor and GemBytes actions
     #
-    # @api public
+    # This class enables the execution of scripts from a file or URI, integrating
+    # with `Thor::Actions` to allow advanced file manipulation and action chaining.
+    # This can be particularly useful for tasks like creating or modifying files,
+    # managing dependencies, and implementing workflows for gem development.
     #
     # @example Executing a script from a file or URI
     #   executor = Bundler::GemBytes::ScriptExecutor.new
     #   executor.execute('path_or_uri_to_script')
+    # @api public
     class ScriptExecutor < ::Thor::Group
       include ::Thor::Actions
       include Bundler::GemBytes::Actions
 
-      # Set the source paths for Thor to use
-      # @return [Array<String>] the source paths
+      # Sets the source paths for `Thor::Actions`
+      #
+      # This determines where action scripts will be sourced from.
+      #
+      # By default, the source path is set to the current working directory, which
+      # allows scripts to access files from the local file system during execution.
+      #
+      # @return [Array<String>] the list of source paths
+      #
       # @api private
       def self.source_paths
-        # Add the current working directory or the directory of the script
         [Dir.pwd]
       end
 
-      # Executes the script from a URI or file path
+      # Executes a script from a given URI or file path
+      #
+      # This method loads the script located at the specified `path_or_uri` and
+      # executes it within the context of this class which includes `Thor::Actions`
+      # and `Bundler::GemBytes::ScriptExecutor`. This allows the script to perform
+      # tasks such as modifying files, creating directories, and other common file
+      # system operations.
       #
       # @param path_or_uri [String] the URI or file path to the script
+      #
       # @return [void]
+      #
       # @raise [RuntimeError] if the script cannot be loaded
+      #
       # @example Execute a script from a path
       #   execute('path/to/script.rb')
+      #
       def execute(path_or_uri)
         apply(path_or_uri)
       rescue StandardError => e

data/lib/bundler/gem_bytes/version.rb

@@ -3,6 +3,6 @@
 module Bundler
   module GemBytes
     # The version of this gem
-    VERSION = '0.2.0'
+    VERSION = '0.2.2'
   end
 end

data/lib/bundler/gem_bytes.rb

@@ -16,7 +16,7 @@ end
 require 'active_support'
 require 'thor'
 
+require_relative 'gem_bytes/actions'
 require_relative 'gem_bytes/bundler_command'
-require_relative 'gem_bytes/gemspec'
 require_relative 'gem_bytes/script_executor'
 require_relative 'gem_bytes/version'