_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)
set_output_stream_done
nil
end | 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(batch_result)
end | 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
break if resp.nil? # the last response was received
yield resp
end
receive_and_check_status
ensure
set_input_stream_done
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.synchronize do
# Metadata might have already been sent if this is an operation view
unless @metadata_sent
ops[SEND_INITIAL_METADATA] = @metadata_to_send.merge!(metadata)
end
@metadata_sent = true
end
begin
batch_result = @call.run_batch(ops)
# no need to check for cancellation after a CallError because this
# batch contains a RECV_STATUS op
ensure
set_input_stream_done
set_output_stream_done
end
@call.metadata = batch_result.metadata
attach_status_results_and_complete_call(batch_result)
get_message_from_batch_result(batch_result)
end | 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
raise e
rescue => e
set_input_stream_done
raise e
ensure
set_output_stream_done
end
batch_result = @call.run_batch(
SEND_CLOSE_FROM_CLIENT => nil,
RECV_INITIAL_METADATA => nil,
RECV_MESSAGE => nil,
RECV_STATUS_ON_CLIENT => nil
)
set_input_stream_done
@call.metadata = batch_result.metadata
attach_status_results_and_complete_call(batch_result)
get_message_from_batch_result(batch_result)
end | 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 @metadata_sent
ops[SEND_INITIAL_METADATA] = @metadata_to_send.merge!(metadata)
end
@metadata_sent = true
end
begin
@call.run_batch(ops)
rescue GRPC::Core::CallError => e
receive_and_check_status # checks for Cancelled
raise e
rescue => e
set_input_stream_done
raise e
ensure
set_output_stream_done
end
replies = enum_for(:each_remote_read_then_finish)
return replies unless block_given?
replies.each { |r| yield r }
end | 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)
set_input_stream_done
set_output_stream_done
attach_status_results_and_complete_call(batch_result)
raise e
rescue => e
set_input_stream_done
set_output_stream_done
raise e
end
bd = BidiCall.new(@call,
@marshal,
@unmarshal,
metadata_received: @metadata_received)
bd.run_on_client(requests,
proc { set_input_stream_done },
proc { set_output_stream_done },
&blk)
end | 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)
interception_ctx.intercept!(
:bidi_streamer,
call: view,
method: mth,
requests: requests
) do
bidi_call.run_on_server(mth, requests)
end
end | 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
fail 'Illegal arity of reply generator'
end
write_loop(replies, is_client: false)
end | 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
batch_result
rescue GRPC::Core::CallError => e
GRPC.logger.warn('bidi call: read_using_run_batch failed')
GRPC.logger.warn(e)
nil
end
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 received
begin
@req_view.send_initial_metadata unless @req_view.nil?
@call.run_batch(SEND_MESSAGE => payload)
rescue GRPC::Core::CallError => e
# This is almost definitely caused by a status arriving while still
# writing. Don't re-throw the error
GRPC.logger.warn('bidi-write-loop: ended with error')
GRPC.logger.warn(e)
break
end
end
GRPC.logger.debug("bidi-write-loop: #{count} writes done")
if is_client
GRPC.logger.debug("bidi-write-loop: client sent #{count}, waiting")
begin
@call.run_batch(SEND_CLOSE_FROM_CLIENT => nil)
rescue GRPC::Core::CallError => e
GRPC.logger.warn('bidi-write-loop: send close failed')
GRPC.logger.warn(e)
end
GRPC.logger.debug('bidi-write-loop: done')
end
GRPC.logger.debug('bidi-write-loop: finished')
rescue StandardError => e
GRPC.logger.warn('bidi-write-loop: failed')
GRPC.logger.warn(e)
if is_client
@call.cancel_with_status(GRPC::Core::StatusCodes::UNKNOWN,
"GRPC bidi call error: #{e.inspect}")
else
raise e
end
ensure
set_output_stream_done.call if is_client
end | 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 beginning the loop
loop do
GRPC.logger.debug("bidi-read-loop: #{count}")
count += 1
batch_result = read_using_run_batch
# handle the next message
if batch_result.nil? || batch_result.message.nil?
GRPC.logger.debug("bidi-read-loop: null batch #{batch_result}")
if is_client
batch_result = @call.run_batch(RECV_STATUS_ON_CLIENT => nil)
@call.status = batch_result.status
@call.trailing_metadata = @call.status.metadata if @call.status
GRPC.logger.debug("bidi-read-loop: done status #{@call.status}")
batch_result.check_status
end
GRPC.logger.debug('bidi-read-loop: done reading!')
break
end
res = @unmarshal.call(batch_result.message)
yield res
end
rescue StandardError => e
GRPC.logger.warn('bidi: read-loop failed')
GRPC.logger.warn(e)
raise e
ensure
set_input_stream_done.call
end
GRPC.logger.debug('bidi-read-loop: finished')
# Make sure that the write loop is done before finishing the call.
# Note that blocking is ok at this point because we've already received
# a status
@enq_th.join if is_client
end | 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?
worker_queue = @ready_workers.pop
fail 'worker already has a task waiting' unless worker_queue.empty?
worker_queue << [blk, args]
end
end | 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 :exit } to kill a thread
loop_execute_jobs(jobs)
end
remove_current_thread
end
@workers << next_thread
end
end | 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 { throw :exit }, []]
end
@stop_cond.wait(@stop_mutex, @keep_alive) if @workers.size > 0
end
forcibly_stop_workers
GRPC.logger.info('stopped, all workers are shutdown')
end | 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')
GRPC.logger.warn(e)
end
end
end | 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 'Cannot stop before starting' if @running_state == :not_started
return if @running_state != :running
transition_running_state(:stopping)
deadline = from_relative_time(@poll_period)
@server.shutdown_and_notify(deadline)
end
@pool.stop
end | 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: #{@running_state}->#{target_state}"
end
end | 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)
end
end | 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
@stop_server_cv.wait(@stop_server_mu, wait_interval)
end
end
# stop is surrounded by mutex, should handle multiple calls to stop
# correctly
stop
end
valid_signals = Signal.list
# register signal handlers
signals.each do |sig|
# input validation
if sig.class == String
sig.upcase!
if sig.start_with?('SIG')
# cut out the SIG prefix to see if valid signal
sig = sig[3..-1]
end
end
# register signal traps for all valid signals
if valid_signals.value?(sig) || valid_signals.key?(sig)
Signal.trap(sig) do
@stop_server = true
@stop_server_cv.broadcast
end
else
fail "#{sig} not a valid signal"
end
end
run
@stop_server_thread.join
end | 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,
metadata_received: true, started: false)
c.send_status(GRPC::Core::StatusCodes::RESOURCE_EXHAUSTED,
'No free threads in thread pool')
nil
end | 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_rpc.deadline,
metadata_received: true, started: false)
c.send_status(GRPC::Core::StatusCodes::UNIMPLEMENTED, '')
nil
end | 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?
@pool.schedule(active_call) do |ac|
c, mth = ac
begin
rpc_descs[mth].run_server_method(
c,
rpc_handlers[mth],
@interceptors.build_context
)
rescue StandardError
c.send_status(GRPC::Core::StatusCodes::INTERNAL,
'Server handler failed')
end
end
end
rescue Core::CallError, RuntimeError => e
# these might happen for various reasons. The correct behavior of
# the server is to log them and continue, if it's not shutting down.
if running_state == :running
GRPC.logger.warn("server call failed: #{e}")
end
next
end
end
# @running_state should be :stopping here
@run_mutex.synchronize do
transition_running_state(:stopped)
GRPC.logger.info("stopped: #{self}")
@server.close
end
end | 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,
deadline: deadline,
parent: parent,
credentials: credentials)
interception_context = @interceptors.build_context
intercept_args = {
method: method,
request: req,
call: c.interceptable,
metadata: metadata
}
if return_op
# return the operation view of the active_call; define #execute as a
# new method for this instance that invokes #request_response.
c.merge_metadata_to_send(metadata)
op = c.operation
op.define_singleton_method(:execute) do
interception_context.intercept!(:request_response, intercept_args) do
c.request_response(req, metadata: metadata)
end
end
op
else
interception_context.intercept!(:request_response, intercept_args) do
c.request_response(req, metadata: metadata)
end
end
end | 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_call(parent, # parent call
@propagate_mask, # propagation options
method,
nil, # host use nil,
deadline)
call.set_credentials! credentials unless credentials.nil?
ActiveCall.new(call, marshal, unmarshal, deadline,
started: false)
end | 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_document
end | 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?
Jekyll.logger.debug "Rendering Liquid:", document.relative_path
output = render_liquid(output, payload, info, document.path)
end
Jekyll.logger.debug "Rendering Markup:", document.relative_path
output = convert(output.to_s)
document.content = output
if document.place_in_layout?
Jekyll.logger.debug "Rendering Layout:", document.relative_path
output = place_in_layouts(output, payload, info)
end
output
end | 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
output = render_layout(output, layout, info)
add_regenerator_dependencies(layout)
next unless (layout = site.layouts[layout.data["layout"]])
break if used.include?(layout)
used << layout
end
output
end | 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?(site.source) ? :site : :theme
Jekyll.logger.debug "Layout source:", layout_source
end
end | 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_attr]&.each { |t| hash[t] << p }
end
hash.each_value { |posts| posts.sort!.reverse! }
hash
end
end | 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_hashes(set["values"], defaults)
end
end
defaults
end | 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.logger.warn set.to_s
nil
end
end.compact
end | 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?(path) && File.readable?(path)
end | 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)
end | 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 # this will allow the modifications above to disappear
end | 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 << ":output_ext" if permalink_style.to_s.end_with?(":output_ext")
end
template
end | 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_PRETTY_REGEXP
when "ascii"
# For web servers not being able to handle Unicode, the safe
# method is to ditch anything else but latin letters and numeric
# digits.
SLUGIFY_ASCII_REGEXP
else
SLUGIFY_DEFAULT_REGEXP
end
# Strip according to the mode
string.gsub(replaceable_char, "-")
end | 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.evaluate(@context)
end
end || []
end | 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, "Invalid nils order: " \
"'#{nils}' is not a valid nils order. It must be 'first' or 'last'."
end
sort_input(input, property, order)
end
end | 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_property.nil?
+ order
else
a_property <=> b_property || a_property.to_s <=> b_property.to_s
end
end
.map!(&:last)
end | 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 if prop.to_s == target.to_s
end
end
false
end | 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_values(values)
values
end | 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) # recursive call
end
else
if ['font', 'background'].include?(key)
# Change the paths to relative ones
# `replace`: to change the content of the string, so it's actually stored
if @path # where is the config file. We don't have a config file in tests
containing_folder = File.expand_path('..', @path)
value.replace(File.join(containing_folder, value))
end
end
end
end
end | 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,
onlyCountLists: true
}
end
result = parse_response(req, 'provisioningProfiles')
csrf_cache[Spaceship::Portal::ProvisioningProfile] = self.csrf_tokens
result
end | 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 request
block_given? ? yield : klass.all
csrf_cache[klass] = self.csrf_tokens
end | 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.rotate(-rotation)
@image.rotate(-rotation)
# Debug Mode: Add filename to frame
if self.debug_mode
filename = File.basename(@frame_path, ".*")
filename.sub!('Apple', '') # remove 'Apple'
width = screenshot.size[0]
font_size = width / 20 # magic number that works well
offset_top = offset['offset'].split("+")[2].to_f
annotate_offset = "+0+#{offset_top}" # magic number that works semi well
frame.combine_options do |c|
c.gravity('North')
c.undercolor('#00000080')
c.fill('white')
c.pointsize(font_size)
c.annotate(annotate_offset.to_s, filename.to_s)
end
end
@image = frame.composite(image, "png") do |c|
c.compose("DstOver")
c.geometry(offset['offset'])
end
# Revert the rotation from above
frame.rotate(rotation)
@image.rotate(rotation)
end | 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.size[0]}x#{screenshot.size[1]}+0+0"]) # crop from center
end
background
end | 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.resize("#{new_frame_width.round}x") # resize it to the calculated width
modify_offset(multiplicator) # modify the offset to properly insert the screenshot into the frame later
end | 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.width / 2.0).round
keyword_left_space = (background.width / 2.0 - keyword.width / 2.0).round
self.space_to_device += title.height + keyword.height + spacing_between_title_and_keyword + vertical_padding
if title_below_image
keyword_top = background.height - effective_text_height / 2 - (keyword.height + spacing_between_title_and_keyword + title.height) / 2
else
keyword_top = device_top(background) / 2 - spacing_between_title_and_keyword / 2 - keyword.height
end
title_top = keyword_top + keyword.height + spacing_between_title_and_keyword
# keyword
background = background.composite(keyword, "png") do |c|
c.compose("Over")
c.geometry("+#{keyword_left_space}+#{keyword_top}")
end
# Place the title below the keyword
background = background.composite(title, "png") do |c|
c.compose("Over")
c.geometry("+#{title_left_space}+#{title_top}")
end
background
end | 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_vertical_trim_offset = 0
words.each do |key|
# Create empty background
empty_path = File.join(Frameit::ROOT, "lib/assets/empty.png")
text_image = MiniMagick::Image.open(empty_path)
image_height = max_height # gets trimmed afterwards anyway, and on the iPad the `y` would get cut
text_image.combine_options do |i|
# Oversize as the text might be larger than the actual image. We're trimming afterwards anyway
i.resize("#{max_width * 5.0}x#{image_height}!") # `!` says it should ignore the ratio
end
current_font = font(key)
text = fetch_text(key)
UI.verbose("Using #{current_font} as font the #{key} of #{screenshot.path}") if current_font
UI.verbose("Adding text '#{text}'")
text.gsub!('\n', "\n")
text.gsub!(/(?<!\\)(')/) { |s| "\\#{s}" } # escape unescaped apostrophes with a backslash
interline_spacing = fetch_config['interline_spacing']
# Add the actual title
text_image.combine_options do |i|
i.font(current_font) if current_font
i.gravity("Center")
i.pointsize(actual_font_size)
i.draw("text 0,0 '#{text}'")
i.interline_spacing(interline_spacing) if interline_spacing
i.fill(fetch_config[key.to_s]['color'])
end
results[key] = text_image
# Natively trimming the image with .trim will result in the loss of the common baseline between the text in all images when side-by-side (e.g. stack_title is false).
# Hence retrieve the calculated trim bounding box without actually trimming:
calculated_trim_box = text_image.identify do |b|
b.format("%@") # CALCULATED: trim bounding box (without actually trimming), see: http://www.imagemagick.org/script/escape.php
end
# Create a Trimbox object from the MiniMagick .identify string with syntax "<width>x<height>+<offset_x>+<offset_y>":
trim_box = Frameit::Trimbox.new(calculated_trim_box)
# Get the minimum top offset of the trim box:
if trim_box.offset_y < top_vertical_trim_offset
top_vertical_trim_offset = trim_box.offset_y
end
# Get the maximum bottom offset of the trim box, this is the top offset + height:
if (trim_box.offset_y + trim_box.height) > bottom_vertical_trim_offset
bottom_vertical_trim_offset = trim_box.offset_y + trim_box.height
end
# Store for the crop action:
trim_boxes[key] = trim_box
end
# Crop text images:
words.each do |key|
# Get matching trim box:
trim_box = trim_boxes[key]
# For side-by-side text images (e.g. stack_title is false) adjust the trim box based on top_vertical_trim_offset and bottom_vertical_trim_offset to maintain the text baseline:
unless stack_title
# Determine the trim area by maintaining the same vertical top offset based on the smallest value from all trim boxes (top_vertical_trim_offset).
# When the vertical top offset is larger than the smallest vertical top offset, the trim box needs to be adjusted:
if trim_box.offset_y > top_vertical_trim_offset
# Increase the height of the trim box with the difference in vertical top offset:
trim_box.height += trim_box.offset_y - top_vertical_trim_offset
# Change the vertical top offset to match that of the others:
trim_box.offset_y = top_vertical_trim_offset
UI.verbose("Trim box for key \"#{key}\" is adjusted to align top: #{trim_box}\n")
end
# Check if the height needs to be adjusted to reach the bottom offset:
if (trim_box.offset_y + trim_box.height) < bottom_vertical_trim_offset
# Set the height of the trim box to the difference between vertical bottom and top offset:
trim_box.height = bottom_vertical_trim_offset - trim_box.offset_y
UI.verbose("Trim box for key \"#{key}\" is adjusted to align bottom: #{trim_box}\n")
end
end
# Crop image with (adjusted) trim box parameters in MiniMagick string format:
results[key].crop(trim_box.string_format)
end
results
end | 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)
parsed = StringsParser.parse(strings_path)
text_array = parsed.find { |k, v| screenshot.path.upcase.include?(k.upcase) }
return text_array.last if text_array && text_array.last.length > 0 # Ignore empty string
end
UI.verbose("Falling back to text in Framefile.json as there was nothing specified in the #{type}.strings file")
# No string files, fallback to Framefile config
text = fetch_config[type.to_s]['text'] if fetch_config[type.to_s] && fetch_config[type.to_s]['text'] && fetch_config[type.to_s]['text'].length > 0 # Ignore empty string
return text
end | 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?(language)
return font["font"]
end
end
else
# No `supported` array, this will always be true
UI.verbose("Found a font with no list of supported languages, using this now")
return font["font"]
end
end
end
UI.verbose("No custom font specified for #{screenshot}, using the default one")
return nil
end | 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.client.teams.find { |t| t['contentProvider']['contentProviderId'].to_s == Spaceship::Tunes.client.team_id }
name = team['contentProvider']['name']
provider_id = generic_transporter.provider_ids[name]
UI.verbose("Inferred provider id #{provider_id} for team #{name}.")
return FastlaneCore::ItunesTransporter.new(options[:username], nil, false, provider_id)
rescue => ex
UI.verbose("Couldn't infer a provider short name for team with id #{Spaceship::Tunes.client.team_id} automatically: #{ex}. Proceeding without provider short name.")
return generic_transporter
end
end | 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_dir, @provider_short_name)
UI.verbose(@transporter_executor.build_upload_command(@user, 'YourPassword', actual_dir, @provider_short_name))
begin
result = @transporter_executor.execute(command, ItunesTransporter.hide_transporter_output?)
rescue TransporterRequiresApplicationSpecificPasswordError => ex
handle_two_step_failure(ex)
return upload(app_id, dir)
end
if result
UI.header("Successfully uploaded package to App Store Connect. It might take a few minutes until it's visible online.")
FileUtils.rm_rf(actual_dir) unless Helper.test? # we don't need the package any more, since the upload was successful
else
handle_error(@password)
end
result
end | 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}`")
return ENV[TWO_FACTOR_ENV_VARIABLE]
end
# 2) TWO_STEP_HOST_PREFIX from keychain
account_manager = CredentialsManager::AccountManager.new(user: @user,
prefix: TWO_STEP_HOST_PREFIX,
note: "application-specific")
password = account_manager.password(ask_if_missing: false)
return password if password.to_s.length > 0
# 3) standard iTC password
account_manager = CredentialsManager::AccountManager.new(user: @user)
return account_manager.password(ask_if_missing: true)
end | 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 invalid, please make sure it's correct")
UI.error("")
UI.user_error!("Invalid application specific password provided")
end
a = CredentialsManager::AccountManager.new(user: @user,
prefix: TWO_STEP_HOST_PREFIX,
note: "application-specific")
if a.password(ask_if_missing: false).to_s.length > 0
# user already entered one.. delete the old one
UI.error("Application specific password seems wrong")
UI.error("Please make sure to follow the instructions")
a.remove_from_keychain
end
UI.error("")
UI.error("Your account has 2 step verification enabled")
UI.error("Please go to https://appleid.apple.com/account/manage")
UI.error("and generate an application specific password for")
UI.error("the iTunes Transporter, which is used to upload builds")
UI.error("")
UI.error("To set the application specific password on a CI machine using")
UI.error("an environment variable, you can set the")
UI.error("#{TWO_FACTOR_ENV_VARIABLE} variable")
@password = a.password(ask_if_missing: true) # to ask the user for the missing value
return true
end | ruby | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.