_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3
values | text stringlengths 66 10.5k | 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}' to pid #{self.pid}")
::Process.kill(sig, self.pid) rescue nil
end | 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
@resource.wait(delay) if delay > 0
end
@events.shift
end
end | ruby | {
"resource": ""
} |
q15203 | God.Driver.schedule | train | def schedule(condition, delay = condition.interval)
applog(nil, :debug, "driver schedule #{condition} in #{delay} seconds")
@events.push(DriverEvent.new(delay, @task, condition))
end | 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
set_collection_ivar(c.respond_to?(:scoped) ? c.scoped : c.all)
end
end | 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
end
if respond_to? :parent, true
url ||= parent_url rescue nil
end
url ||= root_url rescue nil
end | 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?
rparams << without_protection
else
rparams << as_role if role_given?
end
... | 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])
actions_to_remove += ACTIONS - actions_to_... | ruby | {
"resource": ""
} |
q15210 | InheritedResources.ClassMethods.polymorphic_belongs_to | train | def polymorphic_belongs_to(*symbols, &block)
options = symbols.extract_options!
options.merge!(polymorphic: true)
belongs_to(*symbols, options, &block)
end | ruby | {
"resource": ""
} |
q15211 | InheritedResources.ClassMethods.singleton_belongs_to | train | def singleton_belongs_to(*symbols, &block)
options = symbols.extract_options!
options.merge!(singleton: true)
belongs_to(*symbols, options, &block)
end | ruby | {
"resource": ""
} |
q15212 | InheritedResources.ClassMethods.optional_belongs_to | train | def optional_belongs_to(*symbols, &block)
options = symbols.extract_options!
options.merge!(optional: true)
belongs_to(*symbols, options, &block)
end | 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,
scope: requested_scopes.join(" "))
end | 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
else
raise Unsplash::Error.new "Missing self link for #{self.class} with ID #{self.id}"
end
end | 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", params).body)
list.map do |photo|
Unsplash::Photo.new photo.to_hash
end
end | 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)
list.map do |collection|
Unsplash::Collection.new collection.to_hash
end
end | 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 }
updated = JSON.parse(connection.put("/collections/#{id}", params).body)
self.title = updated["title"]
self.descr... | 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"],
user_id: response["user"]["id"],
created_at: response["created_at"]
... | ruby | {
"resource": ""
} |
q15222 | Unsplash.Collection.remove | train | def remove(photo)
response = connection.delete("/collections/#{id}/remove", photo_id: photo.id)
(200..299).include?(response.status)
end | ruby | {
"resource": ""
} |
q15223 | Fugit.Duration.drop_seconds | train | def drop_seconds
h = @h.dup
h.delete(:sec)
h[:min] = 0 if h.empty?
self.class.allocate.init(nil, { literal: true }, h)
end | 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]
warning_when_session_invalid if session_id.blank?
['rucaptcha-session', session_id].join(':')
end | ruby | {
"resource": ""
} |
q15225 | RuCaptcha.ControllerHelpers.generate_rucaptcha | train | def generate_rucaptcha
res = RuCaptcha.generate()
session_val = {
code: res[0],
time: Time.now.to_i
}
RuCaptcha.cache.write(rucaptcha_sesion_key_key, session_val, expires_in: RuCaptcha.config.expires_in)
res[1]
end | 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)
cert.sign(key, OpenSSL::Digest::SHA256.new)
end | ruby | {
"resource": ""
} |
q15228 | Billy.CertificateChain.file | train | def file
contents = certificates.map { |cert| cert.to_pem }.join
write_file("chain-#{domain}.pem", contents)
end | 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?
current_shard_selection.shard_name(self, false)
else
name
end
end | 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
end
if ::Kernel::block_given?
@target << " ["
... | 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(
"<?#{directive_tag}",
"?>",
... | ruby | {
"resource": ""
} |
q15232 | Builder.XmlMarkup._special | train | def _special(open, close, data=nil, attrs=nil, order=[])
_indent
@target << open
@target << data if data
_insert_attributes(attrs, order) if attrs
@target << close
_newline
end | ruby | {
"resource": ""
} |
q15233 | Builder.XmlBase.method_missing | train | def method_missing(sym, *args, &block)
cache_method_call(sym) if ::Builder::XmlBase.cache_method_calls
tag!(sym, *args, &block)
end | 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|
tag!(sym, *args, &block)
end
end
end
end | ruby | {
"resource": ""
} |
q15235 | Sablon.Template.render_to_file | train | def render_to_file(output_path, context, properties = {})
File.open(output_path, 'wb') do |f|
f.write render_to_string(context, properties)
end
end | ruby | {
"resource": ""
} |
q15236 | Sablon.Configuration.register_html_tag | train | def register_html_tag(tag_name, type = :inline, **options)
tag = HTMLTag.new(tag_name, type, **options)
@permitted_html_tags[tag.name] = tag
end | ruby | {
"resource": ""
} |
q15237 | Celluloid.ClassMethods.pool_link | train | def pool_link(klass, config = {}, &block)
Supervision::Container::Pool.new_link(pooling_options(config, block: block, actors: klass))
end | 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
Actor.link(proxy)
proxy._send_(:initialize, *args, &block)
proxy
end | 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)
else
Internals::Logger.with_backtrace(caller(3)) do |logger|
logger.debug("Celluloid::Condition signaled spuriously")
end
... | ruby | {
"resource": ""
} |
q15241 | Celluloid.Condition.broadcast | train | def broadcast(value = nil)
@mutex.synchronize do
@waiters.each { |waiter| waiter << SignalConditionRequest.new(waiter.task, value) }
@waiters.clear
end
end | ruby | {
"resource": ""
} |
q15242 | Celluloid.Future.execute | train | def execute(receiver, method, args, block)
@mutex.synchronize do
raise "already calling" if @call
@call = Call::Sync.new(self, method, args, block)
end
receiver << @call
end | 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 @ready
if @forwards
@forwards.is_a?(Array) ? @forwards.each { |f| f << result } : @forwards << result
end
@result = res... | 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)
return message unless message.is_a?(SystemEvent)
handle_system_event(message)
end
end | 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 "Discarded message (unhandled): #{message}" if !@handlers.handle_message(message) && !@receivers.handle_message(message) && $CELLULOID_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)
rescue => ex
Internals::Logger.crash("Actor#handle_crash CRASHED!", ex)
end | ruby | {
"resource": ""
} |
q15250 | Celluloid.Actor.shutdown | train | def shutdown(exit_event = ExitEvent.new(behavior_proxy))
@behavior.shutdown
cleanup exit_event
ensure
Thread.current[:celluloid_actor] = nil
Thread.current[:celluloid_mailbox] = nil
end | 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
@links.each do |actor|
actor.mailbox << exit_event... | 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
Internals::Logger.warn "Attempted to resume a dead task: type=#{@type.inspect}, meta=#{@meta.inspec... | 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, subject: @subject },
dangerous_suspend: true, &Cell.shutdown)
end | 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
@cond... | 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
end
return message if message
raise TaskTimeout, "receive timeout exceeded"
end | 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
end
mes... | 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
message = @messages.slice!(index, 1).first if index
else
message = @messages.shift
end
message
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
end
Incident.new(merged_events.sort, triggering_event)
end | 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
Internals::Logger.debug "Discarded message (unhandled): #{message}" if $CELLULOID_DE... | 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|
sink << m
sink.flush if sink.respond_to?(:flush) and level == "debug"
end
@buf << m
end
end | ruby | {
"resource": ""
} |
q15266 | Redwood.MBox.each_raw_message_line | train | def each_raw_message_line offset
@mutex.synchronize do
ensure_open
@f.seek offset
until @f.eof? || MBox::is_break_line?(l = @f.gets)
yield l
end
end
end | 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 #{threads.size.pluralize 'thread'} as spam",
undos, lambda { regen_text }, lambda { threads... | 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'}",
undos, lambda { regen_text }, lambda { threads.each { |t| Index.save_thread t } }
regen_text
threads.each { |t| I... | 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 || t.participants.any? { |x| x.longname =~ query }
end | 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
# fill up the line with blanks to overwrite old screen contents
@w.mvaddstr y, x, " " * maxl unless o... | ruby | {
"resource": ""
} |
q15275 | Redwood.BufferManager.roll_buffers | train | def roll_buffers
bufs = rollable_buffers
bufs.last.force_to_top = false
raise_to_front bufs.first
end | 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
@e2p.delete person.email
@a2p.delete aalias if aalias
end | 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 query
matchset = run_query xapian_query, 0, 0, 100
matchset.matches_estimated
end | 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 = b.call
([m.from]+m.to+m.cc+m.bcc).compact.each { |p| contacts << [p.name, p.email] }
end
contacts.to_a.c... | 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 for #{p.id} to #{c.id}, perform? #{c.parent.nil?} || #{overwrite}"
return unless c... | 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
add_message builder.call
end
add_message m if good
end | ruby | {
"resource": ""
} |
q15287 | Redwood.ThreadSet.add_thread | train | def add_thread t
raise "duplicate" if @threads.values.member? t
t.each { |m, *o| add_message m }
end | 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 },
indexable_chunks.map { |c| c.lines.map { |l| l.fix_encoding! } },
indexable_subject,
].fl... | 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
else
l.to_s
end
end | 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...
jump_to_col [rightcol - buffer.content_width + 1, 0].max # move right
end
end | ruby | {
"resource": ""
} |
q15295 | Redwood.ScrollMode.jump_to_line | train | def jump_to_line l
l = l.clamp 0, lines - 1
return if @topline == l
@topline = l
@botline = [l + buffer.content_height, lines].min
buffer.mark_dirty
end | 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 = data
event.trigger
end | ruby | {
"resource": ""
} |
q15299 | WebsocketRails.BaseController.trigger_failure | train | def trigger_failure(data=nil)
event.success = false
event.data = data
event.trigger
end | ruby | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.