- @spec == other.spec && @request == other.request

- Gem::Platform.match @platform

- matching,

- @dependency == other.dependency && @requester == other.requester

- @remote = consider_remote?

- self.class, @domain, @specs.keys, always_install,

- Gem::Resolver::LockSpecification.new(self, name, version, @sources, platform)

-require 'rubygems/resolver/molinillo/lib/molinillo/gem_metadata'

-require 'rubygems/resolver/molinillo/lib/molinillo/errors'

-require 'rubygems/resolver/molinillo/lib/molinillo/resolver'

-require 'rubygems/resolver/molinillo/lib/molinillo/modules/ui'

-require 'rubygems/resolver/molinillo/lib/molinillo/modules/specification_provider'

-require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph/log'

-require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph/vertex'

- parent_node = vertex_named(parent_name)

- add_edge(parent_node, vertex, requirement)

- raise CircularDependencyError.new([origin, destination])

-require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph/action'

-require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph/action'

-require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph/action'

-require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph/action'

-require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph/add_edge_no_circular'

-require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph/add_vertex'

-require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph/delete_edge'

-require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph/detach_vertex_named'

-require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph/set_payload'

-require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph/tag'

-require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph/action'

-require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph/action'

- def up(_graph)

- def down(_graph)

- incoming_edges.map(&:requirement) + explicit_requirements

- # @return [Array<Vertex>] the vertices of {#graph} where `self` is a

- vertices = predecessors

- vertices += vertices.map(&:recursive_predecessors).flatten(1)

- vertices.uniq!

- # @return [Array<Vertex>] the vertices of {#graph} where `self` is an

- vertices = successors

- vertices += vertices.map(&:recursive_successors).flatten(1)

- vertices.uniq!

- equal?(other) || successors.any? { |v| v.path_to?(other) }

- @required_by = required_by

- # @param [Array<DependencyGraph::Vertex>] nodes the nodes in the dependency

- def initialize(nodes)

- super "There is a circular dependency between #{nodes.map(&:name).join(' and ')}"

- @dependencies = nodes.map(&:payload).to_set

- def initialize(conflicts)

- conflicts.values.flatten.map(&:requirements).flatten.each do |conflicting|

- VERSION = '0.5.7'.freeze

- output.puts debug_info.split("\n").map { |s| ' ' * depth + s }

- # @attr [Object] possibility the spec that was unable to be activated due

- # to a conflict

- :possibility,

- :activated_by_name

- break unless state.requirements.any? || state.requirement

- activated.freeze

- handle_missing_or_push_dependency_state(initial_state)

- require 'rubygems/resolver/molinillo/lib/molinillo/state'

- require 'rubygems/resolver/molinillo/lib/molinillo/modules/specification_provider'

- require 'rubygems/resolver/molinillo/lib/molinillo/delegates/resolution_state'

- require 'rubygems/resolver/molinillo/lib/molinillo/delegates/specification_provider'

- create_conflict if state.is_a? PossibilityState

- unwind_for_conflict until possibility && state.is_a?(DependencyState)

- # Creates the initial state for the resolution, based upon the

- # @return [DependencyState] the initial state for the resolution

- def initial_state

- original_requested.each { |r| dg.add_vertex(name_for(r), nil, true).tap { |v| v.explicit_requirements << r } }

- requirements = sort_dependencies(original_requested, graph, {})

- initial_requirement = requirements.shift

- DependencyState.new(

- initial_requirement && name_for(initial_requirement),

- requirements,

- graph,

- initial_requirement,

- initial_requirement && search_for(initial_requirement),

- 0,

- {}

- )

- debug(depth) { "Unwinding for conflict: #{requirement} to #{state_index_for_unwind / 2}" }

- sliced_states = states.slice!((state_index_for_unwind + 1)..-1)

- raise VersionConflict.new(c) unless state

- # @return [Integer] The index to which the resolution should unwind in the

- # case of conflict.

- def state_index_for_unwind

- current_requirement = requirement

- existing_requirement = requirement_for_existing_name(name)

- index = -1

- [current_requirement, existing_requirement].each do |r|

- until r.nil?

- current_state = find_state_for(r)

- if state_any?(current_state)

- current_index = states.index(current_state)

- index = current_index if current_index > index

- break

- r = parent_of(r)

- index

- return nil unless activated.vertex_named(name).payload

- states.reverse_each.find { |i| requirement == i.requirement && i.is_a?(DependencyState) }

- end

-

- # @return [Boolean] whether or not the given state has any possibilities

- # left.

- def state_any?(state)

- state && state.possibilities.any?

- def create_conflict

- vertex.incoming_edges.each { |edge| (requirements[edge.origin.payload] ||= []).unshift(edge.requirement) }

