query stringlengths 7 9.5k | document stringlengths 10 1.07M | negatives listlengths 19 19 | metadata dict |
|---|---|---|---|
:category: Gem Dependencies DSL Restricts this gem dependencies file to the given ruby +version+. You may also provide +engine:+ and +engine_version:+ options to restrict this gem dependencies file to a particular ruby engine and its engine version. This matching is performed by using the RUBY_ENGINE and RUBY_ENGINE_VE... | def ruby(version, options = {})
engine = options[:engine]
engine_version = options[:engine_version]
raise ArgumentError,
'You must specify engine_version along with the Ruby engine' if
engine and not engine_version
return true if @installing
unless RUBY_VERSION == ve... | [
"def ruby version, options = {}\n engine = options[:engine]\n engine_version = options[:engine_version]\n\n raise ArgumentError,\n 'you must specify engine_version along with the ruby engine' if\n engine and not engine_version\n\n unless RUBY_VERSION == version then\n me... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
:category: Gem Dependencies DSL Sets +url+ as a source for gems for this dependency API. RubyGems uses the default configured sources if no source was given. If a source is set only that source is used. This method differs in behavior from Bundler: The +:gemcutter+, +:rubygems+ and +:rubyforge+ sources are not supporte... | def source(url)
Gem.sources.clear if @default_sources
@default_sources = false
Gem.sources << url
end | [
"def source url\n Gem.sources.clear if @default_sources\n\n @default_sources = false\n\n Gem.sources << url\n end",
"def source(url)\n sources = ::Bones.config.gem.sources\n sources << url unless sources.include? url\n nil\n end",
"def pin_gem_source(name, type = :default, source = n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Parses the requirements following the dependency +name+ and the +op+ for the first token of the requirements and returns a Gem::Dependency object. | def parse_dependency(name, op) # :nodoc:
return Gem::Dependency.new name, op unless peek[0] == :text
version = get(:text).value
requirements = ["#{op} #{version}"]
while peek.type == :comma do
get :comma
op = get(:requirement).value
version = get(:text).value
requirement... | [
"def parse_dependency name, op # :nodoc:\n return Gem::Dependency.new name unless peek[0] == :text\n\n _, version, = get :text\n\n requirements = [\"#{op} #{version}\"]\n\n while peek[0] == :comma do\n get :comma\n _, op, = get :requirement\n _, version, = get :text\n\n requirem... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Calculates the column (by byte) and the line of the current token based on +byte_offset+. | def token_pos(byte_offset) # :nodoc:
[byte_offset - @line_pos, @line]
end | [
"def token_pos byte_offset # :nodoc:\n [byte_offset - @line_pos, @line]\n end",
"def get_line_and_column_from_chunk(offset)\n if offset.zero?\n return [@chunk_line, @chunk_column]\n end\n\n string =\n offset >= @chunk.size ? @chunk : @chunk[0..offset-1]\n\n line_count = string.count(\"\\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Writes the lock file alongside the gem dependencies file | def write
content = to_s
File.open "#{@gem_deps_file}.lock", 'w' do |io|
io.write content
end
end | [
"def write\n open \"#{@gem_deps_file}.lock\", 'w' do |io|\n io.write to_s\n end\n end",
"def write_versionlock_file\n transform_str = \"<transform pkg depend -> default facet.version-lock.*> false>\"\n File.write(\"#{staging_dir}/version-lock\", transform_str)\n end",
"def write_lock\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Declare that a gem of name +name+ with +reqs+ requirements is needed. | def gem(name, *reqs)
if dep = @dependency_names[name]
dep.requirement.concat reqs
else
dep = Gem::Dependency.new name, *reqs
@dependency_names[name] = dep
@dependencies << dep
end
end | [
"def gem(name, *reqs)\n @dependencies << Gem::Dependency.new(name, reqs)\n end",
"def gem_requires name, options # :nodoc:\n if options.include? :require then\n if requires = options.delete(:require) then\n @requires[name].concat Array requires\n end\n else\n @requires[name] <<... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Installs gems for this RequestSet using the Gem::Installer +options+. If a +block+ is given an activation +request+ and +installer+ are yielded. The +installer+ will be +nil+ if a gem matching the request was already installed. | def install(options, &block) # :yields: request, installer
if dir = options[:install_dir]
requests = install_into dir, false, options, &block
return requests
end
@prerelease = options[:prerelease]
requests = []
download_queue = Thread::Queue.new
# Create a thread-safe list of gems... | [
"def install(options = {})\n require_relative '../installer'\n\n gem = download options\n\n installer = Gem::Installer.at gem, options\n\n yield installer if block_given?\n\n @spec = installer.install\n end",
"def install_from_gemdeps(options, &block)\n gemdeps = options[:gemdeps]\n\n @insta... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Installs from the gem dependencies files in the +:gemdeps+ option in +options+, yielding to the +block+ as in install. If +:without_groups+ is given in the +options+, those groups in the gem dependencies file are not used. See Gem::Installer for other +options+. | def install_from_gemdeps(options, &block)
gemdeps = options[:gemdeps]
@install_dir = options[:install_dir] || Gem.dir
@prerelease = options[:prerelease]
@remote = options[:domain] != :local
@conservative = true if options[:conservative]
gem_deps_api = load_gemdeps gemdeps, options[:witho... | [
"def add_dependencies(groups, dependencies) # :nodoc:\n return unless (groups & @without_groups).empty?\n\n dependencies.each do |dep|\n @set.gem dep.name, *dep.requirement.as_list\n end\n end",
"def add_dependencies groups, dependencies # :nodoc:\n return unless (groups & @without_groups).empty... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
The error message for the missing dependency, including the specifications that had this dependency. | def message
sources = required_by.map { |r| "`#{r}`" }.join(' and ')
message = "Unable to find a specification for `#{dependency}`"
message += " depended upon by #{sources}" unless sources.empty?
message
end | [
"def error_message\n @load.each {|f| loadable?(f, true) }\n \"Cyclic dependency prevented loading \\n#{@load.join(\"\\n\")}\"\n end",
"def failure_message\n unmet_expecations_messages << errors.join(\"\\n\")\n end",
"def _dependency_error(req, src, msg)\n raise LoadError, sprintf(msg, req, s... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Initializes a new error with the given circular vertices. | def initialize(vertices)
super "There is a circular dependency between #{vertices.map(&:name).join(' and ')}"
@dependencies = vertices.map { |vertex| vertex.payload.possibilities.last }.to_set
end | [
"def initialize\n #@vertices is ALL vertices on the graph\n @vertices = []\n #@edges is ALL edges on the graph\n @edges = []\n end",
"def initialize(*args)\n if args.first.is_a?(Circle)\n circle = args.shift\n @c = circle.c\n @r = circle.r\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns true if the set will compare its elements by their identity. Also see Setcompare_by_identity. | def compare_by_identity?
@hash.respond_to?(:compare_by_identity?) && @hash.compare_by_identity?
end | [
"def compare_by_identity?\n @hash.compare_by_identity?\n end",
"def identity?\n return false unless square? #must be a square matrix\n \n for curr_row_num in 0...@rows\n for curr_col_num in 0...@cols\n return false unless ((curr_row_num == curr_col_num && get(curr_row_num, curr_col_... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns self if no arguments are given. Otherwise, converts the set to another with `klass.new(self, args, &block)`. In subclasses, returns `klass.new(self, args, &block)` unless overridden. | def to_set(klass = Set, *args, &block)
return self if instance_of?(Set) && klass == Set && block.nil? && args.empty?
klass.new(self, *args, &block)
end | [
"def to_set(klass = IntegerSet, *args, &block)\n return self if instance_of?(IntegerSet) && klass == IntegerSet && block.nil? && args.empty?\n klass.new(self, *args, &block)\n end",
"def another\n self.class.new(nil, options)\n end",
"def initialize(set=[])\n if set.is_a? Array\n @set = set.d... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns 0 if the set are equal, 1 / +1 if the set is a proper subset / superset of the given set, or nil if they both have unique elements. | def <=>(set)
return unless set.is_a?(Set)
case size <=> set.size
when -1 then -1 if proper_subset?(set)
when +1 then +1 if proper_superset?(set)
else 0 if self.==(set)
end
end | [
"def likeness(a_set)\n return(0.0) if Set != a_set.class || a_set.empty?\n (self & a_set).size.to_f / a_set.size.to_f\n end",
"def proper_superset?(set)\n return self != set && superset?(set) if set.is_a?(IntegerSet)\n set.is_a?(Set) or raise ArgumentError, \"value must be a set\"\n return false i... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns true if the set and the given enumerable have at least one element in common. Set[1, 2, 3].intersect? Set[4, 5] => false Set[1, 2, 3].intersect? Set[3, 4] => true Set[1, 2, 3].intersect? 4..5 => false Set[1, 2, 3].intersect? [3, 4] => true | def intersect?(set)
case set
when Set
if size < set.size
any? { |o| set.include?(o) }
else
set.any? { |o| include?(o) }
end
when Enumerable
set.any? { |o| include?(o) }
else
raise ArgumentError, "value must be enumerable"
end
end | [
"def intersect?(set)\n set.is_a?(Set) or raise ArgumentError, \"value must be a set\"\n if size < set.size\n any? { |o| set.include?(o) }\n else\n set.any? { |o| include?(o) }\n end\n end",
"def intersect?(set)\n return (@val & set.to_i) > 0 if set.is_a?(IntegerSet)\n set.is_a?(Set) o... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns true if two sets are equal. The equality of each couple of elements is defined according to Objecteql?. Set[1, 2] == Set[2, 1] => true Set[1, 3, 5] == Set[1, 5] => false Set['a', 'b', 'c'] == Set['a', 'c', 'b'] => true Set['a', 'b', 'c'] == ['a', 'c', 'b'] => false | def ==(other)
if self.equal?(other)
true
elsif other.instance_of?(self.class)
@hash == other.instance_variable_get(:@hash)
elsif other.is_a?(Set) && self.size == other.size
other.all? { |o| @hash.include?(o) }
else
false
end
end | [
"def set_eql?(set1, set2)\n return set1.eql?(set2) unless ruby1_8_6?\n set1.to_a.uniq.sort_by {|e| e.hash}.eql?(set2.to_a.uniq.sort_by {|e| e.hash})\n end",
"def ==(other_set)\n requires_set(other_set, __method__)\n other_set.instance_eval { @internal_hash } == @internal_hash\n end",... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Rewinds the graph to the state tagged as `tag` | def rewind_to(tag)
log.rewind_to(self, tag)
end | [
"def rollback\n reset\n machine.write(object, :state, from)\n end",
"def advance(state)\n @state = state\n end",
"def pop_state\n @new_state = nil\n @state = @stack.pop\n end",
"def tag(name)\r\n tagged_finals = finals.map{|state| state.tag(name)}.to_set\r\n tagged_... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns the dependencies of `specification`. | def dependencies_for(specification)
[]
end | [
"def dependencies\n spec.dependencies\n end",
"def dependencies\n @dependencies.collect { |name, dependency| dependency }\n end",
"def dependencies_for(artifact)\n raise \"dependencies_for() not implemented\"\n end",
"def dependencies\n @dependencies.values\n end",
"d... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Determines whether two arrays of dependencies are equal, and thus can be grouped. | def dependencies_equal?(dependencies, other_dependencies)
dependencies == other_dependencies
end | [
"def all_eql?(arr)\n arr.each_cons(2).all? { |x, y| x == y }\n end",
"def array_equals(array1, array2)\n flag = 0\n if array1.nil? && array2.nil?\n return true\n elsif array1.nil? || array2.nil?\n return false\n elsif array1.length != array2.length\n return false\n end\n # array1.length == ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Ends the resolution process | def end_resolution
resolver_ui.after_resolution
debug do
"Finished resolution (#{@iteration_counter} steps) " \
"(Took #{(ended_at = Time.now) - @started_at} seconds) (#{ended_at})"
end
debug { 'Unactivated: ' + Hash[activated.vertices.reject { |_n, v| v.payload }].ke... | [
"def on_end_process()\n # subclasses may override this method\n end",
"def close\n @processor.finish\n end",
"def finish()\n @device.finish() ;\n end",
"def process_end\n end",
"def finish()\n\t\t\t@output.puts(\"... game finished.\")\n\t\tend",
"def finish(command)\n # calle... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Unwinds the states stack because a conflict has been encountered | def unwind_for_conflict
details_for_unwind = build_details_for_unwind
unwind_options = unused_unwind_options
debug(depth) { "Unwinding for conflict: #{requirement} to #{details_for_unwind.state_index / 2}" }
conflicts.tap do |c|
sliced_states = states.slice!((details_for_unwind... | [
"def unwind_for_conflict\n debug(depth) { \"Unwinding for conflict: #{requirement}\" }\n conflicts.tap do |c|\n states.slice!((state_index_for_unwind + 1)..-1)\n raise VersionConflict.new(c) unless state\n state.conflicts = c\n end\n end",
"def unwind_exit_stat... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Raises a VersionConflict error, or any underlying error, if there is no current state | def raise_error_unless_state(conflicts)
return if state
error = conflicts.values.map(&:underlying_error).compact.first
raise error || VersionConflict.new(conflicts, specification_provider)
end | [
"def unwind_for_conflict\n debug(depth) { \"Unwinding for conflict: #{requirement}\" }\n conflicts.tap do |c|\n states.slice!((state_index_for_unwind + 1)..-1)\n raise VersionConflict.new(c) unless state\n state.conflicts = c\n end\n end",
"def check_version_co... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Filter's a state's possibilities to remove any that would not satisfy the requirements in the conflict we've just rewound from | def filter_possibilities_for_primary_unwind(unwind_details)
unwinds_to_state = unused_unwind_options.select { |uw| uw.state_index == unwind_details.state_index }
unwinds_to_state << unwind_details
unwind_requirement_sets = unwinds_to_state.map(&:conflicting_requirements)
state.possibili... | [
"def clean_components\n conditions.delete(conditions.reject(&:active))\n effects.delete(effects.reject(&:active))\n nil\n end",
"def forbidden(state, forbidden_combos)\r\n\tforbidden = false\r\n\tfor forbidden_combo in forbidden_combos\r\n\t\t#A combo is satisfied if all its assignments are satisfied.\r... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Attempts to update the existing vertex's `PossibilitySet` with a filtered version | def attempt_to_filter_existing_spec(vertex)
filtered_set = filtered_possibility_set(vertex)
if !filtered_set.possibilities.empty?
activated.set_payload(name, filtered_set)
new_requirements = requirements.dup
push_state_for_requirements(new_requirements, false)
else
... | [
"def filtered_possibility_set(vertex)\n PossibilitySet.new(vertex.payload.dependencies, vertex.payload.possibilities & possibility.possibilities)\n end",
"def test_remove_vertex_invalid\n\n puts 'Test remove vertex invalid'\n graph = GraphAPI.new\n vertex_list = ['A','B','C','D','E'].to_set\n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Generates a filtered version of the existing vertex's `PossibilitySet` using the current state's `requirement` | def filtered_possibility_set(vertex)
PossibilitySet.new(vertex.payload.dependencies, vertex.payload.possibilities & possibility.possibilities)
end | [
"def attempt_to_filter_existing_spec(vertex)\n filtered_set = filtered_possibility_set(vertex)\n if !filtered_set.possibilities.empty?\n activated.set_payload(name, filtered_set)\n new_requirements = requirements.dup\n push_state_for_requirements(new_requirements, false)\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Checks a proposed requirement with any existing locked requirement before generating an array of possibilities for it. | def possibilities_for_requirement(requirement, activated = self.activated)
return [] unless requirement
if locked_requirement_named(name_for(requirement))
return locked_requirement_possibility_set(requirement, activated)
end
group_possibilities(search_for(requirement))
e... | [
"def findRequestablePieces\n piecesRequired = []\n\n removeOldRequests\n\n @numPieces.times do |pieceIndex|\n piecesRequired.push pieceIndex if ! @completePieces.set?(pieceIndex) && ! @requestedPieces.set?(pieceIndex)\n end\n\n piecesRequired\n end",
"def locked_candidates_1\n\n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Build an array of PossibilitySets, with each element representing a group of dependency versions that all have the same subdependency version constraints and are contiguous. | def group_possibilities(possibilities)
possibility_sets = []
current_possibility_set = nil
possibilities.reverse_each do |possibility|
dependencies = dependencies_for(possibility)
if current_possibility_set && dependencies_equal?(current_possibility_set.dependencies, depende... | [
"def recursive_subsets\n result = Set.new\n queue = subsets.to_a.dup\n until queue.empty?\n g = queue.shift\n result << g\n queue.concat(g.subsets.to_a)\n end\n result\n end... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Called before resolution begins. | def before_resolution
output.print 'Resolving dependencies...'
end | [
"def before_resolution\n end",
"def after_resolution\n end",
"def preReady()\n\t\t\t#does nothing. extend in subclasses\n\t\tend",
"def set_resolver(p0) end",
"def resolver() end",
"def before_setup\n # do nothing by default\n end",
"def on_dependency_resolve_handlers; end",
"def pre... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Called after resolution ends (either successfully or with an error). By default, prints a newline. | def after_resolution
output.puts
end | [
"def before_resolution\n output.print 'Resolving dependencies...'\n end",
"def end_resolution\n resolver_ui.after_resolution\n debug do\n \"Finished resolution (#{@iteration_counter} steps) \" \\\n \"(Took #{(ended_at = Time.now) - @started_at} seconds) (#{ended_at})\"\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Whether or not debug messages should be printed. By default, whether or not the `MOLINILLO_DEBUG` environment variable is set. | def debug?
return @debug_mode if defined?(@debug_mode)
@debug_mode = ENV['MOLINILLO_DEBUG']
end | [
"def debug?\n ENV['DEBUG'] == 'true'\n end",
"def debug?\n @debug || ENV['HATCHET_DEBUG'] || false\n end",
"def debug?\n DEBUG == log_level\n end",
"def debug_on\r\n @@debug =1\r\n end",
"def debug?\n debugging || !ENV['DEBUG'].nil?\n end",
"def debug?\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Downloads a gem at +path+ and returns the file path. | def download(path)
Gem.ensure_gem_subdirectories path
if @spec.respond_to? :sources
exception = nil
path = @spec.sources.find do |source|
begin
source.download full_spec, path
rescue exception
end
end
return path if path
raise exception if e... | [
"def gem_path\n @path || downloaded_gem_path\n end",
"def gem_path\n @path || downloaded_gem_path\n end",
"def download_gem\n gem_path = \"https://rubygems.org/gems/#{@name}-#{@version}.gem\"\n curl = Curl::Easy.new(gem_path)\n curl.follow_location = true\n curl.http_get\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
The version of this activation request's specification | def version
@spec.version
end | [
"def request_version\n @request_version == '' ? nil : @request_version\n end",
"def version\n request = Request::MetaRequest.new\n rest_get(request.version, {\"Accept\" => \"text/plain\"}).strip\n end",
"def version(req)\n req.params.fetch('version', 'current')\n end",
"def ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
The platform of this activation request's specification | def platform
@spec.platform
end | [
"def _platform\n @platform\n end",
"def platform_name\n capabilities['platformName']\n end",
"def platform_type\n return @platform_type\n end",
"def platform\n \"#{@vm}-#{@os}-#{@impl}-#{@arch}\"\n end",
"def platform_name\n return @config['os']['plat... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns true if the conflicting dependency's name matches +spec+. | def for_spec?(spec)
@dependency.name == spec.name
end | [
"def matches_spec?(spec)\n @dependency.matches_spec? spec\n end",
"def matches_spec? spec\n name == spec.name and requirement.satisfied_by? spec.version\n end",
"def satisfied_by?(spec)\n return false unless requirement\n spec = ArtifactNamespace.to_hash(spec)\n hash = to_spec_h... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates a new DependencyRequest for +dependency+ from +requester+. +requester may be nil if the request came from a user. | def initialize(dependency, requester)
@dependency = dependency
@requester = requester
end | [
"def requestor\n @requestor ||= requestor_class.new(self)\n end",
"def create\n @requester = Requester.new(requester_params)\n\n respond_to do |format|\n if @requester.save\n format.html { redirect_to @requester, notice: 'Requester was successfully created.' }\n format.json { ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Is this dependency a development dependency? | def development?
@dependency.type == :development
end | [
"def fetch_development_dependencies # :nodoc:\n end",
"def include_dev?\n config.dig(\"composer\", \"include_dev\") == true\n end",
"def development_dependencies\n dependencies.select {|d| d.type == :development }\n end",
"def has_dependency?\n return true unless @dependency.nil?\n end",
... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Does this dependency request match +spec+? NOTE: matches_spec? matches prerelease versions. See also match? | def matches_spec?(spec)
@dependency.matches_spec? spec
end | [
"def matches_spec? spec\n name == spec.name and requirement.satisfied_by? spec.version\n end",
"def satisfied_by?(spec)\n return false unless requirement\n spec = ArtifactNamespace.to_hash(spec)\n hash = to_spec_hash\n hash.delete(:version)\n version = spec.delete(:versi... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Adds Resolver::DependencyRequest +req+ to this requirements list. | def add(req)
if req.requirement.exact?
@exact.push req
else
@list.push req
end
req
end | [
"def add_require(req)\n #TODO: Implement config of requires allowed\n raise Exception.new(\"Is not a require valid!\") unless req =~ /\\S+/ \n @requires << req\n @requires.uniq!\n end",
"def requirements=(req)\n @requirements = Array req\n end",
"def req(*requirements)\n return req... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Remove the oldest DependencyRequest from the list. | def remove
return @exact.shift unless @exact.empty?
@list.shift
end | [
"def remove_down_request(num_requests)\n down_queue.shift(num_requests)\n end",
"def remove_request()\n return @request_queue.shift\n end",
"def removeOldRequests\n now = Time.new\n @requestedPieces.length.times do |i|\n if @requestedPieces.set? i\n if now - @pieceRequestTime[i... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
The prefetch method may be overridden, but this is not necessary. This default implementation does nothing, which is suitable for sets where looking up a specification is cheap (such as installed gems). When overridden, the prefetch method should look up specifications matching +reqs+. | def prefetch(reqs)
end | [
"def prefetch(reqs)\n @sets.each {|s| s.prefetch(reqs) }\n end",
"def prefetch(reqs)\n return unless @remote\n names = reqs.map {|r| r.dependency.name }\n needed = names - @data.keys - @to_fetch\n\n @to_fetch += needed\n end",
"def prefetch(reqs)\n names = reqs.map { |r| r.dependency.nam... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates a new APISet that will retrieve gems from +uri+ using the RubyGems API URL +dep_uri+ which is described at | def initialize(dep_uri = 'https://index.rubygems.org/info/')
super()
dep_uri = URI dep_uri unless URI === dep_uri
@dep_uri = dep_uri
@uri = dep_uri + '..'
@data = Hash.new {|h,k| h[k] = [] }
@source = Gem::Source.new @uri
@to_fetch = []
end | [
"def add_dependency(uri)\n self.config = hash_reassoc(config, :dependencies) do |set|\n set + Set.new([uri])\n end\n end",
"def build_gem_request_universe(extra_request_sets = [], gem_to_force_update = nil)\n installed_plugins_gem_set = Gem::Resolver::VendorSet.new\n loader.list_mana... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Return an array of APISpecification objects matching DependencyRequest +req+. | def find_all(req)
res = []
return res unless @remote
if @to_fetch.include?(req.name)
prefetch_now
end
versions(req.name).each do |ver|
if req.dependency.match? req.name, ver[:number], @prerelease
res << Gem::Resolver::APISpecification.new(self, ver)
end
end
res
... | [
"def find_all(req)\n res = []\n\n versions(req.name).each do |ver|\n if req.dependency.match? req.name, ver[:number]\n res << APISpecification.new(self, ver)\n end\n end\n\n res\n end",
"def find_all req\n res = []\n\n versions(req.name).each do ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
A hint run by the resolver to allow the Set to fetch data for DependencyRequests +reqs+. | def prefetch(reqs)
return unless @remote
names = reqs.map {|r| r.dependency.name }
needed = names - @data.keys - @to_fetch
@to_fetch += needed
end | [
"def prefetch(reqs)\n names = reqs.map { |r| r.dependency.name }\n needed = names.find_all { |d| !@data.key?(d) }\n\n return if needed.empty?\n\n uri = @dep_uri + \"?gems=#{needed.sort.join ','}\"\n str = Gem::RemoteFetcher.fetcher.fetch_path uri\n\n Marshal.load(str).each ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Sets the remote network access for all composed sets. | def remote=(remote)
super
@sets.each {|set| set.remote = remote }
end | [
"def remote_set_immutable(host, files)\n Pkg::Util::Net.remote_execute(host, \"sudo chattr +i #{files.join(' ')}\")\n end",
"def netset\n obj_retry(\"link\") do; nav.link(:text, 'Network Settings'); end\n end",
"def remote_set_immutable(host, files)\n remote_ssh_cmd(host, \"sudo chattr +i #{files.j... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Prefetches +reqs+ in all sets. | def prefetch(reqs)
@sets.each {|s| s.prefetch(reqs) }
end | [
"def prefetch(reqs)\n end",
"def prefetch(reqs)\n return unless @remote\n names = reqs.map {|r| r.dependency.name }\n needed = names - @data.keys - @to_fetch\n\n @to_fetch += needed\n end",
"def prefetch(reqs)\n names = reqs.map { |r| r.dependency.name }\n needed = names.find_all { |... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Picks which sets to use for the configured sources. | def pick_sets # :nodoc:
@sources.each_source do |source|
@sets << source.dependency_resolver_set
end
end | [
"def sources\n @sources ||= SourcePool.new\n end",
"def sources=(value)\n @sources = value\n end",
"def build_static_sets\n sets = []\n if @options[:sets]\n @options[:sets].each_pair do |k,v|\n set_spec = v[:set_spec] if v.has_key? :set_spec\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Replaces a failed APISet for the URI in +error+ with an IndexSet. If no matching APISet can be found the original +error+ is raised. The calling method must retry the exception to repeat the lookup. | def replace_failed_api_set(error) # :nodoc:
uri = error.original_uri
uri = URI uri unless URI === uri
uri = uri + "."
raise error unless api_set = @sets.find do |set|
Gem::Resolver::APISet === set and set.dep_uri == uri
end
index_set = Gem::Resolver::IndexSet.new api_set.source
@set... | [
"def set_aggregate_failures_exception(exception); end",
"def error_set\n TaskResults.new(@results.select(&:error))\n end",
"def with_exception_handling\n retries = 0\n max_retries = @max_retries || 3\n begin\n yield\n # reset counter of faulty_host for the current ho... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Adds and returns a GitSpecification with the given +name+ and +version+ which came from a +repository+ at the given +reference+. If +submodules+ is true they are checked out along with the repository. This fills in the prefetch information as enough information about the gem is present in the arguments. | def add_git_spec(name, version, repository, reference, submodules) # :nodoc:
add_git_gem name, repository, reference, submodules
source = Gem::Source::Git.new name, repository, reference
source.root_dir = @root_dir
spec = Gem::Specification.new do |s|
s.name = name
s.version = version
... | [
"def gem_git(name, options) # :nodoc:\n if gist = options.delete(:gist)\n options[:git] = \"https://gist.github.com/#{gist}.git\"\n end\n\n return unless repository = options.delete(:git)\n\n pin_gem_source name, :git, repository\n\n reference = gem_git_reference options\n\n submodules = opti... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Prefetches specifications from the git repositories in this set. | def prefetch(reqs)
return unless @specs.empty?
@repositories.each do |name, (repository, reference)|
source = Gem::Source::Git.new name, repository, reference
source.root_dir = @root_dir
source.remote = @remote
source.specs.each do |spec|
git_spec = Gem::Resolver::GitSpecificat... | [
"def repositories\n @repositories ||= repositories_from_yaml[\"Catalog\"][\"repositories\"]\n end",
"def fetch_changesets\n puts \"Calling fetch changesets on #{clone_path}\"\n # runs git fetch\n self.fetch\n super\n end",
"def repositories\n @repositories ||= @ogm_repos ? super.compac... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Return an array of IndexSpecification objects matching DependencyRequest +req+. | def find_all(req)
res = []
return res unless @remote
name = req.dependency.name
@all[name].each do |uri, n|
if req.match? n, @prerelease
res << Gem::Resolver::IndexSpecification.new(
self, n.name, n.version, uri, n.platform)
end
end
res
end | [
"def find_all(req)\n res = []\n\n name = req.dependency.name\n\n @all[name].each do |uri, n|\n if req.dependency.match? n\n res << IndexSpecification.new(self, n.name, n.version,\n uri, n.platform)\n end\n end\n\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
:nodoc: Creates a new InstallerSet that will look for gems in +domain+. | def initialize(domain)
super()
@domain = domain
@f = Gem::SpecFetcher.fetcher
@always_install = []
@ignore_dependencies = false
@ignore_installed = false
@local = {}
@local_source = Gem::Source::Local.new
@remote_set = Gem::Resolver::BestSet.n... | [
"def build_gem_request_universe(extra_request_sets = [], gem_to_force_update = nil)\n installed_plugins_gem_set = Gem::Resolver::VendorSet.new\n loader.list_managed_gems.each do |spec|\n next if spec.name == gem_to_force_update\n\n installed_plugins_gem_set.add_vendor_gem(spec.name, spec.gem... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Looks up the latest specification for +dependency+ and adds it to the always_install list. | def add_always_install(dependency)
request = Gem::Resolver::DependencyRequest.new dependency, nil
found = find_all request
found.delete_if do |s|
s.version.prerelease? and not s.local?
end unless dependency.prerelease?
found = found.select do |s|
Gem::Source::SpecificFile === s.source... | [
"def dependency(dependency, version = nil)\n dependency = Juicer::Install.get(dependency) if [String, Symbol].include?(dependency.class)\n\n @dependencies[dependency.to_s + (version || \"\")] = [dependency, version]\n end",
"def ensure_dependency!(spec, dependency)\n raise \"#{spec.name} r... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Adds a local gem requested using +dep_name+ with the given +spec+ that can be loaded and installed using the +source+. | def add_local(dep_name, spec, source)
@local[dep_name] = [spec, source]
end | [
"def install_gem_from_source(repo_url, git_ref, gem_name = nil)\n uri = URI.parse(repo_url)\n repo_basename = ::File.basename(uri.path)\n repo_name = repo_basename.match(/(?<name>.*)\\.git/)[:name]\n gem_name ||= repo_name\n\n Chef::Log.debug(\"Building #{gem_name} gem from source\")\n\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Has a local gem for +dep_name+ been added to this set? | def local?(dep_name) # :nodoc:
spec, _ = @local[dep_name]
spec
end | [
"def dep_check\n $gems_required.each do |current_gem|\n begin\n if current_gem.include? \",\"\n tokens = current_gem.split(\",\")\n gem tokens[0], tokens[1]\n else\n gem current_gem\n end\n rescue Gem::LoadError\n if current_gem.include? \",\"\n $gems_missing_v... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
:nodoc: Creates a new LockSet from the given +sources+ | def initialize(sources)
super()
@sources = sources.map do |source|
Gem::Source::Lock.new source
end
@specs = []
end | [
"def from(*sources)\n @sources |= sources.flatten\n guess_compiler if @compiler.nil? && sources.flatten.any? { |source| File.exist?(source.to_s) }\n self\n end",
"def from(*sources)\n @sources |= sources.flatten.map { |dir| file(File.expand_path(dir.to_s)) }\n self\n end",
"def in... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates a new IndexSpecification in this set using the given +name+, +version+ and +platform+. The specification's set will be the current set, and the source will be the current set's source. | def add(name, version, platform) # :nodoc:
version = Gem::Version.new version
specs = [
Gem::Resolver::LockSpecification.new(self, name, version, @sources, platform),
]
@specs.concat specs
specs
end | [
"def initialize name, version, platform = nil, source = nil, &specblock\n @dependencies = []\n @name = name\n @platform = platform || Gem::Platform::RUBY\n @source = source\n @specblock = specblock || MISSING\n @version = Gem::Version.create version\n end",... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Loads a Gem::Specification with the given +name+, +version+ and +platform+. +source+ is ignored. | def load_spec(name, version, platform, source) # :nodoc:
dep = Gem::Dependency.new name, version
found = @specs.find do |spec|
dep.matches_spec? spec and spec.platform == platform
end
tuple = Gem::NameTuple.new found.name, found.version, found.platform
found.source.fetch_spec tuple
end | [
"def load_spec (name, version, platform, source)\n version = Gem::Version.new(version) if !version.is_a?(Gem::Version)\n @specs.fetch(name, []).detect{|s| s.name == name && s.version == version}\n end",
"def load_spec(name, version, platform, source) # :nodoc:\n @specs.fetch name\n end",
... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Adds a specification to the set with the given +name+ which has been unpacked into the given +directory+. | def add_vendor_gem(name, directory) # :nodoc:
gemspec = File.join directory, "#{name}.gemspec"
spec = Gem::Specification.load gemspec
raise Gem::GemNotFoundException,
"unable to find #{gemspec} for gem #{name}" unless spec
spec.full_gem_path = File.expand_path directory
@specs[spec.nam... | [
"def add_spec(gem_spec, name = gem_spec.full_name)\n # No idea why, but the Indexer wants to insert them using original_name\n # instead of full_name. So we make it an optional arg.\n @gems[name] = gem_spec\n end",
"def add_spec(gem_spec, name = gem_spec.full_name)\n # No idea why, but the Indexer ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns an Array of VendorSpecification objects matching the DependencyRequest +req+. | def find_all(req)
@specs.values.select do |spec|
req.match? spec
end.map do |spec|
source = Gem::Source::Vendor.new @directories[spec]
Gem::Resolver::VendorSpecification.new self, spec, source
end
end | [
"def find_all(req)\n @specs.values.flatten.select do |spec|\n req.match?(spec)\n end.map do |spec|\n source = Gem::Source::Vendor.new(@directories[spec])\n Gem::Resolver::VendorSpecification.new(self, spec, source)\n end\n end",
"def find_all(req)\n res ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Loads a spec with the given +name+. +version+, +platform+ and +source+ are ignored. | def load_spec(name, version, platform, source) # :nodoc:
@specs.fetch name
end | [
"def load_spec (name, version, platform, source)\n version = Gem::Version.new(version) if !version.is_a?(Gem::Version)\n @specs.fetch(name, []).detect{|s| s.name == name && s.version == version}\n end",
"def load_spec(name, version, platform, source) # :nodoc:\n dep = Gem::Dependency.new nam... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Fetches development dependencies if the source does not provide them by default (see APISpecification). | def fetch_development_dependencies # :nodoc:
end | [
"def development_dependencies\n dependencies.select {|d| d.type == :development }\n end",
"def fetch_external_sources\n return unless allow_pre_downloads?\n\n verify_no_pods_with_different_sources!\n unless dependencies_to_fetch.empty?\n UI.section 'Fetching external sources' do\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Installs this specification using the Gem::Installer +options+. The install method yields a Gem::Installer instance, which indicates the gem will be installed, or +nil+, which indicates the gem is already installed. After installation spec is updated to point to the justinstalled specification. | def install(options = {})
require_relative '../installer'
gem = download options
installer = Gem::Installer.at gem, options
yield installer if block_given?
@spec = installer.install
end | [
"def install options\n destination = options[:install_dir] || Gem.dir\n\n if File.exist? File.join(destination, 'specifications', spec.spec_name) then\n yield nil\n return\n end\n\n super\n end",
"def install!\n install_dependencies!\n \n if !Config.force? && File.exist... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns true if this specification is installable on this platform. | def installable_platform?
Gem::Platform.match_spec? spec
end | [
"def installable?(config = {})\n @install_blk && enabled?(config) && present? && compatible?\n end",
"def should_be_installed?\n needs_install? && installation_possible?\n end",
"def installable?\n uninstallable_reasons.empty?\n end",
"def check_install?\n @default_options[ :check_ins... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
The dependencies of the gem for this specification | def dependencies
spec.dependencies
end | [
"def dependencies\n Gem.loaded_specs.collect do |name, loaded_gem|\n Datadog::Core::Telemetry::V1::Dependency.new(\n # `hash` should be used when `version` is not available\n name: name, version: loaded_gem.version.to_s, hash: nil\n )\n end\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
The required_ruby_version constraint for this specification | def required_ruby_version
spec.required_ruby_version
end | [
"def required_ruby_version\n spec.required_ruby_version || Gem::Requirement.default\n end",
"def version_constraint(gem_name); end",
"def required_version\n normalize_version(@required_version ||= nil)\n end",
"def required_version; end",
"def require_ruby_version *versions\n spec_extras[... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
The required_rubygems_version constraint for this specification | def required_rubygems_version
spec.required_rubygems_version
end | [
"def required_rubygems_version\n spec.required_rubygems_version || Gem::Requirement.default\n end",
"def version_constraint(gem_name); end",
"def required_ruby_version\n spec.required_ruby_version || Gem::Requirement.default\n end",
"def required_version\n normalize_version(@required_version ||... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
The name and version of the specification. Unlike Gem::Specificationfull_name, the platform is not included. | def full_name
"#{spec.name}-#{spec.version}"
end | [
"def full_name\n if platform == Gem::Platform::RUBY or platform.nil? then\n \"#{name}-#{version}\".untaint\n else\n \"#{name}-#{version}-#{platform}\".untaint\n end\n end",
"def full_name\n if platform == Gem::Platform::RUBY || platform.nil?\n \"#{@name}-#{@version}\"\n else\n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates an APISpecification for the given +set+ from the rubygems.org +api_data+. See for the format of the +api_data+. | def initialize(set, api_data)
super()
@set = set
@name = api_data[:name]
@version = Gem::Version.new(api_data[:number]).freeze
@platform = Gem::Platform.new(api_data[:platform]).freeze
@original_platform = api_data[:platform].freeze
@dependencies = api_data[:dependencies].map do |name, ver|... | [
"def api_get(set_URL)\n uri = URI.parse(set_URL)\n response = Net::HTTP.get_response(uri)\n end",
"def create_ip_set_with_http_info(ip_set, opts = {})\n if @api_client.config.debugging\n @api_client.config.logger.debug \"Calling API: GroupingObjectsApi.create_ip_set ...\"\n end\n # ve... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
The required_ruby_version constraint for this specification A fallback is included because when generated, some marshalled specs have it set to +nil+. | def required_ruby_version
spec.required_ruby_version || Gem::Requirement.default
end | [
"def required_ruby_version\n spec.required_ruby_version\n end",
"def require_ruby_version *versions\n spec_extras[:required_ruby_version] = versions\n end",
"def required_version\n normalize_version(@required_version ||= nil)\n end",
"def required_version; end",
"def required_rubygems_ve... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
The required_rubygems_version constraint for this specification A fallback is included because the original version of the specification API didn't include that field, so some marshalled specs in the index have it set to +nil+. | def required_rubygems_version
spec.required_rubygems_version || Gem::Requirement.default
end | [
"def required_rubygems_version\n spec.required_rubygems_version\n end",
"def required_version\n normalize_version(@required_version ||= nil)\n end",
"def version_constraint(gem_name); end",
"def required_ruby_version\n spec.required_ruby_version || Gem::Requirement.default\n end",
"def r... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Fetches a Gem::Specification for this IndexSpecification from the source. | def spec # :nodoc:
@spec ||=
begin
tuple = Gem::NameTuple.new @name, @version, @platform
@source.fetch_spec tuple
end
end | [
"def specification\n Gem::Specification.find_by_name(name, requirement)\n rescue Gem::LoadError\n nil\n end",
"def load_spec(name, version, platform, source) # :nodoc:\n dep = Gem::Dependency.new name, version\n\n found = @specs.find do |spec|\n dep.matches_spec? spec and spec.platform ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
This is a null install as this specification is already installed. +options+ are ignored. | def install(options = {})
yield nil
end | [
"def install options\n destination = options[:install_dir] || Gem.dir\n\n if File.exist? File.join(destination, 'specifications', spec.spec_name) then\n yield nil\n return\n end\n\n super\n end",
"def gem_install_options\n @gem_install_options ||= ['no_ri', 'no_rdoc']\n \"--\"... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
This is a null install as this gem was unpacked into a directory. +options+ are ignored. | def install(options = {})
yield nil
end | [
"def install options\n destination = options[:install_dir] || Gem.dir\n\n if File.exist? File.join(destination, 'specifications', spec.spec_name) then\n yield nil\n return\n end\n\n super\n end",
"def gem_install_options\n @gem_install_options ||= ['no_ri', 'no_rdoc']\n \"--\"... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates an ActivationRequest for the given +dep+ and the last +possible+ specification. Returns the Specification and the ActivationRequest | def activation_request(dep, possible) # :nodoc:
spec = possible.pop
explain :activate, [spec.full_name, possible.size]
explain :possible, possible
activation_request =
Gem::Resolver::ActivationRequest.new spec, dep, possible
return spec, activation_request
end | [
"def activation_request dep, possible # :nodoc:\n spec = possible.pop\n\n explain :activate, [spec.full_name, possible.size]\n\n activation_request =\n Gem::Resolver::ActivationRequest.new spec, dep, possible\n\n return spec, activation_request\n end",
"def resolve_for(needed, specs)\n unti... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Extracts the specifications that may be able to fulfill +dependency+ and returns those that match the local platform and all those that match. | def find_possible(dependency) # :nodoc:
all = @set.find_all dependency
if (skip_dep_gems = skip_gems[dependency.name]) && !skip_dep_gems.empty?
matching = all.select do |api_spec|
skip_dep_gems.any? {|s| api_spec.version == s.version }
end
all = matching unless matching.empty?
en... | [
"def spec_for_dependency(dependency, matching_platform=true)\n tuples, errors = search_for_dependency(dependency, matching_platform)\n\n specs = tuples.map do |tup, source|\n [fetch_spec(tup, URI.parse(source)), source]\n end\n\n return [specs, errors]\n end",
"def search_for_dependency(dependen... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns the gems in +specs+ that match the local platform. | def select_local_platforms(specs) # :nodoc:
specs.select do |spec|
Gem::Platform.installable? spec
end
end | [
"def select_local_platforms specs # :nodoc:\n specs.select do |spec|\n Gem::Platform.match spec.platform\n end\n end",
"def select_local_platforms specs # :nodoc:\n specs.select do |spec|\n Gem::Platform.installable? spec\n end\n end",
"def local_gemfile_lock_specs\n gemfile_lock_sp... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
== Args +uris+:: an Array of Strings == Description Attempts to parse and merge a set of URIs. | def join(*uris)
uris[0] = convert_to_uri(uris[0])
uris.inject :merge
end | [
"def join(*uris); end",
"def resolve_dependencies(uris)\n uris.map { |uri| resolve_dependency(uri) }\n end",
"def make_uris\n coerced = urls.map do |url|\n begin\n URI(url)\n rescue\n nil\n end\n end\n\n coerced.compact\n end",
"def update(u... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns Regexp that is default +self.regexp[:ABS_URI_REF]+, unless +schemes+ is provided. Then it is a Regexp.union with +self.pattern[:X_ABS_URI]+. | def make_regexp(schemes = nil)
unless schemes
@regexp[:ABS_URI_REF]
else
/(?=#{Regexp.union(*schemes)}:)#{@pattern[:X_ABS_URI]}/x
end
end | [
"def uri_regexp\n @uri_regexp ||= /\\A#{URI::Parser.new.make_regexp(protocols)}\\z/\n end",
"def uri(re)\n UriPathMatcher.new(re)\n end",
"def path_regex\n return const_get('URI_Regex')\n end",
"def base_uri_with_scheme\n self.uri_with_scheme.to_s[/^https?:\\/\\/[^\\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
:callseq: escape( str ) escape( str, unsafe ) == Args +str+:: String to make safe +unsafe+:: Regexp to apply. Defaults to +self.regexp[:UNSAFE]+ == Description Constructs a safe String from +str+, removing unsafe characters, replacing them with codes. | def escape(str, unsafe = @regexp[:UNSAFE])
unless unsafe.kind_of?(Regexp)
# perhaps unsafe is String object
unsafe = Regexp.new("[#{Regexp.quote(unsafe)}]", false)
end
str.gsub(unsafe) do
us = $&
tmp = ''
us.each_byte do |uc|
tmp << sprintf('%%%02X', u... | [
"def escape(str, unsafe = UNSAFE)\n # URI.escape is obsolete\"\n DEFAULT_PARSER.escape(str, unsafe)\n end",
"def escape( str )\n str.downcase!\n str.gsub!('::', '__')\n str.gsub!(/[^a-z0-9\\-_$\\(\\)\\+\\/]/, '')\n str.gsub!('/', '%2')\n str\n end",
"def safe(string)\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
:callseq: unescape( str ) unescape( str, escaped ) == Args +str+:: String to remove escapes from +escaped+:: Regexp to apply. Defaults to +self.regexp[:ESCAPED]+ == Description Removes escapes from +str+. | def unescape(str, escaped = @regexp[:ESCAPED])
enc = str.encoding
enc = Encoding::UTF_8 if enc == Encoding::US_ASCII
str.gsub(escaped) { [$&[1, 2]].pack('H2').force_encoding(enc) }
end | [
"def unescape(str); end",
"def unescape( str )\n str.gsub(/\\\\(.)/, '\\1')\n end",
"def unescape( value )\n return value unless @escape\n\n value = value.to_s\n value.gsub!(%r/\\\\[0nrt\\\\]/) { |char|\n case char\n when '\\0'; \"\\0\"\n when '\\n'; \"\\n\"\n when '\\r'... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
== Args +scheme+:: Protocol scheme, i.e. 'http','ftp','mailto' and so on. +userinfo+:: User name and password, i.e. 'sdmitry:bla'. +host+:: Server host name. +port+:: Server port. +registry+:: Registry of naming authorities. +path+:: Path on server. +opaque+:: Opaque part. +query+:: Query data. +fragment+:: Part of the... | def initialize(scheme,
userinfo, host, port, registry,
path, opaque,
query,
fragment,
parser = DEFAULT_PARSER,
arg_check = false)
@scheme = nil
@user = nil
@password = nil
@host = ni... | [
"def initialize(scheme, \n userinfo, host, port, registry, \n path, opaque, \n query, \n fragment,\n\t\t parser = DEFAULT_PARSER,\n arg_check = false)\n @scheme = nil\n @user = nil\n @password = nil\n @ho... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns the parser to be used. Unless a URI::Parser is defined, DEFAULT_PARSER is used. | def parser
if !defined?(@parser) || !@parser
DEFAULT_PARSER
else
@parser || DEFAULT_PARSER
end
end | [
"def default_parser\n return :ox if defined?(::Ox)\n return :libxml if defined?(::LibXML)\n return :nokogiri if defined?(::Nokogiri)\n\n REQUIREMENT_MAP.each do |library, parser|\n begin\n require library\n return parser\n rescue LoadError\n next\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Checks the scheme +v+ component against the URI::Parser Regexp for :SCHEME. | def check_scheme(v)
if v && parser.regexp[:SCHEME] !~ v
raise InvalidComponentError,
"bad component(expected scheme component): #{v}"
end
return true
end | [
"def set_scheme(v)\n @scheme = v&.downcase\n end",
"def check_url_scheme\n myurl = URI.parse self.uurl\n if (self.uurl.match(/(^http:)|(^https:)|(^ftp:)/) and myurl.scheme.present? and myurl.host.present?)\n # I'm happy.\n else\n self.uurl = \"http://#{self.uurl}\"\n end\n end",
"... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Protected setter for the scheme component +v+. See also URI::Generic.scheme=. | def set_scheme(v)
@scheme = v&.downcase
end | [
"def scheme=(v)\n check_scheme(v)\n set_scheme(v)\n v\n end",
"def scheme=(scheme)\n each { |uri| uri.scheme = scheme }\n end",
"def scheme_set(scheme)\n rebuild_uri :scheme => scheme\n end",
"def scheme(value = nil)\n if value\n @scheme = value\n else\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
== Args +v+:: String == Description Public setter for the scheme component +v+ (with validation). See also URI::Generic.check_scheme. == Usage require 'uri' uri = URI.parse(" uri.scheme = "https" uri.to_s => " | def scheme=(v)
check_scheme(v)
set_scheme(v)
v
end | [
"def set_scheme(v)\n @scheme = v&.downcase\n end",
"def scheme(value = nil)\n if value\n @scheme = value\n else\n @scheme ||= 'http'\n end\n end",
"def check_scheme(v)\n if v && parser.regexp[:SCHEME] !~ v\n raise InvalidComponentError,\n \"bad compon... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Checks the +user+ and +password+. If +password+ is not provided, then +user+ is split, using URI::Generic.split_userinfo, to pull +user+ and +password. See also URI::Generic.check_user, URI::Generic.check_password. | def check_userinfo(user, password = nil)
if !password
user, password = split_userinfo(user)
end
check_user(user)
check_password(password, user)
return true
end | [
"def check_user_credentials(username,password)\n user = get_user_by_username(username)\n return nil if !user\n hp = hash_password(password,user['salt'])\n (user['password'] == hp) ? [user['auth'],user['apisecret']] : nil\nend",
"def valid_user?\n params['username'] && params['password']\n end"... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Checks the user +v+ component for RFC2396 compliance and against the URI::Parser Regexp for :USERINFO. Can not have a registry or opaque component defined, with a user component defined. | def check_user(v)
if @opaque
raise InvalidURIError,
"can not set user with opaque"
end
return v unless v
if parser.regexp[:USERINFO] !~ v
raise InvalidComponentError,
"bad component(expected userinfo component or user component): #{v}"
end
retur... | [
"def check_password(v, user = @user)\n if @opaque\n raise InvalidURIError,\n \"can not set password with opaque\"\n end\n return v unless v\n\n if !user\n raise InvalidURIError,\n \"password component depends user component\"\n end\n\n if parser.regexp[:... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Checks the password +v+ component for RFC2396 compliance and against the URI::Parser Regexp for :USERINFO. Can not have a registry or opaque component defined, with a user component defined. | def check_password(v, user = @user)
if @opaque
raise InvalidURIError,
"can not set password with opaque"
end
return v unless v
if !user
raise InvalidURIError,
"password component depends user component"
end
if parser.regexp[:USERINFO] !~ v
... | [
"def check_user(v)\n if @opaque\n raise InvalidURIError,\n \"can not set user with opaque\"\n end\n\n return v unless v\n\n if parser.regexp[:USERINFO] !~ v\n raise InvalidComponentError,\n \"bad component(expected userinfo component or user component): #{v}\"\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Sets userinfo, argument is string like 'name:pass'. | def userinfo=(userinfo)
if userinfo.nil?
return nil
end
check_userinfo(*userinfo)
set_userinfo(*userinfo)
# returns userinfo
end | [
"def set_userinfo(username, password)\n if (username == nil || password == nil)\n raise ArgumentError.new(\"Unable to set userinfo with empty values\")\n end\n @userinfo ||=[username, password].join(\":\")\n end",
"def set_userinfo(user, password = nil)\n unless password\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Protected setter for the +user+ component, and +password+ if available (with validation). See also URI::Generic.userinfo=. | def set_userinfo(user, password = nil)
unless password
user, password = split_userinfo(user)
end
@user = user
@password = password if password
[@user, @password]
end | [
"def set_auth(user, password)\n @user = user\n @password = password\n end",
"def set_user_and_password(user, password)\n @_username = user\n @_password = password\n end",
"def set_user(v)\n set_userinfo(v, @password)\n v\n end",
"def set_userinfo(username, password)\n i... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Protected setter for the user component +v+. See also URI::Generic.user=. | def set_user(v)
set_userinfo(v, @password)
v
end | [
"def user=(value)\n @user = value\n end",
"def user=(value)\n @user = value\n end",
"def set_User(value)\n set_input(\"User\", value)\n end",
"def user=(value)\n conf['api']['user'] = value\n end",
"def set_version_user(version, user)\n unless @versions... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Protected setter for the password component +v+. See also URI::Generic.password=. | def set_password(v)
@password = v
# returns v
end | [
"def password=(value)\n @password = value\n end",
"def password=(value)\n @password = value\n end",
"def password=(passwd)\n @password = passwd\n end",
"def password=(val)\n if val.present?\n self.password_salt = BCrypt::Engine.generate_salt unless password_sa... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns the userinfo +ui+ as [user, password] if properly formatted as 'user:password'. | def split_userinfo(ui)
return nil, nil unless ui
user, password = ui.split(':', 2)
return user, password
end | [
"def userinfo\n if @user.nil?\n nil\n elsif @password.nil?\n @user\n else\n @user + ':' + @password\n end\n end",
"def normalized_userinfo\n normalized_user + (password ? \":#{normalized_password}\" : \"\") if userinfo\n end",
"def build_userinfo\n @passw... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Escapes 'user:password' +v+ based on RFC 1738 section 3.1. | def escape_userpass(v)
parser.escape(v, /[@:\/]/o) # RFC 1738 section 3.1 #/
end | [
"def encode_credentials(username, password)\n \"\\0#{username}\\0#{password}\"\n end",
"def encode_credentials(username, password)\n \"\"\n end",
"def encode_auth(username, password)\n base64(\"\\0#{username}\\0#{password}\")\n end",
"def check_password(v, user = @user)\n if @opaque\n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns the userinfo, either as 'user' or 'user:password'. | def userinfo
if @user.nil?
nil
elsif @password.nil?
@user
else
@user + ':' + @password
end
end | [
"def normalized_userinfo\n normalized_user + (password ? \":#{normalized_password}\" : \"\") if userinfo\n end",
"def user_info\n @user_info ||= raw_info\n end",
"def user_info\n @user_info ||= raw_info.nil? ? {} : raw_info\n end",
"def user_info\n @user_info ||= raw_inf... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Checks the host +v+ component for RFC2396 compliance and against the URI::Parser Regexp for :HOST. Can not have a registry or opaque component defined, with a host component defined. | def check_host(v)
return v unless v
if @opaque
raise InvalidURIError,
"can not set host with registry or opaque"
elsif parser.regexp[:HOST] !~ v
raise InvalidComponentError,
"bad component(expected host component): #{v}"
end
return true
end | [
"def validate_host_header(value)\n # allow only valid hostnames\n value.match?(host_regex) && !value.match?(/_/)\n end",
"def host_address_must_be_valid\n if host.kind_of? String\n begin\n resolved_host = ::Rex::Socket.getaddress(host, true)\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Protected setter for the host component +v+. See also URI::Generic.host=. | def set_host(v)
@host = v
end | [
"def host=(value)\n @host = value\n end",
"def host=(new_host)\n @host = new_host\n\n # Reset dependant values\n @authority = nil\n\n # Ensure we haven't created an invalid URI\n validate()\n end",
"def host=(new_host)\n unless new_host =~ /^http(s)?:\\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Checks the port +v+ component for RFC2396 compliance and against the URI::Parser Regexp for :PORT. Can not have a registry or opaque component defined, with a port component defined. | def check_port(v)
return v unless v
if @opaque
raise InvalidURIError,
"can not set port with registry or opaque"
elsif !v.kind_of?(Integer) && parser.regexp[:PORT] !~ v
raise InvalidComponentError,
"bad component(expected port component): #{v.inspect}"
end
... | [
"def valid_port?(value)\n\t\treturn false if /\\A[0-9]{1,6}\\Z/.match(value).nil?\n\t\ttrue\n\tend",
"def valid_port?(port)\n return false unless port =~ /^[0-9]+$/\n\n (0..65_535).include?(port.to_i)\n end",
"def visit_port?(port)\n @port_rules.accept?(port)\n end",
"def CheckValidPort(port)\n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Protected setter for the port component +v+. See also URI::Generic.port=. | def set_port(v)
v = v.empty? ? nil : v.to_i unless !v || v.kind_of?(Integer)
@port = v
end | [
"def port=(v)\n check_port(v)\n set_port(v)\n port\n end",
"def port=(value)\n @port = value\n end",
"def port=(port)\n each { |uri| uri.port = port }\n end",
"def port(new_port)\n unless port_valid? new_port\n raise Urb::InvalidUrl 'Try to set a invalid value... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
== Args +v+:: String == Description Public setter for the port component +v+ (with validation). See also URI::Generic.check_port. == Usage require 'uri' uri = URI.parse(" uri.port = 8080 uri.to_s => " | def port=(v)
check_port(v)
set_port(v)
port
end | [
"def set_port(v)\n v = v.empty? ? nil : v.to_i unless !v || v.kind_of?(Integer)\n @port = v\n end",
"def port(new_port)\n unless port_valid? new_port\n raise Urb::InvalidUrl 'Try to set a invalid value to port'\n end\n\n @port = new_port\n\n self\n end",
"def check_por... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Checks the path +v+ component for RFC2396 compliance and against the URI::Parser Regexp for :ABS_PATH and :REL_PATH. Can not have a opaque component defined, with a path component defined. | def check_path(v)
# raise if both hier and opaque are not nil, because:
# absoluteURI = scheme ":" ( hier_part | opaque_part )
# hier_part = ( net_path | abs_path ) [ "?" query ]
if v && @opaque
raise InvalidURIError,
"path conflicts with opaque"
end
# If sch... | [
"def check candidate_path\n # Convert dynamic segments into regexp captures\n matchable_path = candidate_path.gsub(/:\\w+/, '([^/]+)')\n\n # Don't match a partial segment. For example,\n # don't match /widget for /widgets.\n path.match(Regexp.new(\"^/?#{matchable_path}(?:/|$)\"))\n end",... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.