bundler-ignore-dependency 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a572dd95bfbcf340640e90c3b98f408959bf7e60d86c0e83be7c457318887001
+  data.tar.gz: 8d0cc03de9e2246632ebaec86248f08944ae8a9fb6e17eb805a9eef6ad6a1e82
+SHA512:
+  metadata.gz: e34990614cfe7085aa0f70b917841f12dcaa547bf1b05d5ccafb6244c57a673cdf24c59fed249049ecbb198fbef3ed1a0572b7efe7e7b9255ed5a44375a4d6dc
+  data.tar.gz: 5d3d5c5a9655bda04e900f9a7086562a89ed2b1ae0edbb12d29de67a1ef850dc6d21b6b396310fd5a738aee8a3ea9338376434b6ee5dabf55ef40937358b7f44

data/lib/bundler/ignore_dependency/definition_patch.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "bundler/definition"
+
+module Bundler
+  module IgnoreDependency
+    # Adds ignored_dependencies attribute to Bundler::Definition
+    #
+    # Purpose: Stores the set of dependencies that should be ignored during
+    # dependency resolution. This attribute is populated by DSLPatch from the
+    # Gemfile's ignore_dependency! directives and is accessed by all other patches
+    # to determine which dependencies to filter.
+    #
+    # The attribute acts as the central source of truth for ignored dependencies
+    # throughout the entire dependency resolution and materialization process.
+    module DefinitionPatch
+      def ignored_dependencies
+        @ignored_dependencies ||= {}
+      end
+
+      attr_writer :ignored_dependencies
+    end
+  end
+
+  Definition.prepend(IgnoreDependency::DefinitionPatch)
+end

data/lib/bundler/ignore_dependency/dsl_patch.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "bundler/dsl"
+
+module Bundler
+  module IgnoreDependency
+    # Adds ignore_dependency! method to Bundler::Dsl (Gemfile DSL)
+    #
+    # Purpose: Provides the user-facing API for specifying which dependencies
+    # should be ignored. Users call ignore_dependency! in their Gemfile to mark
+    # dependencies (Ruby, RubyGems, or gems) that should be filtered out of
+    # dependency resolution and version constraint checking.
+    #
+    # When ignore_dependency! is called, it normalizes the dependency names
+    # (e.g., :ruby -> "Ruby\0") and stores them in @ignored_dependencies.
+    # These settings are then transferred to the Definition object via to_definition().
+    module DslPatch
+      def initialize
+        super
+        @ignored_dependencies = {}
+      end
+
+      def ignore_dependency!(name, type: :complete)
+        unless [:complete, :upper].include?(type)
+          raise ArgumentError, "type must be :complete or :upper, got #{type.inspect}"
+        end
+
+        key = normalize_dependency_name(name)
+        ignored_dependencies[key] = type
+      end
+
+      def to_definition(lockfile, unlock)
+        definition = super
+        definition.ignored_dependencies = ignored_dependencies.dup
+        definition
+      end
+
+      def ignored_dependencies
+        @ignored_dependencies ||= {}
+      end
+
+      private
+
+      def normalize_dependency_name(name)
+        case name
+        when :ruby
+          IgnoreDependency::RUBY_DEPENDENCY_NAME
+        when :rubygems
+          IgnoreDependency::RUBYGEMS_DEPENDENCY_NAME
+        when String
+          name
+        else
+          raise ArgumentError, "dependency name must be :ruby, :rubygems, or a gem name string"
+        end
+      end
+    end
+  end
+
+  Dsl.prepend(IgnoreDependency::DslPatch)
+end

