Module: Bundler::Patch::ConservativeDefinition

Defined in:
lib/bundler/patch/conservative_definition.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#gems_to_update ⇒ Object

Returns the value of attribute gems_to_update.



3
4
5
 
# File 'lib/bundler/patch/conservative_definition.rb', line 3

def gems_to_update
  @gems_to_update
end

#minor_preferred ⇒ Object

pass-through options to ConservativeResolver



6
7
8
 
# File 'lib/bundler/patch/conservative_definition.rb', line 6

def minor_preferred
  @minor_preferred
end

#prefer_minimal ⇒ Object

pass-through options to ConservativeResolver



6
7
8
 
# File 'lib/bundler/patch/conservative_definition.rb', line 6

def prefer_minimal
  @prefer_minimal
end

#strict ⇒ Object

pass-through options to ConservativeResolver



6
7
8
 
# File 'lib/bundler/patch/conservative_definition.rb', line 6

def strict
  @strict
end

Instance Method Details

#resolve ⇒ Object

This copies more code than I’d like out of Bundler::Definition, but for now seems the least invasive way in. Backing up and intervening into the creation of a Definition instance itself involves a lot more code, a lot more preliminary data has to be gathered first.



11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
# File 'lib/bundler/patch/conservative_definition.rb', line 11

def resolve
  @resolve ||= begin
    last_resolve = converge_locked_specs
    if Bundler.settings[:frozen] || (!@unlocking && nothing_changed?)
      last_resolve
    else
      # Run a resolve against the locally available gems
      base = last_resolve.is_a?(Bundler::SpecSet) ? Bundler::SpecSet.new(last_resolve) : []
      bundler_version = Gem::Version.new(Bundler::VERSION)
      if bundler_version >= Gem::Version.new('1.13.0.rc.2')
        require 'bundler/patch/gem_version_patch_promoter'

        gvpp = Bundler::Patch::GemVersionPatchPromoter.new(@gem_version_promoter.locked_specs, @gem_version_promoter.unlock_gems)
        gvpp.level = @minor_preferred ? :minor : :patch
        gvpp.strict = @strict
        gvpp.minimal = @prefer_minimal
        gvpp.gems_to_update = @gems_to_update

        if bundler_version >= Gem::Version.new('1.14.0.rc.1')
          resolver = Bundler::Resolver.new(index, source_requirements, base, gvpp, additional_base_requirements_for_resolve, platforms)
        else
          resolver = Bundler::Resolver.new(index, source_requirements, base, nil, gvpp, additional_base_requirements_for_resolve)
        end
      else
        resolver = ConservativeResolver.new(index, source_requirements, base)
        locked_specs = if @unlocking && @locked_specs.length == 0
                         # Have to grab these again. Default behavior is to not store any
                         # locked_specs if updating all gems, because behavior is the same
                         # with no lockfile OR lockfile but update them all. In our case,
                         # we need to know the locked versions for conservative comparison.
                         locked = Bundler::LockfileParser.new(@lockfile_contents)
                         Bundler::SpecSet.new(locked.specs)
                       else
                         @locked_specs
                       end

        resolver.gems_to_update = @gems_to_update
        resolver.locked_specs = locked_specs
        resolver.strict = @strict
        resolver.minor_preferred = @minor_preferred
        resolver.prefer_minimal = @prefer_minimal
      end

      result = resolver.start(expanded_dependencies)
      spec_set = Bundler::SpecSet.new(result)
      last_resolve.merge spec_set
    end
  end
end