_id
stringlengths 2
6
| title
stringlengths 9
130
| partition
stringclasses 3
values | text
stringlengths 66
10.5k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q27100
|
Tabletastic.TableBuilder.action_link
|
test
|
def action_link(action, prefix)
html_class = "actions #{action.to_s}_link"
block = lambda do |resource|
compound_resource = [prefix, resource].compact
compound_resource.flatten! if prefix.kind_of?(Array)
case action
when :show
@template.link_to(link_title(action), compound_resource)
when :destroy
@template.link_to(link_title(action), compound_resource,
:method => :delete, :data => { :confirm => confirmation_message })
else # edit, other resource GET actions
@template.link_to(link_title(action),
@template.polymorphic_path(compound_resource, :action => action))
end
end
self.cell(action, :heading => "", :cell_html => {:class => html_class}, &block)
end
|
ruby
|
{
"resource": ""
}
|
q27101
|
Metro.Scenes.add
|
test
|
def add(scene)
all_scenes_for(scene).each { |scene| scenes_hash[scene.scene_name] = scene.to_s }
end
|
ruby
|
{
"resource": ""
}
|
q27102
|
Metro.Scenes.apply_post_filters
|
test
|
def apply_post_filters(new_scene,options)
post_filters.inject(new_scene) {|scene,post| post.filter(scene,options) }
end
|
ruby
|
{
"resource": ""
}
|
q27103
|
Metro.Scenes.hash_with_missing_scene_default
|
test
|
def hash_with_missing_scene_default
hash = HashWithIndifferentAccess.new do |hash,key|
missing_scene = hash[:missing_scene].constantize
missing_scene.missing_scene = key.to_sym
missing_scene
end
hash[:missing_scene] = "Metro::MissingScene"
hash
end
|
ruby
|
{
"resource": ""
}
|
q27104
|
Metro.Scenes.all_scenes_for
|
test
|
def all_scenes_for(scenes)
Array(scenes).map do |scene_class_name|
scene = scene_class_name.constantize
[ scene ] + all_scenes_for(scene.scenes)
end.flatten.compact
end
|
ruby
|
{
"resource": ""
}
|
q27105
|
Metro.Scene.actor
|
test
|
def actor(actor_or_actor_name)
if actor_or_actor_name.is_a? String or actor_or_actor_name.is_a? Symbol
send(actor_or_actor_name)
else
actor_or_actor_name
end
end
|
ruby
|
{
"resource": ""
}
|
q27106
|
Metro.Scene.notification
|
test
|
def notification(event,sender=nil)
sender = sender || UnknownSender
state.fire_events_for_notification(event,sender)
end
|
ruby
|
{
"resource": ""
}
|
q27107
|
Metro.Scene.after
|
test
|
def after(ticks,&block)
tick = OnUpdateOperation.new interval: ticks, context: self
tick.on_complete(&block)
enqueue tick
end
|
ruby
|
{
"resource": ""
}
|
q27108
|
Metro.Scene.add_actors_to_scene
|
test
|
def add_actors_to_scene
self.class.actors.each do |scene_actor|
actor_instance = scene_actor.create
actor_instance.scene = self
send "#{scene_actor.name}=", actor_instance
end
end
|
ruby
|
{
"resource": ""
}
|
q27109
|
Metro.Scene.register_animations!
|
test
|
def register_animations!
self.class.animations.each do |animation|
animate animation.actor, animation.options, &animation.on_complete_block
end
end
|
ruby
|
{
"resource": ""
}
|
q27110
|
Metro.Scene.register_actor
|
test
|
def register_actor(actor_factory)
registering_actor = actor(actor_factory.name)
registering_actor.window = window
registering_actor.show
drawers.push(registering_actor)
updaters.push(registering_actor)
register_events_for_target(registering_actor,registering_actor.class.events)
end
|
ruby
|
{
"resource": ""
}
|
q27111
|
Metro.Scene.base_update
|
test
|
def base_update
updaters.each { |updater| updater.update }
update
updaters.reject! { |updater| updater.update_completed? }
end
|
ruby
|
{
"resource": ""
}
|
q27112
|
Metro.Scene.base_draw
|
test
|
def base_draw
drawers.each { |drawer| drawer.draw }
draw
drawers.reject! { |drawer| drawer.draw_completed? }
end
|
ruby
|
{
"resource": ""
}
|
q27113
|
Metro.Scene.transition_to
|
test
|
def transition_to(scene_or_scene_name,options = {})
new_scene = Scenes.generate(scene_or_scene_name,options)
_prepare_transition(new_scene)
window.scene = new_scene
end
|
ruby
|
{
"resource": ""
}
|
q27114
|
Metro.Scene._prepare_transition
|
test
|
def _prepare_transition(new_scene)
log.debug "Preparing to transition from scene #{self} to #{new_scene}"
new_scene.class.actors.find_all {|actor_factory| actor_factory.load_from_previous_scene? }.each do |actor_factory|
new_actor = new_scene.actor(actor_factory.name)
current_actor = actor(actor_factory.name)
new_actor._load current_actor._save
end
prepare_transition_to(new_scene)
new_scene.prepare_transition_from(self)
end
|
ruby
|
{
"resource": ""
}
|
q27115
|
Metro.Scene.to_hash
|
test
|
def to_hash
drawn = drawers.find_all{|draw| draw.saveable_to_view }.inject({}) do |hash,drawer|
drawer_hash = drawer.to_hash
hash.merge drawer_hash
end
drawn
end
|
ruby
|
{
"resource": ""
}
|
q27116
|
Metro.Model.create
|
test
|
def create(model_name,options={})
# @TODO: this is another path that parallels the ModelFactory
model_class = Metro::Models.find(model_name)
mc = model_class.new options
mc.scene = scene
mc.window = window
mc
end
|
ruby
|
{
"resource": ""
}
|
q27117
|
Metro.Model._load
|
test
|
def _load(options = {})
# Clean up and symbolize all the keys then merge that with the existing properties
options.keys.each do |key|
property_name = key.to_s.underscore.to_sym
if respond_to? "#{property_name}="
send("#{property_name}=",options.delete(key))
else
options[property_name] = options.delete(key)
end
end
properties.merge! options
end
|
ruby
|
{
"resource": ""
}
|
q27118
|
WithingsSDK.Client.activities
|
test
|
def activities(user_id, options = {})
perform_request(:get, '/v2/measure', WithingsSDK::Activity, 'activities', {
action: 'getactivity',
userid: user_id
}.merge(options))
end
|
ruby
|
{
"resource": ""
}
|
q27119
|
WithingsSDK.Client.body_measurements
|
test
|
def body_measurements(user_id, options = {})
perform_request(:get, '/measure', WithingsSDK::MeasurementGroup, 'measuregrps', {
action: 'getmeas',
userid: user_id
}.merge(options))
end
|
ruby
|
{
"resource": ""
}
|
q27120
|
WithingsSDK.Client.weight
|
test
|
def weight(user_id, options = {})
groups = body_measurements(user_id, options)
groups.map do |group|
group.measures.select { |m| m.is_a? WithingsSDK::Measure::Weight }.map do |m|
WithingsSDK::Measure::Weight.new(m.attrs.merge('weighed_at' => group.date))
end
end.flatten
end
|
ruby
|
{
"resource": ""
}
|
q27121
|
WithingsSDK.Client.sleep_series
|
test
|
def sleep_series(user_id, options = {})
perform_request(:get, '/v2/sleep', WithingsSDK::SleepSeries, 'series', {
action: 'get',
userid: user_id
}.merge(options))
end
|
ruby
|
{
"resource": ""
}
|
q27122
|
WithingsSDK.Client.perform_request
|
test
|
def perform_request(http_method, path, klass, key, options = {})
if @consumer_key.nil? || @consumer_secret.nil?
raise WithingsSDK::Error::ClientConfigurationError, "Missing consumer_key or consumer_secret"
end
options = WithingsSDK::Utils.normalize_date_params(options)
request = WithingsSDK::HTTP::Request.new(@access_token, { 'User-Agent' => user_agent })
response = request.send(http_method, path, options)
if key.nil?
klass.new(response)
elsif response.has_key? key
response[key].collect do |element|
klass.new(element)
end
else
[klass.new(response)]
end
end
|
ruby
|
{
"resource": ""
}
|
q27123
|
CarrierWave.Magic.set_magic_content_type
|
test
|
def set_magic_content_type(override=false)
if override || file.content_type.blank? || generic_content_type?(file.content_type)
new_content_type = ::FileMagic.new(::FileMagic::MAGIC_MIME).file( file.path ).split(';').first
if file.respond_to?(:content_type=)
file.content_type = new_content_type
else
file.instance_variable_set(:@content_type, new_content_type)
end
end
rescue ::Exception => e
raise CarrierWave::ProcessingError, I18n.translate(:"errors.messages.magic_mime_types_processing_error", e: e, default: 'Failed to process file with FileMagic, Original Error: %{e}')
end
|
ruby
|
{
"resource": ""
}
|
q27124
|
RabbitMQ.Client.send_request
|
test
|
def send_request(channel_id, method, properties={})
Util.error_check :"sending a request",
@conn.send_method(Integer(channel_id), method.to_sym, properties)
nil
end
|
ruby
|
{
"resource": ""
}
|
q27125
|
RabbitMQ.Client.fetch_response
|
test
|
def fetch_response(channel_id, method, timeout: protocol_timeout)
methods = Array(method).map(&:to_sym)
timeout = Float(timeout) if timeout
fetch_response_internal(Integer(channel_id), methods, timeout)
end
|
ruby
|
{
"resource": ""
}
|
q27126
|
RabbitMQ.Client.on_event
|
test
|
def on_event(channel_id, method, callable=nil, &block)
handler = block || callable
raise ArgumentError, "expected block or callable as the event handler" \
unless handler.respond_to?(:call)
@event_handlers[Integer(channel_id)][method.to_sym] = handler
handler
end
|
ruby
|
{
"resource": ""
}
|
q27127
|
GtfsReader.SourceUpdater.download_source
|
test
|
def download_source
Log.debug { " Reading #{@source.url.green}" }
zip = Tempfile.new('gtfs')
zip.binmode
zip << open(@source.url).read
zip.rewind
extract_to_tempfiles(zip)
Log.debug { "Finished reading #{@source.url.green}" }
rescue StandardException => e
Log.error(e.message)
raise e
ensure
zip.try(:close)
end
|
ruby
|
{
"resource": ""
}
|
q27128
|
GtfsReader.SourceUpdater.check_files
|
test
|
def check_files
@found_files = []
check_required_files
check_optional_files
# Add feed files of zip to the list of files to be processed
@source.feed_definition.files.each do |req|
@found_files << req if filenames.include?(req.filename)
end
end
|
ruby
|
{
"resource": ""
}
|
q27129
|
GtfsReader.SourceUpdater.check_columns
|
test
|
def check_columns
@found_files.each do |file|
@temp_files[file.filename].open do |data|
FileReader.new(data, file, validate: true)
end
end
end
|
ruby
|
{
"resource": ""
}
|
q27130
|
GtfsReader.SourceUpdater.fetch_http_fallback_identifier
|
test
|
def fetch_http_fallback_identifier(head_request)
if head_request.key?('last-modified')
head_request['last-modified']
elsif head_request.key?('content-length')
head_request['content-length']
else
Time.now.to_s
end
end
|
ruby
|
{
"resource": ""
}
|
q27131
|
GtfsReader.Configuration.parameter
|
test
|
def parameter(*names)
names.each do |name|
define_singleton_method(name) do |*values|
if (value = values.first)
instance_variable_set("@#{name}", value)
else
instance_variable_get("@#{name}")
end
end
end
end
|
ruby
|
{
"resource": ""
}
|
q27132
|
GtfsReader.FileReader.find_columns
|
test
|
def find_columns(validate)
@found_columns = []
prefix = "#{filename.yellow}:"
required = @definition.required_columns
unless required.empty?
Log.info { "#{prefix} #{'required columns'.magenta}" } if validate
missing = check_columns(validate, prefix, required, :green, :red)
raise RequiredColumnsMissing, missing if validate && missing.present?
end
optional = @definition.optional_columns
unless optional.empty?
Log.info { "#{prefix} #{'optional columns'.cyan}" } if validate
check_columns(validate, prefix, optional, :cyan, :light_yellow)
end
cols = @definition.columns.collect(&:name)
headers = @csv_headers.select { |h| cols.include?(h) }
@col_names ||= @found_columns.map(&:name)
::Hash[*headers.inject([]) { |list, c| list << c << @definition[c] }]
end
|
ruby
|
{
"resource": ""
}
|
q27133
|
Nidyx.Mapper.map
|
test
|
def map(models, options)
models = models.values
case options[:platform].downcase
when "objc", "obj-c", "objective-c"
Nidyx::ObjCMapper.map(models, options)
end
end
|
ruby
|
{
"resource": ""
}
|
q27134
|
Nidyx.Parser.generate
|
test
|
def generate(path, name)
object = get_object(path)
type = object[TYPE_KEY]
if type == OBJECT_TYPE
generate_object(path, name)
elsif type == ARRAY_TYPE
generate_top_level_array(path)
elsif type.is_a?(Array)
if type.include?(OBJECT_TYPE)
raise UnsupportedSchemaError if type.include?(ARRAY_TYPE)
generate_object(path, name)
elsif type.include?(ARRAY_TYPE)
generate_top_leve_array(path)
else raise UnsupportedSchemaError; end
else raise UnsupportedSchemaError; end
end
|
ruby
|
{
"resource": ""
}
|
q27135
|
Nidyx.Parser.resolve_array_refs
|
test
|
def resolve_array_refs(obj)
items = obj[ITEMS_KEY]
case items
when Array
return resolve_items_array(items)
when Hash
# handle a nested any of key
any_of = items[ANY_OF_KEY]
return resolve_items_array(any_of) if any_of.is_a?(Array)
resolve_reference_string(items[REF_KEY])
return [class_name_from_ref(items[REF_KEY])].compact
else
return []
end
end
|
ruby
|
{
"resource": ""
}
|
q27136
|
Nidyx.Generator.run
|
test
|
def run(schema_path, options)
schema = Nidyx::Reader.read(schema_path)
raw_models = Nidyx::Parser.parse(schema, options)
models = Nidyx::Mapper.map(raw_models, options)
Nidyx::Output.write(models, options[:output_directory])
end
|
ruby
|
{
"resource": ""
}
|
q27137
|
Nidyx.Reader.read
|
test
|
def read(path)
schema = nil
begin
# TODO: validate this is legitimate JSON Schema
schema = JSON.parse(IO.read(path))
raise EmptySchemaError if empty_schema?(schema)
rescue JSON::JSONError => e
puts "Encountered an error reading JSON from #{path}"
puts e.message
exit 1
rescue EmptySchemaError
puts "Schema read from #{path} is empty"
exit 1
rescue StandardError => e
puts e.message
exit 1
end
schema
end
|
ruby
|
{
"resource": ""
}
|
q27138
|
Wxpay.Sign.sign_package
|
test
|
def sign_package params
params_str = create_sign_str params
if params_str =~ /trade_type=APP/
key = Wxpay.app_api_key
else
key = Wxpay.api_key
end
Digest::MD5.hexdigest(params_str+"&key=#{key}").upcase
end
|
ruby
|
{
"resource": ""
}
|
q27139
|
Webspicy.Scope._each_resource_file
|
test
|
def _each_resource_file(config)
folder = config.folder
folder.glob("**/*.yml").select(&to_filter_proc(config.file_filter)).each do |file|
yield file, folder
end
end
|
ruby
|
{
"resource": ""
}
|
q27140
|
Webspicy.Scope.each_resource
|
test
|
def each_resource(&bl)
return enum_for(:each_resource) unless block_given?
each_resource_file do |file, folder|
yield Webspicy.resource(file.load, file, self)
end
end
|
ruby
|
{
"resource": ""
}
|
q27141
|
Webspicy.Scope.to_real_url
|
test
|
def to_real_url(url, test_case = nil, &bl)
case config.host
when Proc
config.host.call(url, test_case)
when String
url =~ /^http/ ? url : "#{config.host}#{url}"
else
return url if url =~ /^http/
return yield(url) if block_given?
raise "Unable to resolve `#{url}` : no host resolver provided\nSee `Configuration#host="
end
end
|
ruby
|
{
"resource": ""
}
|
q27142
|
Webspicy.Scope.to_filter_proc
|
test
|
def to_filter_proc(filter)
case ff = filter
when NilClass then ->(f){ true }
when Proc then ff
when Regexp then ->(f){ ff =~ f.to_s }
else
->(f){ ff === f }
end
end
|
ruby
|
{
"resource": ""
}
|
q27143
|
Webspicy.Configuration.folder
|
test
|
def folder(folder = nil, &bl)
if folder.nil?
@folder
else
folder = folder.is_a?(String) ? @folder/folder : Path(folder)
raise "Folder `#{folder}` does not exists" unless folder.exists? && folder.directory?
raise "Folder must be a descendant" unless folder.inside?(@folder)
child = dup do |c|
c.parent = self
c.folder = folder
end
yield(child) if block_given?
@children << child
child
end
end
|
ruby
|
{
"resource": ""
}
|
q27144
|
Webspicy.Configuration.data_system
|
test
|
def data_system
schema = self.folder/"schema.fio"
if schema.file?
Finitio::DEFAULT_SYSTEM.parse(schema.read)
elsif not(self.parent.nil?)
self.parent.data_system
else
Finitio::DEFAULT_SYSTEM
end
end
|
ruby
|
{
"resource": ""
}
|
q27145
|
Exodus.Migration.run
|
test
|
def run(direction)
self.status.direction = direction
# reset the status if the job is rerunnable and has already be completed
self.status.reset! if self.class.rerunnable_safe? && completed?(direction)
self.status.execution_time = time_it { self.send(direction) }
self.status.last_succesful_completion = Time.now
end
|
ruby
|
{
"resource": ""
}
|
q27146
|
Exodus.Migration.failure=
|
test
|
def failure=(exception)
self.status.error = MigrationError.new(
:error_message => exception.message,
:error_class => exception.class,
:error_backtrace => exception.backtrace)
end
|
ruby
|
{
"resource": ""
}
|
q27147
|
Exodus.Migration.is_runnable?
|
test
|
def is_runnable?(direction)
self.class.rerunnable_safe? ||
(direction == UP && status.current_status < status_complete) ||
(direction == DOWN && status.current_status > 0)
end
|
ruby
|
{
"resource": ""
}
|
q27148
|
Exodus.Migration.completed?
|
test
|
def completed?(direction)
return false if self.status.execution_time == 0
(direction == UP && self.status.current_status == self.status_complete) ||
(direction == DOWN && self.status.current_status == 0)
end
|
ruby
|
{
"resource": ""
}
|
q27149
|
Exodus.Migration.step
|
test
|
def step(step_message = nil, step_status = 1)
unless status.status_processed?(status.direction, step_status)
self.status.message = step_message
puts "\t #{step_message}"
yield if block_given?
self.status.current_status += status.direction_to_i
end
end
|
ruby
|
{
"resource": ""
}
|
q27150
|
Exodus.Migration.time_it
|
test
|
def time_it
puts "Running #{self.class}[#{self.status.arguments}](#{self.status.direction})"
start = Time.now
yield if block_given?
end_time = Time.now - start
puts "Tasks #{self.class} executed in #{end_time} seconds. \n\n"
end_time
end
|
ruby
|
{
"resource": ""
}
|
q27151
|
Exodus.TextFormatter.super_print
|
test
|
def super_print(paragraphes, space_number = 50, title = true)
puts format_paragraph(space_number, title, *paragraphes)
end
|
ruby
|
{
"resource": ""
}
|
q27152
|
Gridify.Grid.columns_hash
|
test
|
def columns_hash
colModel.inject({}) { |h, col| h[col.name] = col; h }
end
|
ruby
|
{
"resource": ""
}
|
q27153
|
Amber.Site.render
|
test
|
def render
@page_list.each do |page|
page.render_to_file(@config.dest_dir)
putc '.'; $stdout.flush
end
@dir_list.each do |directory|
src = File.join(@config.pages_dir, directory)
dst = File.join(@config.dest_dir, directory)
Render::Asset.render_dir(src, dst)
putc '.'; $stdout.flush
end
if @config.short_paths
render_short_path_symlinks
end
Render::Apache.write_htaccess(@config, @config.pages_dir, @config.dest_dir)
puts
end
|
ruby
|
{
"resource": ""
}
|
q27154
|
Amber.Site.add_page
|
test
|
def add_page(page)
@pages_by_name[page.name] ||= page
@pages_by_path[page.path.join('/')] = page
add_aliases(I18n.default_locale, page, @pages_by_path)
page.locales.each do |locale|
next if locale == I18n.default_locale
add_aliases(locale, page, @pages_by_locale_path[locale])
end
@page_list << page
end
|
ruby
|
{
"resource": ""
}
|
q27155
|
Amber.Site.add_aliases
|
test
|
def add_aliases(locale, page, path_hash)
page.aliases(locale).each do |alias_path|
alias_path_str = alias_path.join('/')
if path_hash[alias_path_str]
Amber.logger.warn "WARNING: page `#{page.path.join('/')}` has alias `#{alias_path_str}`, but this path is already taken by `#{path_hash[alias_path_str].path.join('/')}` (locale = #{locale})."
else
path_hash[alias_path_str] = page
end
end
end
|
ruby
|
{
"resource": ""
}
|
q27156
|
Amber.StaticPage.parse_headers
|
test
|
def parse_headers(content_file)
headers = []
para1 = []
para2 = []
file_type = type_from_path(content_file)
File.open(content_file, :encoding => 'UTF-8') do |f|
while (line = f.gets) =~ /^(- |)@\w/
if line !~ /^-/
line = '- ' + line
end
headers << line
end
# eat empty lines
while line = f.gets
break unless line =~ /^\s*$/
end
# grab first two paragraphs
para1 << line
while line = f.gets
break if line =~ /^\s*$/
para1 << line
end
while line = f.gets
break if line =~ /^\s*$/
para2 << line
end
end
headers = headers.join
para1 = para1.join
para2 = para2.join
excerpt = ""
# pick the first non-heading paragraph.
# this is stupid, and chokes on nested headings.
# but is also cheap and fast :)
if file_type == :textile
if para1 =~ /^h[1-5]\. /
excerpt = para2
else
excerpt = para1
end
elsif file_type == :markdown
if para1 =~ /^#+ / || para1 =~ /^(===+|---+)\s*$/m
excerpt = para2
else
excerpt = para1
end
end
return [headers, excerpt]
end
|
ruby
|
{
"resource": ""
}
|
q27157
|
Amber.StaticPage.variable_files
|
test
|
def variable_files
if @simple_page
directory = File.dirname(@file_path)
regexp = SIMPLE_VAR_MATCH_RE.call(@name)
else
directory = @file_path
regexp = VAR_FILE_MATCH_RE
end
hsh = {}
Dir.foreach(directory) do |file|
if file && match = regexp.match(file)
locale = match['locale'] || I18n.default_locale
hsh[locale.to_sym] = File.join(directory, file)
end
end
hsh
end
|
ruby
|
{
"resource": ""
}
|
q27158
|
Amber.Menu.last_menu_at_depth
|
test
|
def last_menu_at_depth(depth)
menu = self
depth.times { menu = menu.children.last }
menu
end
|
ruby
|
{
"resource": ""
}
|
q27159
|
Amber::Render.TableOfContents.nameize
|
test
|
def nameize(str)
str = str.dup
str.gsub!(/&(\w{2,6}?|#[0-9A-Fa-f]{2,6});/,'') # remove html entitities
str.gsub!(/[^- [[:word:]]]/u, '') # remove non-word characters (using unicode definition of a word char)
str.strip!
str.downcase! # upper case characters in urls are confusing
str.gsub!(/\ +/u, '-') # spaces to dashes, preferred separator char everywhere
CGI.escape(str)
end
|
ruby
|
{
"resource": ""
}
|
q27160
|
Amber::Render.TableOfContents.strip_html_tags
|
test
|
def strip_html_tags(html)
Nokogiri::HTML::DocumentFragment.parse(html, 'UTF-8').children.collect{|child| child.inner_text}.join
end
|
ruby
|
{
"resource": ""
}
|
q27161
|
Amber::Render.TocItem.populate_node
|
test
|
def populate_node(node, options)
@children.each do |item|
li = node.document.create_element("li")
li.add_child(li.document.create_element("a", item.text, :href => "#{options[:href_base]}##{item.anchor}"))
if item.children.any?
ul = li.document.create_element(options[:tag])
item.populate_node(ul, options)
li.add_child(ul)
end
node.add_child(li)
end
end
|
ruby
|
{
"resource": ""
}
|
q27162
|
Amber::Render.TocItem.to_html
|
test
|
def to_html(options={})
html = []
tag = options[:tag]
indent = options[:indent] || 0
str = options[:indent_str] || " "
html << '%s<%s>' % [(str*indent), tag]
@children.each do |item|
html << '%s<li>' % (str*(indent+1))
html << '%s<a href="%s#%s">%s</a>' % [str*(indent+2), options[:href_base], item.anchor, item.text]
if item.children.any?
html << item.to_html({
:indent => indent+2,
:indent_str => str,
:tag => tag,
:href_base => options[:href_base]
})
end
html << '%s</li>' % (str*(indent+1))
end
html << '%s</%s>' % [(str*indent), tag]
html.join("\n")
end
|
ruby
|
{
"resource": ""
}
|
q27163
|
Amber::Render.TocItem.parent_for
|
test
|
def parent_for(heading)
heading = heading[1].to_i if heading.is_a?(String)
if children.any? && children.last.level < heading
children.last.parent_for(heading)
else
self
end
end
|
ruby
|
{
"resource": ""
}
|
q27164
|
Eve.JavascriptHelper.type_id
|
test
|
def type_id(which)
which = which.to_s.humanize unless which.kind_of?(String)
which.downcase!
case which
when 'alliance' then 16159
when 'character' then 1377
when 'corporation' then 2
when 'constellation' then 4
when 'region' then 3
when 'solar system', 'solarsystem' then 5
when 'station' then 3867
else raise ArgumentError, "Unknown type: #{which}"
end
end
|
ruby
|
{
"resource": ""
}
|
q27165
|
Eve.JavascriptHelper.link_to_info
|
test
|
def link_to_info(text, type_id, item_id = nil, *args)
function = "CCPEVE.showInfo(#{type_id.inspect}"
function.concat ", #{item_id.inspect}" if item_id
function.concat ")"
link_to_function text, function, *args
end
|
ruby
|
{
"resource": ""
}
|
q27166
|
Eve.JavascriptHelper.link_to_route
|
test
|
def link_to_route(text, destination_id, source_id = nil, *args)
function = "CCPEVE.showRouteTo(#{destination_id.inspect}"
function.concat ", #{source_id.inspect}" if source_id
function.concat ")"
link_to_function text, function, *args
end
|
ruby
|
{
"resource": ""
}
|
q27167
|
Eve.JavascriptHelper.link_to_trust_request
|
test
|
def link_to_trust_request(text, trust_url = "http://#{request.host}/", *args)
trust_url = url_for(trust_url.merge(:only_path => false)) if trust_url.kind_of?(Hash)
link_to_function text, "CCPEVE.requestTrust(#{trust_url.inspect})", *args
end
|
ruby
|
{
"resource": ""
}
|
q27168
|
Eve.JavascriptHelper.request_trust
|
test
|
def request_trust(trust_url = "http://#{request.host}/", *args)
trust_url = url_for(trust_url.merge(:only_path => false)) if trust_url.kind_of?(Hash)
javascript_tag "CCPEVE.requestTrust(#{trust_url.inspect});", *args
end
|
ruby
|
{
"resource": ""
}
|
q27169
|
Amber.StaticPage.render_to_file
|
test
|
def render_to_file(dest_dir, options={})
render_content_files(dest_dir, options)
render_assets(dest_dir)
@props.locales.each do |locale|
if aliases(locale).any?
link_page_aliases(dest_dir, aliases(locale), locale)
end
end
end
|
ruby
|
{
"resource": ""
}
|
q27170
|
Amber.StaticPage.symlink
|
test
|
def symlink(from_path, to_path)
to_path = realpath(to_path)
target = from_path.relative_path_from(to_path).to_s.sub(/^\.\.\//, '')
if !to_path.dirname.directory?
Amber.logger.warn { "On page `#{@file_path}`, the parent directories for alias name `#{to_path}` don't exist. Skipping alias." }
return
end
if to_path.exist? && to_path.symlink?
File.unlink(to_path)
end
if !to_path.exist?
Amber.logger.debug { "Symlink #{to_path} => #{target}" }
FileUtils.ln_s(target, to_path)
end
end
|
ruby
|
{
"resource": ""
}
|
q27171
|
Amber.StaticPage.render_content_files
|
test
|
def render_content_files(dest_dir, options)
view = Render::View.new(self, @config)
@config.locales.each do |file_locale|
content_file = content_file(file_locale)
next unless content_file
dest = destination_file(dest_dir, file_locale)
unless Dir.exist?(File.dirname(dest))
FileUtils.mkdir_p(File.dirname(dest))
end
if options[:force] || !File.exist?(dest) || File.mtime(content_file) > File.mtime(dest)
File.open(dest, 'w') do |f|
layout = @props.layout || 'default'
f.write view.render({page: self, layout: layout}, {locale: file_locale})
end
end
end
end
|
ruby
|
{
"resource": ""
}
|
q27172
|
Snoo.User.friend
|
test
|
def friend name, friend_id, note = nil
friend_wrapper(api_name = name, api_container = @userid, api_note = note, api_type = "friend")
end
|
ruby
|
{
"resource": ""
}
|
q27173
|
Snoo.User.get_user_listing
|
test
|
def get_user_listing username, opts = {}
opts[:type] = 'overview' if opts[:type].nil?
url = "/user/%s%s.json" % [username, ('/' + opts[:type] if opts[:type] != 'overview')]
opts.delete :type
query = opts
get(url, query: query)
end
|
ruby
|
{
"resource": ""
}
|
q27174
|
Snoo.LinksComments.comment
|
test
|
def comment text, id
logged_in?
post('/api/comment', body: { text: text, thing_id: id, uh: @modhash, api_type: 'json'})
end
|
ruby
|
{
"resource": ""
}
|
q27175
|
Snoo.LinksComments.submit
|
test
|
def submit title, subreddit, opts = {}
logged_in?
post = {
title: title,
sr: subreddit,
uh: @modhash,
kind: (opts[:url] ? "link" : "self"),
api_type: 'json'
}
post.merge! opts
post('/api/submit', body: post)
end
|
ruby
|
{
"resource": ""
}
|
q27176
|
Snoo.LinksComments.vote
|
test
|
def vote direction, id
logged_in?
post('/api/vote', body: {id: id, dir: direction, uh: @modhash, api_type: 'json'})
end
|
ruby
|
{
"resource": ""
}
|
q27177
|
Gotcha.Base.correct?
|
test
|
def correct?(str)
str = str.is_a?(String) ? str : str.to_s
str == (@answer.is_a?(String) ? @answer : @answer.to_s) # don't change @answer type
end
|
ruby
|
{
"resource": ""
}
|
q27178
|
Gotcha.FormHelpers.gotcha
|
test
|
def gotcha(options = {})
options[:label_options] ||= {}
options[:text_field_options] ||= {}
if gotcha = Gotcha.random
field = "gotcha_response[#{gotcha.class.name.to_s}-#{Digest::MD5.hexdigest(gotcha.class.down_transform(gotcha.answer))}]"
(label_tag field, gotcha.question, options[:label_options]) + "\n" + (text_field_tag field, nil, options[:text_field_options])
else
raise "No Gotchas Installed"
end
end
|
ruby
|
{
"resource": ""
}
|
q27179
|
Snoo.Subreddit.delete_image
|
test
|
def delete_image subreddit, image_name
logged_in?
post('/api/delete_sr_image', body: {r: subreddit, img_name: image_name, uh: @modhash, api_type: 'json'})
end
|
ruby
|
{
"resource": ""
}
|
q27180
|
Snoo.Subreddit.set_stylesheet
|
test
|
def set_stylesheet stylesheet, subreddit
logged_in?
post('/api/subreddit_stylesheet', body: {op: 'save', r: subreddit, stylesheet_contents: stylesheet, uh: @modhash, api_type: 'json'})
end
|
ruby
|
{
"resource": ""
}
|
q27181
|
Snoo.Subreddit.subscribe
|
test
|
def subscribe subreddit, action = "sub"
logged_in?
post('/api/subscribe', body: {action: action, sr: subreddit, uh: @modhash, api_type: 'json'})
end
|
ruby
|
{
"resource": ""
}
|
q27182
|
Snoo.Subreddit.my_reddits
|
test
|
def my_reddits opts = {}
logged_in?
url = "/reddits/mine/%s.json" % (opts[:condition] if opts[:condition])
opts.delete :condition
query = opts
get(url, query: query)
end
|
ruby
|
{
"resource": ""
}
|
q27183
|
Snoo.Subreddit.get_reddits
|
test
|
def get_reddits opts = {}
url = "/reddits/%s.json" % (opts[:condition] if opts[:condition])
opts.delete :condition
query = opts
get(url, query: query)
end
|
ruby
|
{
"resource": ""
}
|
q27184
|
Snoo.Subreddit.add_moderator
|
test
|
def add_moderator container, user, subreddit
friend_wrapper container: container, name: user, r: subreddit, type: "moderator"
end
|
ruby
|
{
"resource": ""
}
|
q27185
|
Snoo.Subreddit.add_contributor
|
test
|
def add_contributor container, user, subreddit
friend_wrapper container: container, name: user, r: subreddit, type: "contributor"
end
|
ruby
|
{
"resource": ""
}
|
q27186
|
Snoo.Subreddit.ban_user
|
test
|
def ban_user container, user, subreddit
friend_wrapper container: container, name: user, r: subreddit, type: "banned"
end
|
ruby
|
{
"resource": ""
}
|
q27187
|
Snoo.Subreddit.remove_moderator
|
test
|
def remove_moderator container, user, subreddit
unfriend_wrapper container: container, name: user, r: subreddit, type: "moderator"
end
|
ruby
|
{
"resource": ""
}
|
q27188
|
Snoo.Subreddit.remove_contributor
|
test
|
def remove_contributor container, user, subreddit
unfriend_wrapper container: container, name: user, r: subreddit, type: "contributor"
end
|
ruby
|
{
"resource": ""
}
|
q27189
|
Snoo.Subreddit.unban_user
|
test
|
def unban_user container, user, subreddit
unfriend_wrapper container: container, name: user, r: subreddit, type: "banned"
end
|
ruby
|
{
"resource": ""
}
|
q27190
|
Snoo.Utilities.get
|
test
|
def get *args, &block
response = self.class.get *args, &block
raise WebserverError, response.code unless response.code == 200
response
end
|
ruby
|
{
"resource": ""
}
|
q27191
|
Snoo.Account.log_in
|
test
|
def log_in username, password
login = post("/api/login", :body => {user: username, passwd: password, api_type: 'json'})
errors = login['json']['errors']
raise errors[0][1] unless errors.size == 0
set_cookies login.headers['set-cookie']
@modhash = login['json']['data']['modhash']
@username = username
@userid = 't2_' + get('/api/me.json')['data']['id']
return login
end
|
ruby
|
{
"resource": ""
}
|
q27192
|
Snoo.Account.auth
|
test
|
def auth modhash, cookies
set_cookies cookies
@modhash = modhash
meinfo = get("/api/me.json")
@username = meinfo['data']['name']
@userid = 't2_' + meinfo['data']['id']
end
|
ruby
|
{
"resource": ""
}
|
q27193
|
Snoo.Account.delete_user
|
test
|
def delete_user password, reason = "deleted by script command"
logged_in?
delete = post('/api/delete_user', body: {
confirm: true,
delete_message: reason,
passwd: password,
uh: @modhash,
user: @username,
api_type: 'json'
})
return delete
end
|
ruby
|
{
"resource": ""
}
|
q27194
|
Snoo.PM.get_messages
|
test
|
def get_messages where = "inbox", opts = {}
query = {
mark: false
}
query.merge! opts
get("/message/#{where}.json", query: query)
end
|
ruby
|
{
"resource": ""
}
|
q27195
|
Snoo.Flair.clear_flair_templates
|
test
|
def clear_flair_templates type, subreddit
logged_in?
post('/api/clearflairtemplates', body: { flair_type: type, r: subreddit, uh: @modhash, api_type: 'json'})
end
|
ruby
|
{
"resource": ""
}
|
q27196
|
Snoo.Flair.delete_user_flair
|
test
|
def delete_user_flair user, subreddit
logged_in?
post('/api/deleteflair', body: {name: user, r: subreddit, uh: @modhash, api_type: 'json'})
end
|
ruby
|
{
"resource": ""
}
|
q27197
|
Snoo.Flair.delete_flair_template
|
test
|
def delete_flair_template id, subreddit
logged_in?
post('/api/deleteflairtemplate', body: {flair_template_id: id, r: subreddit, uh: @modhash, api_type: 'json'})
end
|
ruby
|
{
"resource": ""
}
|
q27198
|
Snoo.Flair.flair_config
|
test
|
def flair_config subreddit, opts = {}
logged_in?
options = {
flair_enabled: true,
flair_position: 'right',
flair_self_assign_enabled: false,
link_flair_position: 'right',
link_flair_self_assign_enabled: false,
uh: @modhash,
r: subreddit,
api_type: 'json'
}
options.merge! opts
post('/api/flairconfig', body: options)
end
|
ruby
|
{
"resource": ""
}
|
q27199
|
Snoo.Flair.flair_csv
|
test
|
def flair_csv csv, subreddit
logged_in?
post('/api/flaircsv.json', body: {flair_csv: csv, r: subreddit, uh: @modhash})
end
|
ruby
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.