data/lib/bundler/ignore_dependency/lazy_specification_patch.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Bundler
+  module IgnoreDependency
+    # Removes completely ignored gems from resolved gem specifications
+    #
+    # Purpose: After dependency resolution, LazySpecification objects are created
+    # from resolved specs. This patch intercepts that creation to remove completely
+    # ignored gems from the dependencies list.
+    #
+    # Critical for: Preventing ignored gems from appearing in the lockfile
+    # Without this patch, completely ignored gems would still appear in Gemfile.lock
+    # even though they're not actually being resolved.
+    #
+    # Flow: ResolverPatch filters during resolution → LazySpecificationPatch filters
+    # the resolved specs → MaterializationPatch prevents fetching
+    module LazySpecificationPatch
+      def from_spec(s)
+        filter_ignored_dependencies(super)
+      end
+
+      private
+
+      def filter_ignored_dependencies(lazy_spec)
+        ignored_names = IgnoreDependency.completely_ignored_gem_names
+
+        if ignored_names.any?
+          lazy_spec.dependencies.reject! do |dep|
+            ignored_names.include?(dep.name)
+          end
+        end
+
+        lazy_spec
+      end
+    end
+  end
+
+  LazySpecification.singleton_class.prepend(IgnoreDependency::LazySpecificationPatch)
+end

data/lib/bundler/ignore_dependency/match_metadata_patch.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "bundler/match_metadata"
+
+module Bundler
+  module IgnoreDependency
+    # Overrides Ruby and RubyGems version matching checks
+    #
+    # Purpose: Allows gems with restrictive Ruby/RubyGems version requirements
+    # to be installed even when the current environment doesn't meet those constraints.
+    #
+    # Behaviors:
+    # - When Ruby is completely ignored: accepts gems regardless of required_ruby_version
+    # - When Ruby upper bound is ignored: removes upper bounds from requirements,
+    #   allowing newer Ruby versions (e.g., Ruby 4.0 can install gems marked as < 4.0)
+    # - Same logic applies to RubyGems version matching
+    #
+    # Example: A gem with required_ruby_version = [">= 2.7", "< 3.0"] can be installed
+    # on Ruby 3.2 when ignore_dependency! :ruby, type: :upper is used.
+    module MatchMetadataPatch
+      def matches_current_ruby?
+        matches_version?(:ruby, Gem.ruby_version, @required_ruby_version)
+      end
+
+      def matches_current_rubygems?
+        matches_version?(:rubygems, Gem.rubygems_version, @required_rubygems_version)
+      end
+
+      private
+
+      def matches_version?(dependency_type, current_version, required_version)
+        return true if IgnoreDependency.send("#{dependency_type}_completely_ignored?")
+
+        requirement = if IgnoreDependency.send("#{dependency_type}_upper_bound_ignored?")
+          IgnoreDependency.remove_upper_bounds(required_version)
+        else
+          required_version
+        end
+
+        requirement.satisfied_by?(current_version)
+      end
+    end
+  end
+
+  MatchMetadata.prepend(IgnoreDependency::MatchMetadataPatch)
+end

data/lib/bundler/ignore_dependency/materialization_patch.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "bundler/materialization"
+
+module Bundler
+  module IgnoreDependency
+    # Prevents fetching/installing of completely ignored gems
+    #
+    # Purpose: During the materialization phase, Bundler prepares to actually
+    # install/download gems. This patch removes completely ignored gems from
+    # the list of dependencies to materialize.
+    #
+    # Critical for: Preventing unnecessary gem downloads and avoiding network
+    # errors when the server doesn't have compatible versions of ignored gems.
+    #
+    # Without this patch:
+    # - Bundler would try to fetch completely ignored gems from rubygems.org
+    # - If the gem doesn't exist or has no compatible platform, installation fails
+    # - Network bandwidth is wasted downloading gems that won't be used
+    #
+    # Flow: ResolverPatch filters during resolution → LazySpecificationPatch
+    # filters specs → MaterializationPatch prevents fetching
+    module MaterializationPatch
+      def dependencies
+        deps = super
+        ignored_names = IgnoreDependency.completely_ignored_gem_names
+
+        return deps if ignored_names.empty?
+
+        deps.reject { |dep, _| ignored_names.include?(dep.name) }
+      end
+    end
+  end
+
+  Materialization.prepend(IgnoreDependency::MaterializationPatch)
+end

