_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3
values | text stringlengths 66 10.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q10400 | ActiveStorage.Attached::Many.attach | train | def attach(*attachables)
if record.persisted? && !record.changed?
record.update(name => blobs + attachables.flatten)
else
record.public_send("#{name}=", blobs + attachables.flatten)
end
end | ruby | {
"resource": ""
} |
q10401 | ActionDispatch.Response.charset= | train | def charset=(charset)
content_type = parsed_content_type_header.mime_type
if false == charset
set_content_type content_type, nil
else
set_content_type content_type, charset || self.class.default_charset
end
end | ruby | {
"resource": ""
} |
q10402 | DateAndTime.Calculations.days_to_week_start | train | def days_to_week_start(start_day = Date.beginning_of_week)
start_day_number = DAYS_INTO_WEEK.fetch(start_day)
(wday - start_day_number) % 7
end | ruby | {
"resource": ""
} |
q10403 | GRPC.ActiveCall.remote_send | train | def remote_send(req, marshalled = false)
send_initial_metadata
GRPC.logger.debug("sending #{req}, marshalled? #{marshalled}")
payload = marshalled ? req : @marshal.call(req)
@call.run_batch(SEND_MESSAGE => payload)
end | ruby | {
"resource": ""
} |
q10404 | GRPC.ActiveCall.send_status | train | def send_status(code = OK, details = '', assert_finished = false,
metadata: {})
send_initial_metadata
ops = {
SEND_STATUS_FROM_SERVER => Struct::Status.new(code, details, metadata)
}
ops[RECV_CLOSE_ON_SERVER] = nil if assert_finished
@call.run_batch(ops)
s... | ruby | {
"resource": ""
} |
q10405 | GRPC.ActiveCall.remote_read | train | def remote_read
ops = { RECV_MESSAGE => nil }
ops[RECV_INITIAL_METADATA] = nil unless @metadata_received
batch_result = @call.run_batch(ops)
unless @metadata_received
@call.metadata = batch_result.metadata
@metadata_received = true
end
get_message_from_batch_result(ba... | ruby | {
"resource": ""
} |
q10406 | GRPC.ActiveCall.each_remote_read | train | def each_remote_read
return enum_for(:each_remote_read) unless block_given?
begin
loop do
resp = remote_read
break if resp.nil? # the last response was received
yield resp
end
ensure
set_input_stream_done
end
end | ruby | {
"resource": ""
} |
q10407 | GRPC.ActiveCall.each_remote_read_then_finish | train | def each_remote_read_then_finish
return enum_for(:each_remote_read_then_finish) unless block_given?
loop do
resp =
begin
remote_read
rescue GRPC::Core::CallError => e
GRPC.logger.warn("In each_remote_read_then_finish: #{e}")
nil
end
... | ruby | {
"resource": ""
} |
q10408 | GRPC.ActiveCall.request_response | train | def request_response(req, metadata: {})
raise_error_if_already_executed
ops = {
SEND_MESSAGE => @marshal.call(req),
SEND_CLOSE_FROM_CLIENT => nil,
RECV_INITIAL_METADATA => nil,
RECV_MESSAGE => nil,
RECV_STATUS_ON_CLIENT => nil
}
@send_initial_md_mutex.sync... | ruby | {
"resource": ""
} |
q10409 | GRPC.ActiveCall.client_streamer | train | def client_streamer(requests, metadata: {})
raise_error_if_already_executed
begin
send_initial_metadata(metadata)
requests.each { |r| @call.run_batch(SEND_MESSAGE => @marshal.call(r)) }
rescue GRPC::Core::CallError => e
receive_and_check_status # check for Cancelled
rai... | ruby | {
"resource": ""
} |
q10410 | GRPC.ActiveCall.server_streamer | train | def server_streamer(req, metadata: {})
raise_error_if_already_executed
ops = {
SEND_MESSAGE => @marshal.call(req),
SEND_CLOSE_FROM_CLIENT => nil
}
@send_initial_md_mutex.synchronize do
# Metadata might have already been sent if this is an operation view
unless @me... | ruby | {
"resource": ""
} |
q10411 | GRPC.ActiveCall.bidi_streamer | train | def bidi_streamer(requests, metadata: {}, &blk)
raise_error_if_already_executed
# Metadata might have already been sent if this is an operation view
begin
send_initial_metadata(metadata)
rescue GRPC::Core::CallError => e
batch_result = @call.run_batch(RECV_STATUS_ON_CLIENT => nil... | ruby | {
"resource": ""
} |
q10412 | GRPC.ActiveCall.run_server_bidi | train | def run_server_bidi(mth, interception_ctx)
view = multi_req_view
bidi_call = BidiCall.new(
@call,
@marshal,
@unmarshal,
metadata_received: @metadata_received,
req_view: view
)
requests = bidi_call.read_next_loop(proc { set_input_stream_done }, false)
... | ruby | {
"resource": ""
} |
q10413 | GRPC.BidiCall.run_on_client | train | def run_on_client(requests,
set_input_stream_done,
set_output_stream_done,
&blk)
@enq_th = Thread.new do
write_loop(requests, set_output_stream_done: set_output_stream_done)
end
read_loop(set_input_stream_done, &blk)
end | ruby | {
"resource": ""
} |
q10414 | GRPC.BidiCall.run_on_server | train | def run_on_server(gen_each_reply, requests)
replies = nil
# Pass in the optional call object parameter if possible
if gen_each_reply.arity == 1
replies = gen_each_reply.call(requests)
elsif gen_each_reply.arity == 2
replies = gen_each_reply.call(requests, @req_view)
else
... | ruby | {
"resource": ""
} |
q10415 | GRPC.BidiCall.read_using_run_batch | train | def read_using_run_batch
ops = { RECV_MESSAGE => nil }
ops[RECV_INITIAL_METADATA] = nil unless @metadata_received
begin
batch_result = @call.run_batch(ops)
unless @metadata_received
@call.metadata = batch_result.metadata
@metadata_received = true
end
... | ruby | {
"resource": ""
} |
q10416 | GRPC.BidiCall.write_loop | train | def write_loop(requests, is_client: true, set_output_stream_done: nil)
GRPC.logger.debug('bidi-write-loop: starting')
count = 0
requests.each do |req|
GRPC.logger.debug("bidi-write-loop: #{count}")
count += 1
payload = @marshal.call(req)
# Fails if status already receiv... | ruby | {
"resource": ""
} |
q10417 | GRPC.BidiCall.read_loop | train | def read_loop(set_input_stream_done, is_client: true)
return enum_for(:read_loop,
set_input_stream_done,
is_client: is_client) unless block_given?
GRPC.logger.debug('bidi-read-loop: starting')
begin
count = 0
# queue the initial read before b... | ruby | {
"resource": ""
} |
q10418 | GRPC.Pool.schedule | train | def schedule(*args, &blk)
return if blk.nil?
@stop_mutex.synchronize do
if @stopped
GRPC.logger.warn('did not schedule job, already stopped')
return
end
GRPC.logger.info('schedule another job')
fail 'No worker threads available' if @ready_workers.empty?
... | ruby | {
"resource": ""
} |
q10419 | GRPC.Pool.start | train | def start
@stop_mutex.synchronize do
fail 'already stopped' if @stopped
end
until @workers.size == @size.to_i
new_worker_queue = Queue.new
@ready_workers << new_worker_queue
next_thread = Thread.new(new_worker_queue) do |jobs|
catch(:exit) do # allows { throw... | ruby | {
"resource": ""
} |
q10420 | GRPC.Pool.stop | train | def stop
GRPC.logger.info('stopping, will wait for all the workers to exit')
@stop_mutex.synchronize do # wait @keep_alive seconds for workers to stop
@stopped = true
loop do
break unless ready_for_work?
worker_queue = @ready_workers.pop
worker_queue << [proc {... | ruby | {
"resource": ""
} |
q10421 | GRPC.Pool.forcibly_stop_workers | train | def forcibly_stop_workers
return unless @workers.size > 0
GRPC.logger.info("forcibly terminating #{@workers.size} worker(s)")
@workers.each do |t|
next unless t.alive?
begin
t.exit
rescue StandardError => e
GRPC.logger.warn('error while terminating a worker'... | ruby | {
"resource": ""
} |
q10422 | GRPC.RpcServer.stop | train | def stop
# if called via run_till_terminated_or_interrupted,
# signal stop_server_thread and dont do anything
if @stop_server.nil? == false && @stop_server == false
@stop_server = true
@stop_server_cv.broadcast
return
end
@run_mutex.synchronize do
fail 'Ca... | ruby | {
"resource": ""
} |
q10423 | GRPC.RpcServer.transition_running_state | train | def transition_running_state(target_state)
state_transitions = {
not_started: :running,
running: :stopping,
stopping: :stopped
}
if state_transitions[@running_state] == target_state
@running_state = target_state
else
fail "Bad server state transition: #{@r... | ruby | {
"resource": ""
} |
q10424 | GRPC.RpcServer.handle | train | def handle(service)
@run_mutex.synchronize do
unless @running_state == :not_started
fail 'cannot add services if the server has been started'
end
cls = service.is_a?(Class) ? service : service.class
assert_valid_service_class(cls)
add_rpc_descs_for(service)
... | ruby | {
"resource": ""
} |
q10425 | GRPC.RpcServer.run | train | def run
@run_mutex.synchronize do
fail 'cannot run without registering services' if rpc_descs.size.zero?
@pool.start
@server.start
transition_running_state(:running)
@run_cond.broadcast
end
loop_handle_server_calls
end | ruby | {
"resource": ""
} |
q10426 | GRPC.RpcServer.run_till_terminated_or_interrupted | train | def run_till_terminated_or_interrupted(signals, wait_interval = 60)
@stop_server = false
@stop_server_mu = Mutex.new
@stop_server_cv = ConditionVariable.new
@stop_server_thread = Thread.new do
loop do
break if @stop_server
@stop_server_mu.synchronize do
@... | ruby | {
"resource": ""
} |
q10427 | GRPC.RpcServer.available? | train | def available?(an_rpc)
return an_rpc if @pool.ready_for_work?
GRPC.logger.warn('no free worker threads currently')
noop = proc { |x| x }
# Create a new active call that knows that metadata hasn't been
# sent yet
c = ActiveCall.new(an_rpc.call, noop, noop, an_rpc.deadline,
... | ruby | {
"resource": ""
} |
q10428 | GRPC.RpcServer.implemented? | train | def implemented?(an_rpc)
mth = an_rpc.method.to_sym
return an_rpc if rpc_descs.key?(mth)
GRPC.logger.warn("UNIMPLEMENTED: #{an_rpc}")
noop = proc { |x| x }
# Create a new active call that knows that
# metadata hasn't been sent yet
c = ActiveCall.new(an_rpc.call, noop, noop, an... | ruby | {
"resource": ""
} |
q10429 | GRPC.RpcServer.loop_handle_server_calls | train | def loop_handle_server_calls
fail 'not started' if running_state == :not_started
while running_state == :running
begin
an_rpc = @server.request_call
break if (!an_rpc.nil?) && an_rpc.call.nil?
active_call = new_active_server_call(an_rpc)
unless active_call.nil... | ruby | {
"resource": ""
} |
q10430 | GRPC.ClientStub.request_response | train | def request_response(method, req, marshal, unmarshal,
deadline: nil,
return_op: false,
parent: nil,
credentials: nil,
metadata: {})
c = new_active_call(method, marshal, unmarshal,
... | ruby | {
"resource": ""
} |
q10431 | GRPC.ClientStub.new_active_call | train | def new_active_call(method, marshal, unmarshal,
deadline: nil,
parent: nil,
credentials: nil)
deadline = from_relative_time(@timeout) if deadline.nil?
# Provide each new client call with its own completion queue
call = @ch.create_... | ruby | {
"resource": ""
} |
q10432 | Jekyll.LiquidExtensions.lookup_variable | train | def lookup_variable(context, variable)
lookup = context
variable.split(".").each do |value|
lookup = lookup[value]
end
lookup || variable
end | ruby | {
"resource": ""
} |
q10433 | Jekyll.Renderer.converters | train | def converters
@converters ||= site.converters.select { |c| c.matches(document.extname) }.sort
end | ruby | {
"resource": ""
} |
q10434 | Jekyll.Renderer.run | train | def run
Jekyll.logger.debug "Rendering:", document.relative_path
assign_pages!
assign_current_document!
assign_highlighter_options!
assign_layout_data!
Jekyll.logger.debug "Pre-Render Hooks:", document.relative_path
document.trigger_hooks(:pre_render, payload)
render_d... | ruby | {
"resource": ""
} |
q10435 | Jekyll.Renderer.render_document | train | def render_document
info = {
:registers => { :site => site, :page => payload["page"] },
:strict_filters => liquid_options["strict_filters"],
:strict_variables => liquid_options["strict_variables"],
}
output = document.content
if document.render_with_liquid?
... | ruby | {
"resource": ""
} |
q10436 | Jekyll.Renderer.place_in_layouts | train | def place_in_layouts(content, payload, info)
output = content.dup
layout = layouts[document.data["layout"].to_s]
validate_layout(layout)
used = Set.new([layout])
# Reset the payload layout data to ensure it starts fresh for each page.
payload["layout"] = nil
while layout
... | ruby | {
"resource": ""
} |
q10437 | Jekyll.Renderer.validate_layout | train | def validate_layout(layout)
if invalid_layout?(layout)
Jekyll.logger.warn(
"Build Warning:",
"Layout '#{document.data["layout"]}' requested "\
"in #{document.relative_path} does not exist."
)
elsif !layout.nil?
layout_source = layout.path.start_with?(sit... | ruby | {
"resource": ""
} |
q10438 | Jekyll.Renderer.render_layout | train | def render_layout(output, layout, info)
payload["content"] = output
payload["layout"] = Utils.deep_merge_hashes(layout.data, payload["layout"] || {})
render_liquid(
layout.content,
payload,
info,
layout.relative_path
)
end | ruby | {
"resource": ""
} |
q10439 | Jekyll.Renderer.assign_pages! | train | def assign_pages!
payload["page"] = document.to_liquid
payload["paginator"] = (document.pager.to_liquid if document.respond_to?(:pager))
end | ruby | {
"resource": ""
} |
q10440 | Jekyll.Reader.read | train | def read
@site.layouts = LayoutReader.new(site).read
read_directories
read_included_excludes
sort_files!
@site.data = DataReader.new(site).read(site.config["data_dir"])
CollectionReader.new(site).read
ThemeAssetsReader.new(site).read
end | ruby | {
"resource": ""
} |
q10441 | Jekyll.Reader.retrieve_dirs | train | def retrieve_dirs(_base, dir, dot_dirs)
dot_dirs.each do |file|
dir_path = site.in_source_dir(dir, file)
rel_path = File.join(dir, file)
@site.reader.read_directories(rel_path) unless @site.dest.chomp("/") == dir_path
end
end | ruby | {
"resource": ""
} |
q10442 | Jekyll.Reader.get_entries | train | def get_entries(dir, subfolder)
base = site.in_source_dir(dir, subfolder)
return [] unless File.exist?(base)
entries = Dir.chdir(base) { filter_entries(Dir["**/*"], base) }
entries.delete_if { |e| File.directory?(site.in_source_dir(base, e)) }
end | ruby | {
"resource": ""
} |
q10443 | Jekyll.Site.write | train | def write
each_site_file do |item|
item.write(dest) if regenerator.regenerate?(item)
end
regenerator.write_metadata
Jekyll::Hooks.trigger :site, :post_write, self
end | ruby | {
"resource": ""
} |
q10444 | Jekyll.Site.post_attr_hash | train | def post_attr_hash(post_attr)
# Build a hash map based on the specified post attribute ( post attr =>
# array of posts ) then sort each array in reverse order.
@post_attr_hash[post_attr] ||= begin
hash = Hash.new { |h, key| h[key] = [] }
posts.docs.each do |p|
p.data[post_att... | ruby | {
"resource": ""
} |
q10445 | Jekyll.Site.find_converter_instance | train | def find_converter_instance(klass)
@find_converter_instance ||= {}
@find_converter_instance[klass] ||= begin
converters.find { |converter| converter.instance_of?(klass) } || \
raise("No Converters found for #{klass}")
end
end | ruby | {
"resource": ""
} |
q10446 | Jekyll.Site.instantiate_subclasses | train | def instantiate_subclasses(klass)
klass.descendants.select { |c| !safe || c.safe }.sort.map do |c|
c.new(config)
end
end | ruby | {
"resource": ""
} |
q10447 | Jekyll.Site.documents | train | def documents
@documents ||= collections.reduce(Set.new) do |docs, (_, collection)|
docs + collection.docs + collection.files
end.to_a
end | ruby | {
"resource": ""
} |
q10448 | Jekyll.Site.configure_cache | train | def configure_cache
Jekyll::Cache.cache_dir = in_source_dir(config["cache_dir"], "Jekyll/Cache")
Jekyll::Cache.disable_disk_cache! if safe
end | ruby | {
"resource": ""
} |
q10449 | Jekyll.FrontmatterDefaults.find | train | def find(path, type, setting)
value = nil
old_scope = nil
matching_sets(path, type).each do |set|
if set["values"].key?(setting) && has_precedence?(old_scope, set["scope"])
value = set["values"][setting]
old_scope = set["scope"]
end
end
value
end | ruby | {
"resource": ""
} |
q10450 | Jekyll.FrontmatterDefaults.all | train | def all(path, type)
defaults = {}
old_scope = nil
matching_sets(path, type).each do |set|
if has_precedence?(old_scope, set["scope"])
defaults = Utils.deep_merge_hashes(defaults, set["values"])
old_scope = set["scope"]
else
defaults = Utils.deep_merge_hash... | ruby | {
"resource": ""
} |
q10451 | Jekyll.FrontmatterDefaults.valid_sets | train | def valid_sets
sets = @site.config["defaults"]
return [] unless sets.is_a?(Array)
sets.map do |set|
if valid?(set)
ensure_time!(update_deprecated_types(set))
else
Jekyll.logger.warn "Defaults:", "An invalid front-matter default set was found:"
Jekyll.logg... | ruby | {
"resource": ""
} |
q10452 | Jekyll.Cache.[] | train | def [](key)
return @cache[key] if @cache.key?(key)
path = path_to(hash(key))
if disk_cache_enabled? && File.file?(path) && File.readable?(path)
@cache[key] = load(path)
else
raise
end
end | ruby | {
"resource": ""
} |
q10453 | Jekyll.Cache.[]= | train | def []=(key, value)
@cache[key] = value
return unless disk_cache_enabled?
path = path_to(hash(key))
value = new Hash(value) if value.is_a?(Hash) && !value.default.nil?
dump(path, value)
rescue TypeError
Jekyll.logger.debug "Cache:", "Cannot dump object #{key}"
end | ruby | {
"resource": ""
} |
q10454 | Jekyll.Cache.delete | train | def delete(key)
@cache.delete(key)
File.delete(path_to(hash(key))) if disk_cache_enabled?
end | ruby | {
"resource": ""
} |
q10455 | Jekyll.Cache.key? | train | def key?(key)
# First, check if item is already cached in memory
return true if @cache.key?(key)
# Otherwise, it might be cached on disk
# but we should not consider the disk cache if it is disabled
return false unless disk_cache_enabled?
path = path_to(hash(key))
File.file?(p... | ruby | {
"resource": ""
} |
q10456 | Jekyll.Cache.path_to | train | def path_to(hash = nil)
@base_dir ||= File.join(Jekyll::Cache.cache_dir, @name)
return @base_dir if hash.nil?
File.join(@base_dir, hash[0..1], hash[2..-1]).freeze
end | ruby | {
"resource": ""
} |
q10457 | Jekyll.Convertible.render_liquid | train | def render_liquid(content, payload, info, path)
_renderer.render_liquid(content, payload, info, path)
end | ruby | {
"resource": ""
} |
q10458 | Jekyll.Convertible.to_liquid | train | def to_liquid(attrs = nil)
further_data = Hash[(attrs || self.class::ATTRIBUTES_FOR_LIQUID).map do |attribute|
[attribute, send(attribute)]
end]
defaults = site.frontmatter_defaults.all(relative_path, type)
Utils.deep_merge_hashes defaults, Utils.deep_merge_hashes(data, further_data)
... | ruby | {
"resource": ""
} |
q10459 | Jekyll.Convertible.render_all_layouts | train | def render_all_layouts(layouts, payload, info)
_renderer.layouts = layouts
self.output = _renderer.place_in_layouts(output, payload, info)
ensure
@_renderer = nil # this will allow the modifications above to disappear
end | ruby | {
"resource": ""
} |
q10460 | Jekyll.Convertible.do_layout | train | def do_layout(payload, layouts)
self.output = _renderer.tap do |renderer|
renderer.layouts = layouts
renderer.payload = payload
end.run
Jekyll.logger.debug "Post-Render Hooks:", relative_path
Jekyll::Hooks.trigger hook_owner, :post_render, self
ensure
@_renderer = nil ... | ruby | {
"resource": ""
} |
q10461 | Jekyll.PluginManager.require_theme_deps | train | def require_theme_deps
return false unless site.theme.runtime_dependencies
site.theme.runtime_dependencies.each do |dep|
next if dep.name == "jekyll"
External.require_with_graceful_fail(dep.name) if plugin_allowed?(dep.name)
end
end | ruby | {
"resource": ""
} |
q10462 | Jekyll.PluginManager.require_plugin_files | train | def require_plugin_files
unless site.safe
plugins_path.each do |plugin_search_path|
plugin_files = Utils.safe_glob(plugin_search_path, File.join("**", "*.rb"))
Jekyll::External.require_with_graceful_fail(plugin_files)
end
end
end | ruby | {
"resource": ""
} |
q10463 | Jekyll.StaticFile.path | train | def path
# Static file is from a collection inside custom collections directory
if !@collection.nil? && !@site.config["collections_dir"].empty?
File.join(*[@base, @site.config["collections_dir"], @dir, @name].compact)
else
File.join(*[@base, @dir, @name].compact)
end
end | ruby | {
"resource": ""
} |
q10464 | Jekyll.Document.merge_data! | train | def merge_data!(other, source: "YAML front matter")
merge_categories!(other)
Utils.deep_merge_hashes!(data, other)
merge_date!(source)
data
end | ruby | {
"resource": ""
} |
q10465 | Jekyll.Utils.deep_merge_hashes! | train | def deep_merge_hashes!(target, overwrite)
merge_values(target, overwrite)
merge_default_proc(target, overwrite)
duplicate_frozen_values(target)
target
end | ruby | {
"resource": ""
} |
q10466 | Jekyll.Utils.pluralized_array_from_hash | train | def pluralized_array_from_hash(hash, singular_key, plural_key)
[].tap do |array|
value = value_from_singular_key(hash, singular_key)
value ||= value_from_plural_key(hash, plural_key)
array << value
end.flatten.compact
end | ruby | {
"resource": ""
} |
q10467 | Jekyll.Utils.has_liquid_construct? | train | def has_liquid_construct?(content)
return false if content.nil? || content.empty?
content.include?("{%") || content.include?("{{")
end | ruby | {
"resource": ""
} |
q10468 | Jekyll.Utils.add_permalink_suffix | train | def add_permalink_suffix(template, permalink_style)
template = template.dup
case permalink_style
when :pretty
template << "/"
when :date, :ordinal, :none
template << ":output_ext"
else
template << "/" if permalink_style.to_s.end_with?("/")
template << ":out... | ruby | {
"resource": ""
} |
q10469 | Jekyll.Utils.replace_character_sequence_with_hyphen | train | def replace_character_sequence_with_hyphen(string, mode: "default")
replaceable_char =
case mode
when "raw"
SLUGIFY_RAW_REGEXP
when "pretty"
# "._~!$&'()+,;=@" is human readable (not URI-escaped) in URL
# and is allowed in both extN and NTFS.
SLUGIFY... | ruby | {
"resource": ""
} |
q10470 | Jekyll.Page.process | train | def process(name)
self.ext = File.extname(name)
self.basename = name[0..-ext.length - 1].gsub(%r!\.*\z!, "")
end | ruby | {
"resource": ""
} |
q10471 | Jekyll.Page.render | train | def render(layouts, site_payload)
site_payload["page"] = to_liquid
site_payload["paginator"] = pager.to_liquid
do_layout(site_payload, layouts)
end | ruby | {
"resource": ""
} |
q10472 | Jekyll.Filters.where_exp | train | def where_exp(input, variable, expression)
return input unless input.respond_to?(:select)
input = input.values if input.is_a?(Hash) # FIXME
condition = parse_condition(expression)
@context.stack do
input.select do |object|
@context[variable] = object
condition.evalu... | ruby | {
"resource": ""
} |
q10473 | Jekyll.Filters.sort | train | def sort(input, property = nil, nils = "first")
raise ArgumentError, "Cannot sort a null object." if input.nil?
if property.nil?
input.sort
else
if nils == "first"
order = - 1
elsif nils == "last"
order = + 1
else
raise ArgumentError, "Inv... | ruby | {
"resource": ""
} |
q10474 | Jekyll.Filters.sort_input | train | def sort_input(input, property, order)
input.map { |item| [item_property(item, property), item] }
.sort! do |a_info, b_info|
a_property = a_info.first
b_property = b_info.first
if !a_property.nil? && b_property.nil?
- order
elsif a_property.nil? && !b_p... | ruby | {
"resource": ""
} |
q10475 | Jekyll.Filters.compare_property_vs_target | train | def compare_property_vs_target(property, target)
case target
when NilClass
return true if property.nil?
when Liquid::Expression::MethodLiteral # `empty` or `blank`
return true if Array(property).join == target.to_s
else
Array(property).each do |prop|
return true... | ruby | {
"resource": ""
} |
q10476 | Jekyll.Collection.entries | train | def entries
return [] unless exists?
@entries ||=
Utils.safe_glob(collection_dir, ["**", "*"], File::FNM_DOTMATCH).map do |entry|
entry["#{collection_dir}/"] = ""
entry
end
end | ruby | {
"resource": ""
} |
q10477 | Jekyll.Collection.collection_dir | train | def collection_dir(*files)
return directory if files.empty?
site.in_source_dir(container, relative_directory, *files)
end | ruby | {
"resource": ""
} |
q10478 | Jekyll.Regenerator.add | train | def add(path)
return true unless File.exist?(path)
metadata[path] = {
"mtime" => File.mtime(path),
"deps" => [],
}
cache[path] = true
end | ruby | {
"resource": ""
} |
q10479 | Jekyll.Regenerator.add_dependency | train | def add_dependency(path, dependency)
return if metadata[path].nil? || disabled
unless metadata[path]["deps"].include? dependency
metadata[path]["deps"] << dependency
add(dependency) unless metadata.include?(dependency)
end
regenerate? dependency
end | ruby | {
"resource": ""
} |
q10480 | Jekyll.Regenerator.write_metadata | train | def write_metadata
unless disabled?
Jekyll.logger.debug "Writing Metadata:", ".jekyll-metadata"
File.binwrite(metadata_file, Marshal.dump(metadata))
end
end | ruby | {
"resource": ""
} |
q10481 | Frameit.ConfigParser.fetch_value | train | def fetch_value(path)
specifics = @data['data'].select { |a| path.include?(a['filter']) }
default = @data['default']
values = default.clone
specifics.each do |specific|
values = values.fastlane_deep_merge(specific)
end
change_paths_to_absolutes!(values)
validate_valu... | ruby | {
"resource": ""
} |
q10482 | Frameit.ConfigParser.change_paths_to_absolutes! | train | def change_paths_to_absolutes!(values)
values.each do |key, value|
if value.kind_of?(Hash)
change_paths_to_absolutes!(value) # recursive call
elsif value.kind_of?(Array)
value.each do |current|
change_paths_to_absolutes!(current) if current.kind_of?(Hash) # recursiv... | ruby | {
"resource": ""
} |
q10483 | Spaceship.PortalClient.provisioning_profiles_via_xcode_api | train | def provisioning_profiles_via_xcode_api(mac: false)
req = request(:post) do |r|
r.url("https://developerservices2.apple.com/services/#{PROTOCOL_VERSION}/#{platform_slug(mac)}/listProvisioningProfiles.action")
r.params = {
teamId: team_id,
includeInactiveProfiles: true,
... | ruby | {
"resource": ""
} |
q10484 | Spaceship.PortalClient.ensure_csrf | train | def ensure_csrf(klass)
if csrf_cache[klass]
self.csrf_tokens = csrf_cache[klass]
return
end
self.csrf_tokens = nil
# If we directly create a new resource (e.g. app) without querying anything before
# we don't have a valid csrf token, that's why we have to do at least one ... | ruby | {
"resource": ""
} |
q10485 | Frameit.Editor.put_into_frame | train | def put_into_frame
# We have to rotate the screenshot, since the offset information is for portrait
# only. Instead of doing the calculations ourselves, it's much easier to let
# imagemagick do the hard lifting for landscape screenshots
rotation = self.rotation_for_device_orientation
frame... | ruby | {
"resource": ""
} |
q10486 | Frameit.Editor.modify_offset | train | def modify_offset(multiplicator)
# Format: "+133+50"
hash = offset['offset']
x = hash.split("+")[1].to_f * multiplicator
y = hash.split("+")[2].to_f * multiplicator
new_offset = "+#{x.round}+#{y.round}"
@offset_information['offset'] = new_offset
end | ruby | {
"resource": ""
} |
q10487 | Frameit.Editor.horizontal_frame_padding | train | def horizontal_frame_padding
padding = fetch_config['padding']
if padding.kind_of?(String) && padding.split('x').length == 2
padding = padding.split('x')[0]
padding = padding.to_i unless padding.end_with?('%')
end
return scale_padding(padding)
end | ruby | {
"resource": ""
} |
q10488 | Frameit.Editor.title_min_height | train | def title_min_height
@title_min_height ||= begin
height = fetch_config['title_min_height'] || 0
if height.kind_of?(String) && height.end_with?('%')
height = ([image.width, image.height].min * height.to_f * 0.01).ceil
end
height
end
end | ruby | {
"resource": ""
} |
q10489 | Frameit.Editor.generate_background | train | def generate_background
background = MiniMagick::Image.open(fetch_config['background'])
if background.height != screenshot.size[1]
background.resize("#{screenshot.size[0]}x#{screenshot.size[1]}^") # `^` says it should fill area
background.merge!(["-gravity", "center", "-crop", "#{screenshot... | ruby | {
"resource": ""
} |
q10490 | Frameit.Editor.resize_frame! | train | def resize_frame!
screenshot_width = self.screenshot.portrait? ? screenshot.size[0] : screenshot.size[1]
multiplicator = (screenshot_width.to_f / offset['width'].to_f) # by how much do we have to change this?
new_frame_width = multiplicator * frame.width # the new width for the frame
frame.resi... | ruby | {
"resource": ""
} |
q10491 | Frameit.Editor.put_title_into_background_stacked | train | def put_title_into_background_stacked(background, title, keyword)
resize_text(title)
resize_text(keyword)
vertical_padding = vertical_frame_padding # assign padding to variable
spacing_between_title_and_keyword = (actual_font_size / 2)
title_left_space = (background.width / 2.0 - title.wi... | ruby | {
"resource": ""
} |
q10492 | Frameit.Editor.build_text_images | train | def build_text_images(max_width, max_height, stack_title)
words = [:keyword, :title].keep_if { |a| fetch_text(a) } # optional keyword/title
results = {}
trim_boxes = {}
top_vertical_trim_offset = Float::INFINITY # Init at a large value, as the code will search for a minimal value.
bottom_v... | ruby | {
"resource": ""
} |
q10493 | Frameit.Editor.fetch_text | train | def fetch_text(type)
UI.user_error!("Valid parameters :keyword, :title") unless [:keyword, :title].include?(type)
# Try to get it from a keyword.strings or title.strings file
strings_path = File.join(File.expand_path("..", screenshot.path), "#{type}.strings")
if File.exist?(strings_path)
... | ruby | {
"resource": ""
} |
q10494 | Frameit.Editor.font | train | def font(key)
single_font = fetch_config[key.to_s]['font']
return single_font if single_font
fonts = fetch_config[key.to_s]['fonts']
if fonts
fonts.each do |font|
if font['supported']
font['supported'].each do |language|
if screenshot.path.include?(la... | ruby | {
"resource": ""
} |
q10495 | Pilot.BuildManager.transporter_for_selected_team | train | def transporter_for_selected_team(options)
generic_transporter = FastlaneCore::ItunesTransporter.new(options[:username], nil, false, options[:itc_provider])
return generic_transporter unless options[:itc_provider].nil? && Spaceship::Tunes.client.teams.count > 1
begin
team = Spaceship::Tunes.c... | ruby | {
"resource": ""
} |
q10496 | Spaceship.Client.update_request_headers | train | def update_request_headers(req)
req.headers["X-Apple-Id-Session-Id"] = @x_apple_id_session_id
req.headers["X-Apple-Widget-Key"] = self.itc_service_key
req.headers["Accept"] = "application/json"
req.headers["scnt"] = @scnt
end | ruby | {
"resource": ""
} |
q10497 | FastlaneCore.ItunesTransporter.upload | train | def upload(app_id, dir)
actual_dir = File.join(dir, "#{app_id}.itmsp")
UI.message("Going to upload updated app to App Store Connect")
UI.success("This might take a few minutes. Please don't interrupt the script.")
command = @transporter_executor.build_upload_command(@user, @password, actual_di... | ruby | {
"resource": ""
} |
q10498 | FastlaneCore.ItunesTransporter.load_password_for_transporter | train | def load_password_for_transporter
# 3 different sources for the password
# 1) ENV variable for application specific password
if ENV[TWO_FACTOR_ENV_VARIABLE].to_s.length > 0
UI.message("Fetching password for transporter from environment variable named `#{TWO_FACTOR_ENV_VARIABLE}`")
re... | ruby | {
"resource": ""
} |
q10499 | FastlaneCore.ItunesTransporter.handle_two_step_failure | train | def handle_two_step_failure(ex)
if ENV[TWO_FACTOR_ENV_VARIABLE].to_s.length > 0
# Password provided, however we already used it
UI.error("")
UI.error("Application specific password you provided using")
UI.error("environment variable #{TWO_FACTOR_ENV_VARIABLE}")
UI.error("is... | ruby | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.