- activated.each { |v| activated_by_name[v.name] = v.payload if v.payload }

- vertex.payload,

- activated_by_name

- existing_node = activated.vertex_named(name)

- if existing_node.payload

- debug(depth) { "Found existing spec (#{existing_node.payload})" }

- attempt_to_activate_existing_spec(existing_node)

- attempt_to_activate_new_spec

- end

- end

-

- # Attempts to activate the current {#possibility} (given that it has

- # already been activated)

- # @return [void]

- def attempt_to_activate_existing_spec(existing_node)

- existing_spec = existing_node.payload

- if requirement_satisfied_by?(requirement, activated, existing_spec)

- new_requirements = requirements.dup

- push_state_for_requirements(new_requirements, false)

- else

- return if attempt_to_swap_possibility

- create_conflict

- debug(depth) { "Unsatisfied by existing spec (#{existing_node.payload})" }

- unwind_for_conflict

- end

- end

-

- # Attempts to swp the current {#possibility} with the already-activated

- # spec with the given name

- # @return [Boolean] Whether the possibility was swapped into {#activated}

- def attempt_to_swap_possibility

- activated.tag(:swap)

- vertex = activated.vertex_named(name)

- activated.set_payload(name, possibility)

- if !vertex.requirements.

- all? { |r| requirement_satisfied_by?(r, activated, possibility) } ||

- !new_spec_satisfied?

- activated.rewind_to(:swap)

- return

- end

- fixup_swapped_children(vertex)

- activate_spec

- end

-

- # Ensures there are no orphaned successors to the given {vertex}.

- # @param [DependencyGraph::Vertex] vertex the vertex to fix up.

- # @return [void]

- def fixup_swapped_children(vertex) # rubocop:disable Metrics/CyclomaticComplexity

- payload = vertex.payload

- deps = dependencies_for(payload).group_by(&method(:name_for))

- vertex.outgoing_edges.each do |outgoing_edge|

- requirement = outgoing_edge.requirement

- parent_index = @parents_of[requirement].last

- succ = outgoing_edge.destination

- matching_deps = Array(deps[succ.name])

- dep_matched = matching_deps.include?(requirement)

-

- # only push the current index when it was originally required by the

- # same named spec

- if parent_index && states[parent_index].name == name

- @parents_of[requirement].push(states.size - 1)

-

- if matching_deps.empty? && !succ.root? && succ.predecessors.to_a == [vertex]

- debug(depth) { "Removing orphaned spec #{succ.name} after swapping #{name}" }

- succ.requirements.each { |r| @parents_of.delete(r) }

-

- removed_names = activated.detach_vertex_named(succ.name).map(&:name)

- requirements.delete_if do |r|

- # the only removed vertices are those with no other requirements,

- # so it's safe to delete only based upon name here

- removed_names.include?(name_for(r))

- end

- elsif !dep_matched

- debug(depth) { "Removing orphaned dependency #{requirement} after swapping #{name}" }

- # also reset if we're removing the edge, but only if its parent has

- # already been fixed up

- @parents_of[requirement].push(states.size - 1) if @parents_of[requirement].empty?

-

- activated.delete_edge(outgoing_edge)

- requirements.delete(requirement)

- # Attempts to activate the current {#possibility} (given that it hasn't

- # already been activated)

- def attempt_to_activate_new_spec

- if new_spec_satisfied?

- activate_spec

- # @return [Boolean] whether the current spec is satisfied as a new

- # possibility.

- def new_spec_satisfied?

- unless requirement_satisfied_by?(requirement, activated, possibility)

- debug(depth) { 'Unsatisfied by requested spec' }

- return false

- end

-

- locked_requirement = locked_requirement_named(name)

-

- locked_spec_satisfied = !locked_requirement ||

- requirement_satisfied_by?(locked_requirement, activated, possibility)

- debug(depth) { 'Unsatisfied by locked spec' } unless locked_spec_satisfied

-

- locked_spec_satisfied

- def activate_spec

- # @param [Object] activated_spec the specification that has just been

- def require_nested_dependencies_for(activated_spec)

- nested_dependencies = dependencies_for(activated_spec)

- activated.add_child_vertex(name_for(d), nil, [name_for(activated_spec)], d)

- new_requirement = new_requirements.shift

- possibilities = new_requirement ? search_for(new_requirement) : []

- new_requirement, possibilities, depth, conflicts.dup

- # pushed, and the node in {#activated} is removed, and we continue

-require 'rubygems/resolver/molinillo/lib/molinillo/dependency_graph'

- require 'rubygems/resolver/molinillo/lib/molinillo/resolution'

- # @attr [Set<Object>] conflicts unresolved conflicts

- :conflicts

- new(nil, [], DependencyGraph.new, nil, nil, 0, Set.new)

- conflicts.dup

- Gem::Platform.match spec.platform