data/lib/bundler/ignore_dependency/resolver_patch.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "bundler/resolver"
+
+module Bundler
+  module IgnoreDependency
+    # Filters dependencies during Bundler's resolution phase
+    #
+    # Purpose: This is the core filtering mechanism. During dependency resolution,
+    # it removes or modifies dependencies based on ignore rules:
+    # - Completely ignored dependencies are removed entirely (not part of resolution)
+    # - Upper bound ignored dependencies have their upper bounds removed (e.g., < 3.0)
+    #   while keeping lower bounds (e.g., >= 2.7)
+    #
+    # This ensures that:
+    # 1. Completely ignored gems don't participate in dependency resolution at all
+    # 2. Upper bound ignored constraints don't prevent newer versions from being resolved
+    # 3. Lower bounds are still respected (e.g., minimum version requirements)
+    #
+    # This filtering happens before the resolver sees dependencies, making it the
+    # primary mechanism for excluding dependencies from the resolution process.
+    module ResolverPatch
+      private
+
+      def to_dependency_hash(dependencies, packages)
+        super(filter_ignored_dependencies(dependencies), packages)
+      end
+
+      def filter_ignored_dependencies(deps)
+        ignored = IgnoreDependency.ignored_dependencies
+        return deps if ignored.empty?
+
+        deps.filter_map do |dep|
+          filter_dependency(dep, ignored)
+        end
+      end
+
+      def filter_dependency(dep, ignored)
+        case ignored[dep.name]
+        when :complete
+          nil # Remove the dependency entirely
+        when :upper
+          apply_upper_bound_filter(dep)
+        else
+          dep
+        end
+      end
+
+      def apply_upper_bound_filter(dep)
+        filtered = IgnoreDependency.remove_upper_bounds(dep.requirement)
+        Gem::Dependency.new(dep.name, filtered)
+      end
+    end
+  end
+
+  Resolver.prepend(IgnoreDependency::ResolverPatch)
+end

data/lib/bundler/ignore_dependency/shared_helpers_patch.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "bundler/shared_helpers"
+
+module Bundler
+  module IgnoreDependency
+    # Skips API validation for completely ignored gem dependencies
+    #
+    # Purpose: When Bundler fetches gem metadata from rubygems.org or other
+    # sources, it validates that the dependencies reported by the server match
+    # what was previously resolved. This validation raises an error if there's
+    # a mismatch (e.g., when a gem's dependencies change between versions).
+    #
+    # For completely ignored gems, we filter them out before validation because:
+    # 1. They won't be installed anyway
+    # 2. We don't care about their dependency structure
+    # 3. Differences in their deps shouldn't cause validation errors
+    #
+    # Without this patch, if a completely ignored gem has different dependencies
+    # in the API than before, bundle install would fail with APIResponseMismatchError.
+    module SharedHelpersPatch
+      def ensure_same_dependencies(spec, old_deps, new_deps)
+        super(spec, old_deps, IgnoreDependency.filter_ignored_gem_dependencies(new_deps))
+      end
+    end
+  end
+
+  SharedHelpers.singleton_class.prepend(IgnoreDependency::SharedHelpersPatch)
+end

data/lib/bundler/ignore_dependency/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Bundler
+  module IgnoreDependency
+    VERSION = "0.1.0"
+  end
+end

