_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3
values | text stringlengths 30 4.3k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q15200 | God.Process.signal | train | def signal(sig)
sig = sig.to_i if sig.to_i != 0
applog(self, :info, "#{self.name} sending signal '#{sig}' | ruby | {
"resource": ""
} |
q15201 | God.Process.ensure_stop | train | def ensure_stop
applog(self, :warn, "#{self.name} ensuring stop...")
unless self.pid
applog(self, :warn, "#{self.name} stop called but pid is uknown")
return
end
# Poll to see if it's dead
@stop_timeout.times do
begin
::Process.kill(0, self.pid)
... | ruby | {
"resource": ""
} |
q15202 | God.DriverEventQueue.pop | train | def pop
@monitor.synchronize do
if @events.empty?
raise ThreadError, "queue empty" if @shutdown
@resource.wait
else
delay = @events.first.at - Time.now
| ruby | {
"resource": ""
} |
q15203 | God.Driver.schedule | train | def schedule(condition, delay = condition.interval)
applog(nil, :debug, "driver schedule #{condition} in #{delay} seconds")
| ruby | {
"resource": ""
} |
q15204 | God.Watch.call_action | train | def call_action(condition, action)
# Before.
before_items = self.behaviors
before_items += [condition] if condition
before_items.each do |b|
info = b.send("before_#{action}")
if info
msg = "#{self.name} before_#{action}: #{info} (#{b.base_name})"
applog(self, ... | ruby | {
"resource": ""
} |
q15205 | InheritedResources.BaseHelpers.collection | train | def collection
get_collection_ivar || begin
c = end_of_association_chain
| ruby | {
"resource": ""
} |
q15206 | InheritedResources.BaseHelpers.end_of_association_chain | train | def end_of_association_chain #:nodoc:
if chain = association_chain.last
if method_for_association_chain
apply_scopes_if_available(chain.send(method_for_association_chain))
else
# This only happens when we specify begin_of_association_chain in
# a singleton... | ruby | {
"resource": ""
} |
q15207 | InheritedResources.BaseHelpers.smart_collection_url | train | def smart_collection_url
url = nil
if respond_to? :index
url ||= collection_url rescue nil | ruby | {
"resource": ""
} |
q15208 | InheritedResources.BaseHelpers.build_resource_params | train | def build_resource_params
parameters = permitted_params || params
rparams = [parameters[resource_request_name] || parameters[resource_instance_name] || {}]
if without_protection_given?
| ruby | {
"resource": ""
} |
q15209 | InheritedResources.ClassMethods.actions | train | def actions(*actions_to_keep)
raise ArgumentError, 'Wrong number of arguments. You have to provide which actions you want to keep.' if actions_to_keep.empty?
options = actions_to_keep.extract_options!
actions_to_remove = Array(options[:except]) | ruby | {
"resource": ""
} |
q15210 | InheritedResources.ClassMethods.polymorphic_belongs_to | train | def polymorphic_belongs_to(*symbols, &block)
options = symbols.extract_options!
options.merge!(polymorphic: | ruby | {
"resource": ""
} |
q15211 | InheritedResources.ClassMethods.singleton_belongs_to | train | def singleton_belongs_to(*symbols, &block)
options = symbols.extract_options!
options.merge!(singleton: | ruby | {
"resource": ""
} |
q15212 | InheritedResources.ClassMethods.optional_belongs_to | train | def optional_belongs_to(*symbols, &block)
options = symbols.extract_options!
options.merge!(optional: | ruby | {
"resource": ""
} |
q15213 | InheritedResources.ClassMethods.custom_actions | train | def custom_actions(options)
self.resources_configuration[:self][:custom_actions] = options
options.each do | resource_or_collection, actions |
[*actions].each do | action |
create_custom_action(resource_or_collection, action)
end
end
create_resources_url_h... | ruby | {
"resource": ""
} |
q15214 | InheritedResources.ClassMethods.initialize_resources_class_accessors! | train | def initialize_resources_class_accessors! #:nodoc:
# First priority is the namespaced model, e.g. User::Group
self.resource_class ||= begin
namespaced_class = self.name.sub(/Controller$/, '').singularize
namespaced_class.constantize
rescue NameError
nil
end
... | ruby | {
"resource": ""
} |
q15215 | InheritedResources.PolymorphicHelpers.symbols_for_association_chain | train | def symbols_for_association_chain #:nodoc:
polymorphic_config = resources_configuration[:polymorphic]
parents_symbols.map do |symbol|
if symbol == :polymorphic
params_keys = params.keys
keys = polymorphic_config[:symbols].map do |poly|
params_keys.include... | ruby | {
"resource": ""
} |
q15216 | Unsplash.Connection.authorization_url | train | def authorization_url(requested_scopes = ["public"])
@oauth.auth_code.authorize_url(redirect_uri: Unsplash.configuration.application_redirect_uri, | ruby | {
"resource": ""
} |
q15217 | Unsplash.Client.reload! | train | def reload!
if links && links["self"]
attrs = JSON.parse(connection.get(links["self"]).body)
@attributes = OpenStruct.new(attrs)
self
| ruby | {
"resource": ""
} |
q15218 | Unsplash.User.photos | train | def photos(page = 1, per_page = 10)
params = {
page: page,
per_page: per_page
}
list = JSON.parse(connection.get("/users/#{username}/photos", | ruby | {
"resource": ""
} |
q15219 | Unsplash.User.collections | train | def collections(page = 1, per_page = 10)
params = {
page: page,
per_page: per_page
}
list = JSON.parse(connection.get("/users/#{username}/collections", params).body)
| ruby | {
"resource": ""
} |
q15220 | Unsplash.Collection.update | train | def update(title: nil, description: nil, private: nil)
params = {
title: title,
description: description,
private: private
}.select { |k,v| v }
| ruby | {
"resource": ""
} |
q15221 | Unsplash.Collection.add | train | def add(photo)
response = JSON.parse(connection.post("/collections/#{id}/add", { photo_id: photo.id }).body)
{
photo_id: response["photo"]["id"],
collection_id: response["collection"]["id"],
| ruby | {
"resource": ""
} |
q15222 | Unsplash.Collection.remove | train | def remove(photo)
response = connection.delete("/collections/#{id}/remove", | ruby | {
"resource": ""
} |
q15223 | Fugit.Duration.drop_seconds | train | def drop_seconds
h = @h.dup
h.delete(:sec)
h[:min] = 0 if h.empty?
| ruby | {
"resource": ""
} |
q15224 | RuCaptcha.ControllerHelpers.rucaptcha_sesion_key_key | train | def rucaptcha_sesion_key_key
session_id = session.respond_to?(:id) ? session.id : session[:session_id] | ruby | {
"resource": ""
} |
q15225 | RuCaptcha.ControllerHelpers.generate_rucaptcha | train | def generate_rucaptcha
res = RuCaptcha.generate()
session_val = {
code: res[0],
| ruby | {
"resource": ""
} |
q15226 | RuCaptcha.ControllerHelpers.verify_rucaptcha? | train | def verify_rucaptcha?(resource = nil, opts = {})
opts ||= {}
store_info = RuCaptcha.cache.read(rucaptcha_sesion_key_key)
# make sure move used key
RuCaptcha.cache.delete(rucaptcha_sesion_key_key) unless opts[:keep_session]
# Make sure session exist
if store_info.blank?
retu... | ruby | {
"resource": ""
} |
q15227 | Billy.Authority.generate | train | def generate
cert = OpenSSL::X509::Certificate.new
configure(cert)
add_extensions(cert)
| ruby | {
"resource": ""
} |
q15228 | Billy.CertificateChain.file | train | def file
contents = certificates.map { |cert| | ruby | {
"resource": ""
} |
q15229 | ActiveRecordShards.ConnectionSwitcher.connection_pool_name | train | def connection_pool_name # :nodoc:
name = current_shard_selection.shard_name(self)
if configurations[name].nil? && on_slave?
| ruby | {
"resource": ""
} |
q15230 | Builder.XmlMarkup.declare! | train | def declare!(inst, *args, &block)
_indent
@target << "<!#{inst}"
args.each do |arg|
case arg
when ::String
@target << %{ "#{arg}"} # " WART
when ::Symbol
@target << " #{arg}"
end
| ruby | {
"resource": ""
} |
q15231 | Builder.XmlMarkup.instruct! | train | def instruct!(directive_tag=:xml, attrs={})
_ensure_no_block ::Kernel::block_given?
if directive_tag == :xml
a = { :version=>"1.0", :encoding=>"UTF-8" }
attrs = a.merge attrs
@encoding = attrs[:encoding].downcase
end
_special(
| ruby | {
"resource": ""
} |
q15232 | Builder.XmlMarkup._special | train | def _special(open, close, data=nil, attrs=nil, order=[])
_indent
@target << open
@target << data if data
| ruby | {
"resource": ""
} |
q15233 | Builder.XmlBase.method_missing | train | def method_missing(sym, *args, &block)
cache_method_call(sym) | ruby | {
"resource": ""
} |
q15234 | Builder.XmlBase.cache_method_call | train | def cache_method_call(sym)
class << self; self; end.class_eval do
unless method_defined?(sym)
define_method(sym) do |*args, &block|
| ruby | {
"resource": ""
} |
q15235 | Sablon.Template.render_to_file | train | def render_to_file(output_path, context, properties = {})
File.open(output_path, 'wb') do |f|
| ruby | {
"resource": ""
} |
q15236 | Sablon.Configuration.register_html_tag | train | def register_html_tag(tag_name, type = :inline, **options)
| ruby | {
"resource": ""
} |
q15237 | Celluloid.ClassMethods.pool_link | train | def pool_link(klass, config = {}, &block)
Supervision::Container::Pool.new_link(pooling_ | ruby | {
"resource": ""
} |
q15238 | Celluloid.ClassMethods.new_link | train | def new_link(*args, &block)
raise NotActorError, "can't link outside actor context" unless Celluloid.actor?
proxy = Cell.new(allocate, behavior_options, actor_options).proxy
| ruby | {
"resource": ""
} |
q15239 | Celluloid.Condition.wait | train | def wait(timeout = nil)
raise ConditionError, "cannot wait for signals while exclusive" if Celluloid.exclusive?
if actor = Thread.current[:celluloid_actor]
task = Task.current
if timeout
bt = caller
timer = actor.timers.after(timeout) do
exception = Condition... | ruby | {
"resource": ""
} |
q15240 | Celluloid.Condition.signal | train | def signal(value = nil)
@mutex.synchronize do
if waiter = @waiters.shift
waiter << SignalConditionRequest.new(waiter.task, value)
| ruby | {
"resource": ""
} |
q15241 | Celluloid.Condition.broadcast | train | def broadcast(value = nil)
@mutex.synchronize do
@waiters.each { |waiter| waiter << | ruby | {
"resource": ""
} |
q15242 | Celluloid.Future.execute | train | def execute(receiver, method, args, block)
@mutex.synchronize do
raise "already | ruby | {
"resource": ""
} |
q15243 | Celluloid.Future.value | train | def value(timeout = nil)
ready = result = nil
begin
@mutex.lock
if @ready
ready = true
result = @result
else
case @forwards
when Array
@forwards << Celluloid.mailbox
when NilClass
@forwards = Celluloid.mailbo... | ruby | {
"resource": ""
} |
q15244 | Celluloid.Future.signal | train | def signal(value)
return if @cancelled
result = Result.new(value, self)
@mutex.synchronize do
raise "the future has already happened!" if | ruby | {
"resource": ""
} |
q15245 | Celluloid.Actor.run | train | def run
while @running
begin
@timers.wait do |interval|
interval = 0 if interval && interval < 0
if message = @mailbox.check(interval)
handle_message(message)
break unless @running
end
end
rescue MailboxShutdown
... | ruby | {
"resource": ""
} |
q15246 | Celluloid.Actor.linking_request | train | def linking_request(receiver, type)
Celluloid.exclusive do
receiver.mailbox << LinkingRequest.new(Actor.current, type)
system_events = []
Timers::Wait.for(LINKING_TIMEOUT) do |remaining|
begin
message = @mailbox.receive(remaining) do |msg|
msg.is_a?(Lin... | ruby | {
"resource": ""
} |
q15247 | Celluloid.Actor.receive | train | def receive(timeout = nil, &block)
loop do
message = @receivers.receive(timeout, &block)
| ruby | {
"resource": ""
} |
q15248 | Celluloid.Actor.handle_message | train | def handle_message(message)
# !!! DO NOT INTRODUCE ADDITIONAL GLOBAL VARIABLES !!!
# rubocop:disable Metrics/LineLength, Style/GlobalVars
Internals::Logger.debug | ruby | {
"resource": ""
} |
q15249 | Celluloid.Actor.handle_crash | train | def handle_crash(exception)
# TODO: add meta info
Internals::Logger.crash("Actor crashed!", exception)
shutdown ExitEvent.new(behavior_proxy, exception) | ruby | {
"resource": ""
} |
q15250 | Celluloid.Actor.shutdown | train | def shutdown(exit_event = ExitEvent.new(behavior_proxy))
@behavior.shutdown
cleanup exit_event
ensure
| ruby | {
"resource": ""
} |
q15251 | Celluloid.Actor.cleanup | train | def cleanup(exit_event)
# !!! DO NOT INTRODUCE ADDITIONAL GLOBAL VARIABLES !!!
# rubocop:disable Style/GlobalVars
Celluloid::Probe.actor_died(self) if $CELLULOID_MONITORING
# rubocop:enable Style/GlobalVars
@mailbox.shutdown
| ruby | {
"resource": ""
} |
q15252 | Celluloid.Task.suspend | train | def suspend(status)
raise "Cannot suspend while in exclusive mode" if exclusive?
raise "Cannot suspend a task from outside of itself" unless Task.current == self
@status = status
# !!! DO NOT INTRODUCE ADDITIONAL GLOBAL VARIABLES !!!
# rubocop:disable Style/GlobalVars
if $CELLULOID... | ruby | {
"resource": ""
} |
q15253 | Celluloid.Task.resume | train | def resume(value = nil)
guard "Cannot resume a task from inside of a task" if Thread.current[:celluloid_task]
if running?
deliver(value)
else
# rubocop:disable Metrics/LineLength
| ruby | {
"resource": ""
} |
q15254 | Celluloid.Task.terminate | train | def terminate
raise "Cannot terminate an exclusive task" if exclusive?
if running?
# !!! DO NOT INTRODUCE ADDITIONAL GLOBAL VARIABLES !!!
# rubocop:disable Style/GlobalVars
if $CELLULOID_DEBUG
Internals::Logger.with_backtrace(backtrace) do |logger|
type = @dang... | ruby | {
"resource": ""
} |
q15255 | Celluloid.Cell.shutdown | train | def shutdown
return unless @finalizer && @subject.respond_to?(@finalizer, true)
task(:finalizer, @finalizer, { call: @finalizer, | ruby | {
"resource": ""
} |
q15256 | Celluloid.Mailbox.<< | train | def <<(message)
@mutex.lock
begin
if mailbox_full || @dead
dead_letter(message)
return
end
if message.is_a?(SystemEvent)
# SystemEvents are high priority messages so they get added to the
# head of our message queue instead of the end
| ruby | {
"resource": ""
} |
q15257 | Celluloid.Mailbox.check | train | def check(timeout = nil, &block)
message = nil
@mutex.lock
begin
raise MailboxDead, "attempted to receive from a dead mailbox" if @dead
message = nil
Timers::Wait.for(timeout) do |remaining|
message = next_message(&block)
break if message
| ruby | {
"resource": ""
} |
q15258 | Celluloid.Mailbox.receive | train | def receive(timeout = nil, &block)
message = nil
Timers::Wait.for(timeout) do |_remaining|
message = check(timeout, &block)
break if message
| ruby | {
"resource": ""
} |
q15259 | Celluloid.Mailbox.shutdown | train | def shutdown
raise MailboxDead, "mailbox already shutdown" if @dead
@mutex.lock
begin
yield if block_given?
messages = @messages
@messages = []
@dead = true
ensure
begin
@mutex.unlock
rescue
nil
end
| ruby | {
"resource": ""
} |
q15260 | Celluloid.Mailbox.next_message | train | def next_message
message = nil
if block_given?
index = @messages.index do |msg|
yield(msg) || msg.is_a?(SystemEvent)
end
| ruby | {
"resource": ""
} |
q15261 | Celluloid.Incident.merge | train | def merge(*other_incidents)
merged_events = other_incidents.flatten.inject(events) do |events, incident|
events += incident.events
| ruby | {
"resource": ""
} |
q15262 | Celluloid.Actor.handle_system_event | train | def handle_system_event(event)
if handler = SystemEvent.handle(event.class)
send(handler, event)
else
# !!! DO NOT INTRODUCE ADDITIONAL GLOBAL VARIABLES !!!
# rubocop:disable Style/GlobalVars
| ruby | {
"resource": ""
} |
q15263 | Celluloid.IncidentLogger.add | train | def add(severity, message = nil, progname = nil, &block)
progname ||= @progname
severity ||= UNKNOWN
return event.id if severity < @level
if message.nil? && !block_given?
message = progname
progname = @progname
end
event = LogEvent.new(severity, message, progname, ... | ruby | {
"resource": ""
} |
q15264 | Redwood.CryptoManager.decrypt | train | def decrypt payload, armor=false # a RubyMail::Message object
return unknown_status(@not_working_reason) unless @not_working_reason.nil?
gpg_opts = {:protocol => GPGME::PROTOCOL_OpenPGP}
gpg_opts = HookManager.run("gpg-options",
{:operation => "decrypt", :options => gpg_opts}... | ruby | {
"resource": ""
} |
q15265 | Redwood.Logger.send_message | train | def send_message m
@mutex.synchronize do
@sinks.each do |sink|
| ruby | {
"resource": ""
} |
q15266 | Redwood.MBox.each_raw_message_line | train | def each_raw_message_line offset
@mutex.synchronize do
ensure_open
| ruby | {
"resource": ""
} |
q15267 | Redwood.AccountManager.add_account | train | def add_account hash, default=false
raise ArgumentError, "no email specified for account" unless hash[:email]
unless default
[:name, :sendmail, :signature, :gpgkey].each { |k| hash[k] ||= @default_account.send(k) }
end
hash[:alternates] ||= []
fail "alternative emails are not an array: #{hash[... | ruby | {
"resource": ""
} |
q15268 | Redwood.ThreadIndexMode.select | train | def select t=nil, when_done=nil
t ||= cursor_thread or return
Redwood::reporting_thread("load messages for thread-view-mode") do
num = t.size
message = "Loading #{num.pluralize 'message body'}..."
BufferManager.say(message) do |sid|
t.each_with_index do |(m, *_), i|
next unl... | ruby | {
"resource": ""
} |
q15269 | Redwood.ThreadIndexMode.multi_toggle_spam | train | def multi_toggle_spam threads
undos = threads.map { |t| actually_toggle_spammed t }
threads.each { |t| HookManager.run("mark-as-spam", :thread => t) }
UndoManager.register "marking/unmarking | ruby | {
"resource": ""
} |
q15270 | Redwood.ThreadIndexMode.multi_toggle_deleted | train | def multi_toggle_deleted threads
undos = threads.map { |t| actually_toggle_deleted t }
UndoManager.register "deleting/undeleting #{threads.size.pluralize 'thread'}",
| ruby | {
"resource": ""
} |
q15271 | Redwood.ThreadIndexMode.multi_kill | train | def multi_kill threads
UndoManager.register "killing/unkilling #{threads.size.pluralize 'threads'}" do
threads.each do |t|
if t.toggle_label :killed
add_or_unhide t.first
else
hide_thread t
end
end.each do |t|
UpdateManager.relay self, :labeled, t.firs... | ruby | {
"resource": ""
} |
q15272 | Redwood.ThreadIndexMode.thread_matches? | train | def thread_matches? t, query
t.subj =~ query || t.snippet =~ query || | ruby | {
"resource": ""
} |
q15273 | Redwood.ThreadIndexMode.author_names_and_newness_for_thread | train | def author_names_and_newness_for_thread t, limit=nil
new = {}
seen = {}
authors = t.map do |m, *o|
next unless m && m.from
new[m.from] ||= m.has_label?(:unread)
next if seen[m.from]
seen[m.from] = true
m.from
end.compact
result = []
authors.each do |a|
break ... | ruby | {
"resource": ""
} |
q15274 | Redwood.Buffer.write | train | def write y, x, s, opts={}
return if x >= @width || y >= @height
@w.attrset Colormap.color_for(opts[:color] || :none, opts[:highlight])
s ||= ""
maxl = @width - x # maximum display width width
| ruby | {
"resource": ""
} |
q15275 | Redwood.BufferManager.roll_buffers | train | def roll_buffers
bufs = rollable_buffers
bufs.last.force_to_top = | ruby | {
"resource": ""
} |
q15276 | Redwood.BufferManager.ask_for_labels | train | def ask_for_labels domain, question, default_labels, forbidden_labels=[]
default_labels = default_labels - forbidden_labels - LabelManager::RESERVED_LABELS
default = default_labels.to_a.join(" ")
default += " " unless default.empty?
# here I would prefer to give more control and allow all_labels instea... | ruby | {
"resource": ""
} |
q15277 | Redwood.BufferManager.ask | train | def ask domain, question, default=nil, &block
raise "impossible!" if @asking
raise "Question too long" if Ncurses.cols <= question.length
@asking = true
@textfields[domain] ||= TextField.new
tf = @textfields[domain]
completion_buf = nil
status, title = get_status_and_title @focus_buf
... | ruby | {
"resource": ""
} |
q15278 | Redwood.ContactManager.drop_contact | train | def drop_contact person
aalias = @p2a[person]
@p2a.delete person
| ruby | {
"resource": ""
} |
q15279 | Redwood.ThreadViewMode.regen_text | train | def regen_text
@text = []
@chunk_lines = []
@message_lines = []
@person_lines = []
prevm = nil
@thread.each do |m, depth, parent|
unless m.is_a? Message # handle nil and :fake_root
@text += chunk_to_lines m, nil, @text.length, depth, parent
next
end
l = @layout... | ruby | {
"resource": ""
} |
q15280 | Redwood.Index.num_results_for | train | def num_results_for query={}
xapian_query = build_xapian_query | ruby | {
"resource": ""
} |
q15281 | Redwood.Index.build_message | train | def build_message id
entry = synchronize { get_entry id }
return unless entry
locations = entry[:locations].map do |source_id,source_info|
source = SourceManager[source_id]
raise "invalid source #{source_id}" unless source
Location.new source, source_info
end
m = Message.new :loc... | ruby | {
"resource": ""
} |
q15282 | Redwood.Index.load_contacts | train | def load_contacts email_addresses, opts={}
contacts = Set.new
num = opts[:num] || 20
each_id_by_date :participants => email_addresses do |id,b|
break if contacts.size >= num
m | ruby | {
"resource": ""
} |
q15283 | Redwood.Index.index_message_static | train | def index_message_static m, doc, entry
# Person names are indexed with several prefixes
person_termer = lambda do |d|
lambda do |p|
doc.index_text p.name, PREFIX["#{d}_name"][:prefix] if p.name
doc.index_text p.email, PREFIX['email_text'][:prefix]
doc.add_term mkterm(:email, d, p.e... | ruby | {
"resource": ""
} |
q15284 | Redwood.Index.mkterm | train | def mkterm type, *args
case type
when :label
PREFIX['label'][:prefix] + args[0].to_s.downcase
when :type
PREFIX['type'][:prefix] + args[0].to_s.downcase
when :date
PREFIX['date'][:prefix] + args[0].getutc.strftime("%Y%m%d%H%M%S")
when :email
case args[0]
when :from then... | ruby | {
"resource": ""
} |
q15285 | Redwood.ThreadSet.link | train | def link p, c, overwrite=false
if p == c || p.descendant_of?(c) || c.descendant_of?(p) # would create a loop
#puts "*** linking parent #{p.id} and child #{c.id} would create a loop"
return
end
#puts "in link | ruby | {
"resource": ""
} |
q15286 | Redwood.ThreadSet.load_thread_for_message | train | def load_thread_for_message m, opts={}
good = @index.each_message_in_thread_for m, opts do |mid, builder|
next if contains_id? mid
| ruby | {
"resource": ""
} |
q15287 | Redwood.ThreadSet.add_thread | train | def add_thread t
raise "duplicate" if @threads.values.member? t
| ruby | {
"resource": ""
} |
q15288 | Redwood.ThreadSet.join_threads | train | def join_threads threads
return if threads.size < 2
containers = threads.map do |t|
c = @messages.member?(t.first.id) ? @messages[t.first.id] : nil
raise "not in threadset: #{t.first.id}" unless c && c.message
c
end
## use subject headers heuristically
parent = containers.find { ... | ruby | {
"resource": ""
} |
q15289 | Redwood.ThreadSet.add_message | train | def add_message message
el = @messages[message.id]
return if el.message # we've seen it before
#puts "adding: #{message.id}, refs #{message.refs.inspect}"
el.message = message
oldroot = el.root
## link via references:
(message.refs + [el.id]).inject(nil) do |prev, ref_id|
ref = @mes... | ruby | {
"resource": ""
} |
q15290 | Redwood.Message.load_from_source! | train | def load_from_source!
@chunks ||=
begin
## we need to re-read the header because it contains information
## that we don't store in the index. actually i think it's just
## the mailing list address (if any), so this is kinda overkill.
## i could just store that in the index, but... | ruby | {
"resource": ""
} |
q15291 | Redwood.Message.indexable_content | train | def indexable_content
load_from_source!
[
from && from.indexable_content,
to.map { |p| p.indexable_content },
cc.map { |p| p.indexable_content },
bcc.map { |p| p.indexable_content },
| ruby | {
"resource": ""
} |
q15292 | Redwood.Message.multipart_signed_to_chunks | train | def multipart_signed_to_chunks m
if m.body.size != 2
warn_with_location "multipart/signed with #{m.body.size} parts (expecting 2)"
return
end
payload, signature = m.body
if signature.multipart?
warn_with_location "multipart/signed with payload multipart #{payload.multipart?} and signa... | ruby | {
"resource": ""
} |
q15293 | Redwood.LabelManager.string_for | train | def string_for l
if RESERVED_LABELS.include? l
l.to_s.capitalize
| ruby | {
"resource": ""
} |
q15294 | Redwood.ScrollMode.search_goto_pos | train | def search_goto_pos line, leftcol, rightcol
search_goto_line line
if rightcol > self.rightcol # if it's occluded...
| ruby | {
"resource": ""
} |
q15295 | Redwood.ScrollMode.jump_to_line | train | def jump_to_line l
l = l.clamp 0, lines - 1
return if @topline == | ruby | {
"resource": ""
} |
q15296 | Redwood.LineCursorMode.page_down | train | def page_down
## if we're on the last page, and it's not a full page, just move
## the cursor down to the bottom and assume we can't load anything
## else via the callbacks.
if topline > lines - buffer.content_height
set_cursor_pos(lines - 1)
## if we're on the last page, and it's a full page... | ruby | {
"resource": ""
} |
q15297 | Redwood.TextField.get_cursed_value | train | def get_cursed_value
return nil unless @field
x = Ncurses.curx
form_driver_key Ncurses::Form::REQ_VALIDATION
v = @field.field_buffer(0).gsub(/^\s+|\s+$/, "")
## cursor <= end of text
if x - @question.length - v.length <= 0
v
else # trailing spaces
v + (" " * (x - @question.leng... | ruby | {
"resource": ""
} |
q15298 | WebsocketRails.BaseController.trigger_success | train | def trigger_success(data=nil)
event.success = true
event.data | ruby | {
"resource": ""
} |
q15299 | WebsocketRails.BaseController.trigger_failure | train | def trigger_failure(data=nil)
event.success = false
event.data | ruby | {
"resource": ""
} |
Subsets and Splits
SQL Console for CoIR-Retrieval/CodeSearchNet-ccr-ruby-queries-corpus
Retrieves a large number of entries in the 'ruby' language, providing basic information but limited analytical value.