data/lib/bundler/ignore_dependency.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative "ignore_dependency/version"
+
+module Bundler
+  module IgnoreDependency
+    LOWER_BOUND_OPERATORS = [">=", ">", "="].freeze
+    RUBY_DEPENDENCY_NAME = "Ruby\0"
+    RUBYGEMS_DEPENDENCY_NAME = "RubyGems\0"
+
+    class << self
+      def ignored_dependencies
+        Bundler.definition&.ignored_dependencies || {}
+      end
+
+      def completely_ignored_gem_names
+        @completely_ignored_gem_names ||= ignored_dependencies.filter_map do |name, type|
+          # Filter out Ruby/RubyGems internal names (they contain \0)
+          name if type == :complete && !name.include?("\0")
+        end.to_set
+      end
+
+      def ignore_type_for(name)
+        ignored_dependencies[name]
+      end
+
+      def completely_ignored?(name)
+        ignore_type_for(name) == :complete
+      end
+
+      def upper_bound_ignored?(name)
+        ignore_type_for(name) == :upper
+      end
+
+      def ruby_completely_ignored?
+        completely_ignored?(RUBY_DEPENDENCY_NAME)
+      end
+
+      def ruby_upper_bound_ignored?
+        upper_bound_ignored?(RUBY_DEPENDENCY_NAME)
+      end
+
+      def rubygems_completely_ignored?
+        completely_ignored?(RUBYGEMS_DEPENDENCY_NAME)
+      end
+
+      def rubygems_upper_bound_ignored?
+        upper_bound_ignored?(RUBYGEMS_DEPENDENCY_NAME)
+      end
+
+      def remove_upper_bounds(requirement)
+        return Gem::Requirement.default if requirement.nil? || requirement.none?
+
+        lower_bounds = requirement.requirements.filter_map do |op, version|
+          if LOWER_BOUND_OPERATORS.include?(op)
+            [op, version]
+          elsif op == "~>"
+            # Pessimistic operator ~> X.Y means >= X.Y AND < X+1.0
+            # We keep only the lower bound part
+            [">=", version]
+          end
+          # Skip < and <= operators (upper bounds)
+        end
+
+        return Gem::Requirement.default if lower_bounds.empty?
+
+        Gem::Requirement.new(lower_bounds.map { |op, v| "#{op} #{v}" })
+      end
+
+      def apply_ignore_rule(requirement, name)
+        return Gem::Requirement.default if completely_ignored?(name)
+        return remove_upper_bounds(requirement) if upper_bound_ignored?(name)
+
+        requirement
+      end
+
+      def filter_ignored_gem_dependencies(dependencies)
+        ignored_names = completely_ignored_gem_names
+        return dependencies if ignored_names.empty?
+
+        dependencies.reject { |dep| ignored_names.include?(dep.name) }
+      end
+    end
+  end
+end
+
+require_relative "ignore_dependency/match_metadata_patch"
+require_relative "ignore_dependency/dsl_patch"
+require_relative "ignore_dependency/definition_patch"
+require_relative "ignore_dependency/resolver_patch"
+require_relative "ignore_dependency/lazy_specification_patch"
+require_relative "ignore_dependency/shared_helpers_patch"
+require_relative "ignore_dependency/materialization_patch"

data/plugins.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "lib/bundler/ignore_dependency"

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: bundler-ignore-dependency
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ufuk Kayserilioglu
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: A Bundler plugin that adds an ignore_dependency! DSL method to allow
+  ignoring version constraints on Ruby, RubyGems, or gem dependencies.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/bundler/ignore_dependency.rb
+- lib/bundler/ignore_dependency/definition_patch.rb
+- lib/bundler/ignore_dependency/dsl_patch.rb
+- lib/bundler/ignore_dependency/lazy_specification_patch.rb
+- lib/bundler/ignore_dependency/match_metadata_patch.rb
+- lib/bundler/ignore_dependency/materialization_patch.rb
+- lib/bundler/ignore_dependency/resolver_patch.rb
+- lib/bundler/ignore_dependency/shared_helpers_patch.rb
+- lib/bundler/ignore_dependency/version.rb
+- plugins.rb
+homepage: https://github.com/paracycle/bundler-ignore-dependency
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: Bundler plugin to ignore dependency version constraints
+test_files: []