_id
stringlengths 2
6
| title
stringlengths 9
130
| partition
stringclasses 3
values | text
stringlengths 30
4.3k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q24700
|
RWebSpec.Driver.attach_browser
|
train
|
def attach_browser(how, what, options = {})
options.merge!(:browser => is_firefox? ? "Firefox" : "IE") unless options[:browser]
begin
options.merge!(:base_url => browser.context.base_url)
rescue
|
ruby
|
{
"resource": ""
}
|
q24701
|
RWebSpec.Driver.enter_text_with_id
|
train
|
def enter_text_with_id(textfield_id, value, opts = {})
# For IE10, it seems unable to identify HTML5 elements
#
# However for IE10, the '.' is omitted.
if opts.nil? || opts.empty?
# for Watir, default is clear
opts[:appending] = false
end
perform_operation {
begin
text_field(:id, textfield_id).set(value)
rescue => e
# However, this approach is not reliable with Watir (IE)
# for
|
ruby
|
{
"resource": ""
}
|
q24702
|
RWebSpec.Driver.absolutize_page
|
train
|
def absolutize_page(content, base_url, current_url_parent)
modified_content = ""
content.each_line do |line|
if line =~ /<script\s+.*src=["'']?(.*)["'].*/i then
script_src = $1
substitute_relative_path_in_src_line(line, script_src, base_url, current_url_parent)
elsif line =~ /<link\s+.*href=["'']?(.*)["'].*/i then
link_href = $1
|
ruby
|
{
"resource": ""
}
|
q24703
|
RWebSpec.Driver.absolutize_page_hpricot
|
train
|
def absolutize_page_hpricot(content, base_url, parent_url)
return absolutize_page(content, base_url, parent_url) if RUBY_PLATFORM == 'java'
begin
require 'hpricot'
doc = Hpricot(content)
base_url.slice!(-1) if ends_with?(base_url, "/")
(doc/'link').each { |e| e['href'] = absolutify_url(e['href'], base_url, parent_url) || "" }
(doc/'img').each { |e| e['src'] = absolutify_url(e['src'], base_url, parent_url) || "" }
|
ruby
|
{
"resource": ""
}
|
q24704
|
RWebSpec.Driver.wait_for_element
|
train
|
def wait_for_element(element_id, timeout = $testwise_polling_timeout, interval = $testwise_polling_interval)
start_time = Time.now
#TODO might not work with Firefox
|
ruby
|
{
"resource": ""
}
|
q24705
|
RWebSpec.Driver.clear_popup
|
train
|
def clear_popup(popup_win_title, seconds = 10, yes = true)
# commonly "Security Alert", "Security Information"
if is_windows?
sleep 1
autoit = WIN32OLE.new('AutoItX3.Control')
# Look for window with given title. Give up after 1 second.
ret = autoit.WinWait(popup_win_title, '', seconds)
|
ruby
|
{
"resource": ""
}
|
q24706
|
RWebSpec.Driver.basic_authentication_ie
|
train
|
def basic_authentication_ie(title, username, password, options = {})
default_options = {:textctrl_username => "Edit2",
:textctrl_password => "Edit3",
:button_ok => 'Button1'
}
options = default_options.merge(options)
title ||= ""
if title =~ /^Connect\sto/
full_title = title
else
full_title = "Connect to #{title}"
end
require 'rformspec'
|
ruby
|
{
"resource": ""
}
|
q24707
|
MetaPresenter.Helpers.presenter
|
train
|
def presenter
@presenter ||= begin
controller = self
klass = MetaPresenter::Builder.new(controller,
|
ruby
|
{
"resource": ""
}
|
q24708
|
DataSift.AccountIdentityToken.create
|
train
|
def create(identity_id = '', service = '', token = '')
fail BadParametersError, 'identity_id is required' if identity_id.empty?
fail BadParametersError, 'service is required' if
|
ruby
|
{
"resource": ""
}
|
q24709
|
DataSift.AccountIdentityToken.list
|
train
|
def list(identity_id = '', per_page = '', page = '')
params = { identity_id: identity_id }
requires params
params.merge!(per_page: per_page) unless per_page.empty?
|
ruby
|
{
"resource": ""
}
|
q24710
|
BuildrIzPack.Pack.emitIzPackXML
|
train
|
def emitIzPackXML(xm)
# raise "xm must be an Builder::XmlMarkup object, but is #{xm.class}" if xm.class != Builder::XmlMarkup
xm.pack(@attributes) {
xm.description(@description)
|
ruby
|
{
"resource": ""
}
|
q24711
|
BuildrIzPack.IzPackTask.create_from
|
train
|
def create_from(file_map)
@izpackVersion ||= '4.3.5'
@appName ||= project.id
@izpackBaseDir = File.dirname(@output) if !@izpackBaseDir
@installerType ||= 'standard'
@inheritAll ||= 'true'
@compression ||= 'deflate'
@compressionLevel ||= '9'
@locales ||= ['eng']
@panels ||= ['TargetPanel', 'InstallPanel']
@packs ||=
raise "You must include at least one file to create an izPack installer" if file_map.size == 0 and !File.exists?(@input)
izPackArtifact = Buildr.artifact( "org.codehaus.izpack:izpack-standalone-compiler:jar:#{@izpackVersion}")
doc = nil
if !File.exists?(@input)
genInstaller(Builder::XmlMarkup.new(:target=>File.open(@input, 'w+'), :indent
|
ruby
|
{
"resource": ""
}
|
q24712
|
Tenon.ApplicationHelper.first_image
|
train
|
def first_image(obj, options = {})
opts = {
collection: :images,
method: :image,
style: :thumbnail,
default: image_path('noimage.jpg')
}.merge(options.symbolize_keys!)
image =
|
ruby
|
{
"resource": ""
}
|
q24713
|
Tenon.ApplicationHelper.human
|
train
|
def human(object)
if object.is_a?(Date)
object.strftime('%B %d, %Y')
elsif object.is_a?(Time)
object.strftime('%B %d, %Y at %I:%M %p')
|
ruby
|
{
"resource": ""
}
|
q24714
|
TeaLeaves.ExponentialSmoothingForecast.mean_squared_error
|
train
|
def mean_squared_error
return @mean_squared_error if @mean_squared_error
numerator = errors.drop(@seasonality_strategy.start_index).map {|i| i ** 2 }.inject(&:+)
|
ruby
|
{
"resource": ""
}
|
q24715
|
DataSift.ManagedSourceResource.add
|
train
|
def add(id, resources, validate = 'true')
params = {
id: id,
resources: resources,
validate: validate
}
|
ruby
|
{
"resource": ""
}
|
q24716
|
DataSift.ManagedSourceResource.remove
|
train
|
def remove(id, resource_ids)
params = {
id: id,
resource_ids: resource_ids
}
requires params
|
ruby
|
{
"resource": ""
}
|
q24717
|
DataSift.ManagedSourceAuth.add
|
train
|
def add(id, auth, validate = 'true')
params = {
id: id,
auth: auth,
|
ruby
|
{
"resource": ""
}
|
q24718
|
DataSift.ManagedSourceAuth.remove
|
train
|
def remove(id, auth_ids)
params = {
id: id,
auth_ids: auth_ids
}
requires params
|
ruby
|
{
"resource": ""
}
|
q24719
|
MediaWiki.Auth.login
|
train
|
def login(username, password)
# Save the assertion value while trying to log in, because otherwise the assertion will prevent us from logging in
assertion_value = @assertion.clone
@assertion = nil
params = {
action: 'login',
lgname: username,
lgpassword: password,
lgtoken: get_token('login')
}
response
|
ruby
|
{
"resource": ""
}
|
q24720
|
MediaWiki.Auth.create_account
|
train
|
def create_account(username, password, language = 'en', reason = nil)
params = {
name: username,
password: password,
language: language,
token: get_token('createaccount')
}
params[:reason] = reason unless reason.nil?
result = post(params)
unless result['error'].nil?
|
ruby
|
{
"resource": ""
}
|
q24721
|
MediaWiki.Auth.create_account_email
|
train
|
def create_account_email(username, email, language = 'en', reason = nil)
params = {
name: username,
email: email,
mailpassword: 'value',
language: language,
token: get_token('createaccount')
}
params[:reason] = reason unless reason.nil?
result = post(params)
unless
|
ruby
|
{
"resource": ""
}
|
q24722
|
RWebSpec.Driver.save_current_page
|
train
|
def save_current_page(options = {})
default_options = {:replacement => true}
options = default_options.merge(options)
to_dir = options[:dir] || default_dump_dir
if options[:filename]
file_name = options[:filename]
else
file_name = Time.now.strftime("%m%d%H%M%S") + ".html"
end
Dir.mkdir(to_dir) unless File.exists?(to_dir)
file = File.join(to_dir, file_name)
content = page_source
base_url = @web_browser.context.base_url
current_url = @web_browser.url
current_url =~ /(.*\/).*$/
|
ruby
|
{
"resource": ""
}
|
q24723
|
RWebSpec.Driver.wait_until
|
train
|
def wait_until(timeout = $testwise_polling_timeout || 30, polling_interval = $testwise_polling_interval || 1, & block)
end_time = ::Time.now + timeout
until ::Time.now > end_time
result = nil
begin
result = yield(self)
return result if result
|
ruby
|
{
"resource": ""
}
|
q24724
|
MediaWiki.Administration.block
|
train
|
def block(user, expiry = '2 weeks', reason = nil, nocreate = true)
params = {
action: 'block',
user: user,
expiry: expiry
}
token = get_token
params[:reason] = reason if reason
params[:nocreate] = '1' if nocreate
params[:token] = token
response = post(params)
|
ruby
|
{
"resource": ""
}
|
q24725
|
MediaWiki.Administration.unblock
|
train
|
def unblock(user, reason = nil)
params = {
action: 'unblock',
user: user
}
token = get_token
params[:reason] = reason if reason
params[:token] = token
response = post(params)
if response.key?('error')
|
ruby
|
{
"resource": ""
}
|
q24726
|
Argos.Ds.parse_message
|
train
|
def parse_message(contact)
header = contact[0]
body = contact[1,contact.count]
items = process_item_body(body)
|
ruby
|
{
"resource": ""
}
|
q24727
|
Argos.Ds.merge
|
train
|
def merge(ds, measurement, cardinality)
m = ds.select {|k,v| k != :measurements and k != :errors and k != :warn }
m = m.merge(measurement)
m = m.merge ({ technology: "argos",
type: type,
cardinality: cardinality
#file: "file://"+filename,
#source: sha1
})
# if not ds[:errors].nil? and ds[:errors].any?
# m[:errors] = ds[:errors].clone
# end
#
# if not ds[:warn].nil? and ds[:warn].any?
# m[:warn] = ds[:warn].clone
# end
#
# if not m[:sensor_data].nil? and m[:sensor_data].size != ds[:sensors]
# if m[:warn].nil?
# m[:warn] = []
# end
# m[:warn] << "sensors-count-mismatch"
# end
# Create id as SHA1 hash of measurement minus stuff that may vary (like filename)
#
# Possible improvement for is to base id on a static list of keys
# :program,
# :platform,
# :lines,
# :sensors,
# :satellite,
|
ruby
|
{
"resource": ""
}
|
q24728
|
DataSift.AccountIdentityLimit.create
|
train
|
def create(identity_id = '', service = '', total_allowance = nil, analyze_queries = nil)
fail BadParametersError, 'identity_id is required' if identity_id.empty?
fail BadParametersError, 'service is required' if service.empty?
fail BadParametersError, 'Must set total_allowance or analyze_queries' if
total_allowance.nil? && analyze_queries.nil?
params = { service: service }
params[:total_allowance]
|
ruby
|
{
"resource": ""
}
|
q24729
|
DataSift.AccountIdentityLimit.get
|
train
|
def get(identity_id = '', service = '')
fail BadParametersError, 'identity_id is required' if identity_id.empty?
fail BadParametersError, 'service is required' if service.empty?
|
ruby
|
{
"resource": ""
}
|
q24730
|
DataSift.AccountIdentityLimit.list
|
train
|
def list(service = '', per_page = '', page = '')
fail BadParametersError, 'service is required' if service.empty?
params = {}
params[:per_page] = per_page unless per_page.empty?
|
ruby
|
{
"resource": ""
}
|
q24731
|
DataSift.AccountIdentityLimit.delete
|
train
|
def delete(identity_id = '', service = '')
fail BadParametersError, 'identity_id is required' if identity_id.empty?
fail BadParametersError, 'service is required' if service.empty?
|
ruby
|
{
"resource": ""
}
|
q24732
|
EcsCompose.JsonGenerator.generate
|
train
|
def generate
if @yaml.has_key?("version")
@yaml = @yaml.fetch("services")
end
# Generate JSON for our containers.
containers = @yaml.map do |name, fields|
# Skip this service if we've been given a list to emit, and
# this service isn't on the list.
begin
mount_points = (fields["volumes"] || []).map do |v|
host, container, ro = v.split(':')
{
"sourceVolume" => path_to_vol_name(host),
"containerPath" => container,
"readOnly" => (ro == "ro")
}
end
json = {
"name" => name,
"image" => fields.fetch("image"),
# Default to a tiny guaranteed CPU share. Currently, 2 is the
# smallest meaningful value, and various ECS tools will round
# smaller numbers up.
"cpu" => fields["cpu_shares"] || 2,
"memory" => mem_limit_to_mb(fields.fetch("mem_limit")),
"links" => fields["links"] || [],
"portMappings" =>
(fields["ports"] || []).map {|pm| port_mapping(pm) },
"essential" => true,
"environment" => environment(fields["environment"] || {}),
"mountPoints" => mount_points,
"volumesFrom" => [],
"dockerLabels" => fields.fetch("labels", {}),
}
if fields.has_key?("entrypoint")
json["entryPoint"] = command_line(fields.fetch("entrypoint"))
end
if fields.has_key?("command")
json["command"] = command_line(fields.fetch("command"))
end
if fields.has_key?("privileged")
json["privileged"] = fields.fetch("privileged")
end
if fields.has_key?("ulimits")
json["ulimits"] = fields.fetch("ulimits").map do |name, limits|
case limits
when Hash
softLimit = limits.fetch("soft")
hardLimit = limits.fetch("hard")
else
|
ruby
|
{
"resource": ""
}
|
q24733
|
EcsCompose.JsonGenerator.mem_limit_to_mb
|
train
|
def mem_limit_to_mb(mem_limit)
unless mem_limit.downcase =~ /\A(\d+)([bkmg])\z/
raise "Cannot parse docker memory limit: #{mem_limit}"
end
val = $1.to_i
case $2
when "b" then (val / (1024.0 * 1024.0)).ceil
when "k" then (val / 1024.0).ceil
|
ruby
|
{
"resource": ""
}
|
q24734
|
EcsCompose.JsonGenerator.port_mapping
|
train
|
def port_mapping(port)
case port.to_s
when /\A(\d+)(?:\/([a-z]+))?\z/
port = $1.to_i
{
"hostPort" => port,
"containerPort" => port,
"protocol" => $2 || "tcp"
}
when /\A(\d+):(\d+)(?:\/([a-z]+))?\z/
{
|
ruby
|
{
"resource": ""
}
|
q24735
|
SemiSemantic.VersionSegment.increment
|
train
|
def increment(index=-1)
value = @components[index]
raise TypeError.new "'#{value}' is not an integer" unless value.is_a? Integer
copy = Array.new @components
copy[index] = value + 1
while index < copy.size && index != -1
index +=
|
ruby
|
{
"resource": ""
}
|
q24736
|
SemiSemantic.VersionSegment.decrement
|
train
|
def decrement(index=-1)
value = @components[index]
raise TypeError.new "'#{value}' is not an integer" unless value.is_a? Integer
raise RangeError.new "'#{value}' is zero or less" unless value > 0
|
ruby
|
{
"resource": ""
}
|
q24737
|
SemiSemantic.VersionSegment.compare_arrays
|
train
|
def compare_arrays(a, b)
a.each_with_index do |v1, i|
v2 = b[i]
if v1.is_a?(String) && v2.is_a?(Integer)
return 1
elsif v1.is_a?(Integer) && v2.is_a?(String)
return -1
end
|
ruby
|
{
"resource": ""
}
|
q24738
|
DataSift.ManagedSource.create
|
train
|
def create(source_type, name, parameters = {}, resources = [], auth = [], options = {})
fail BadParametersError, 'source_type and name are required' if source_type.nil? || name.nil?
params = {
:source_type => source_type,
:name => name
}
params.merge!(options) unless options.empty?
|
ruby
|
{
"resource": ""
}
|
q24739
|
DataSift.ManagedSource.update
|
train
|
def update(id, source_type, name, parameters = {}, resources = [], auth = [], options = {})
fail BadParametersError, 'ID, source_type and name are required' if id.nil? || source_type.nil? || name.nil?
params = {
:id => id,
:source_type => source_type,
:name => name
}
params.merge!(options) unless options.empty?
params.merge!({:auth => MultiJson.dump(auth)})
|
ruby
|
{
"resource": ""
}
|
q24740
|
DataSift.ManagedSource.get
|
train
|
def get(id = nil, source_type = nil, page = 1, per_page = 20)
params = { :page => page, :per_page => per_page }
params.merge!({ :id => id }) if !id.nil?
params.merge!({ :source_type => source_type
|
ruby
|
{
"resource": ""
}
|
q24741
|
DataSift.ManagedSource.log
|
train
|
def log(id, page = 1, per_page = 20)
fail BadParametersError, 'ID is required' if id.nil?
DataSift.request(:POST,
|
ruby
|
{
"resource": ""
}
|
q24742
|
Guard.Less.compile
|
train
|
def compile(lessfile, cssfile)
import_paths = options[:import_paths].unshift(File.dirname(lessfile))
parser = ::Less::Parser.new paths: import_paths, filename: lessfile
File.open(lessfile, 'r') do |infile|
File.open(cssfile, 'w') do
|
ruby
|
{
"resource": ""
}
|
q24743
|
DataSift.Pylon.tags
|
train
|
def tags(hash = '', id = '', service = 'facebook')
fail BadParametersError, 'hash or id is required' if hash.empty? && id.empty?
fail BadParametersError, 'service is required' if service.empty?
params = {}
|
ruby
|
{
"resource": ""
}
|
q24744
|
DataSift.Pylon.sample
|
train
|
def sample(hash = '', count = nil, start_time = nil, end_time = nil, filter = '', id = '', service = 'facebook')
fail BadParametersError, 'hash or id is required' if hash.empty? && id.empty?
fail BadParametersError, 'service is required' if service.empty?
params = {}
params.merge!(hash: hash) unless hash.empty?
params.merge!(id: id) unless id.empty?
params.merge!(count: count) unless count.nil?
params.merge!(start_time: start_time) unless start_time.nil?
|
ruby
|
{
"resource": ""
}
|
q24745
|
DataSift.Pylon.reference
|
train
|
def reference(service:, slug: '', **opts)
params = {}
params[:per_page] = opts[:per_page] if opts.key?(:per_page)
params[:page] = opts[:page] if opts.key?(:page)
|
ruby
|
{
"resource": ""
}
|
q24746
|
TeaLeaves.Forecast.errors
|
train
|
def errors
@errors ||= @time_series.zip(one_step_ahead_forecasts).map do |(observation, forecast)|
|
ruby
|
{
"resource": ""
}
|
q24747
|
Tenon.TenonHelper.action_link
|
train
|
def action_link(title, link, icon, options = {})
icon_tag = content_tag(:i, '', class: "fa fa-#{icon} fa-fw")
|
ruby
|
{
"resource": ""
}
|
q24748
|
Tenon.TenonHelper.toggle_link
|
train
|
def toggle_link(object, field, link, true_values, false_values)
state = object.send(field)
icon = state ? true_values[0] : false_values[0]
tooltip = state ? true_values[1] : false_values[1]
data = {
trueicon: true_values[0],
falseicon:
|
ruby
|
{
"resource": ""
}
|
q24749
|
Tenon.TenonHelper.edit_link
|
train
|
def edit_link(obj, options = {})
if policy(obj).edit?
url = polymorphic_url([:edit] + Array(obj))
|
ruby
|
{
"resource": ""
}
|
q24750
|
Tenon.TenonHelper.delete_link
|
train
|
def delete_link(obj, options = {})
if policy(obj).destroy?
default_options = { data: {
confirm: 'Are you sure? There is no undo for this!',
tooltip: 'Delete',
method: 'Delete',
remote: 'true'
|
ruby
|
{
"resource": ""
}
|
q24751
|
Argos.Soap._call_xml_operation
|
train
|
def _call_xml_operation(op_sym, body, extract=nil)
@operation = _operation(op_sym)
@operation.body = body
@response = operation.call
# Check for http errors?
# Handle faults (before extracting data)
_envelope.xpath("soap:Body/soap:Fault", namespaces).each do | fault |
raise Exception, fault.to_s
end
# Extract data
if extract.respond_to?(:call)
@xml = extract.call(response)
else
@xml = response.raw
end
# Handle errors
ng = Nokogiri.XML(xml)
ng.xpath("/data/errors/error").each do | error |
if error.key?("code")
case error["code"].to_i
when 4
raise NodataException
end
#<error code="2">max response reached</error>
#<error code="3">authentification error</error>
#<error code="9">start date upper than end date</error>
else
raise Exception, error
end
end
# Validation - only :getXml
|
ruby
|
{
"resource": ""
}
|
q24752
|
Argos.Soap._extract_motm
|
train
|
def _extract_motm
lambda {|response|
# Scan for MOTM signature --uuid:*
if response.raw =~ (/^(--[\w:-]+)--$/)
# Get the last message, which is -2 because of the trailing --
xml = response.raw.split($1)[-2].strip
# Get rid of HTTP headers
|
ruby
|
{
"resource": ""
}
|
q24753
|
AssLauncher.Api.ole
|
train
|
def ole(type, requiremet = '>= 0')
AssLa
|
ruby
|
{
"resource": ""
}
|
q24754
|
RWebSpec.Popup.check_for_security_alerts
|
train
|
def check_for_security_alerts
autoit = WIN32OLE.new('AutoItX3.Control')
loop do
["Security Alert", "Security Information"].each do |win_title|
ret = autoit.WinWait(win_title, '', 1)
|
ruby
|
{
"resource": ""
}
|
q24755
|
RWebSpec.Popup.start_checking_js_dialog
|
train
|
def start_checking_js_dialog(button = "OK", wait_time = 3)
w = WinClicker.new
longName = File.expand_path(File.dirname(__FILE__)).gsub("/", "\\" )
shortName = w.getShortFileName(longName)
c
|
ruby
|
{
"resource": ""
}
|
q24756
|
MediaWiki.Butt.query
|
train
|
def query(params, base_return = [])
params[:action] = 'query'
params[:continue] = ''
loop do
result = post(params)
yield(base_return, result['query']) if result.key?('query')
|
ruby
|
{
"resource": ""
}
|
q24757
|
MediaWiki.Butt.query_ary_irrelevant_keys
|
train
|
def query_ary_irrelevant_keys(params, base_response_key, property_key)
query(params) do |return_val, query|
|
ruby
|
{
"resource": ""
}
|
q24758
|
MediaWiki.Butt.query_ary
|
train
|
def query_ary(params, base_response_key, property_key)
query(params) do |return_val, query|
|
ruby
|
{
"resource": ""
}
|
q24759
|
MediaWiki.Butt.get_limited
|
train
|
def get_limited(integer, max_user = 500, max_bot = 5000)
if integer.is_a?(String)
return integer if integer == 'max'
return 500
end
return integer if integer <= max_user
|
ruby
|
{
"resource": ""
}
|
q24760
|
MetaPresenter.Builder.ancestors_until
|
train
|
def ancestors_until(until_class)
# trim down the list
ancestors_list = all_ancestors[0..all_ancestors.index(until_class)]
|
ruby
|
{
"resource": ""
}
|
q24761
|
RailsRateLimiter.ClassMethods.rate_limit
|
train
|
def rate_limit(options = {}, &block)
raise Error, 'Handling block was not provided' unless block_given?
# Separate out options related only to rate limiting
strategy = (options.delete(:strategy) || 'sliding_window_log').to_s
|
ruby
|
{
"resource": ""
}
|
q24762
|
DataSift.Historics.prepare
|
train
|
def prepare(hash, start, end_time, name, sources = '', sample = 100)
params = {
:hash => hash,
:start => start,
:end => end_time,
:name => name,
:sources => sources,
|
ruby
|
{
"resource": ""
}
|
q24763
|
DataSift.Historics.pause
|
train
|
def pause(id, reason = '')
params = { :id => id }
requires params
|
ruby
|
{
"resource": ""
}
|
q24764
|
DataSift.Historics.stop
|
train
|
def stop(id, reason = '')
params = { :id => id }
requires params
|
ruby
|
{
"resource": ""
}
|
q24765
|
DataSift.Historics.status
|
train
|
def status(start, end_time, sources = '')
params = { :start => start, :end => end_time, :sources => sources }
requires params
|
ruby
|
{
"resource": ""
}
|
q24766
|
DataSift.Historics.update
|
train
|
def update(id, name)
params = { :id => id, :name => name }
requires params
|
ruby
|
{
"resource": ""
}
|
q24767
|
DataSift.Historics.get_by_id
|
train
|
def get_by_id(id, with_estimate = 1)
params = { :id => id, :with_estimate =>
|
ruby
|
{
"resource": ""
}
|
q24768
|
DataSift.Historics.get
|
train
|
def get(max = 20, page = 1, with_estimate = 1)
params = { :max => max, :page => page, :with_estimate
|
ruby
|
{
"resource": ""
}
|
q24769
|
Bech32.SegwitAddr.to_script_pubkey
|
train
|
def to_script_pubkey
v = ver == 0 ? ver : ver + 0x50
([v, prog.length].pack("CC")
|
ruby
|
{
"resource": ""
}
|
q24770
|
Bech32.SegwitAddr.script_pubkey=
|
train
|
def script_pubkey=(script_pubkey)
values = [script_pubkey].pack('H*').unpack("C*")
@ver = values[0]
|
ruby
|
{
"resource": ""
}
|
q24771
|
Youtrack.Issue.add_work_item_to
|
train
|
def add_work_item_to(issue_id, attributes={})
attributes = attributes.to_hash
attributes.symbolize_keys!
attributes[:date] ||= Date.current.iso8601
epoc_date = Date.parse(attributes[:date]).to_time.to_i * 1000
attributes[:user] ||= self.service.login
work_items = REXML::Element.new('workItems')
work_item = work_items.add_element('workItem')
work_item.add_element('author').add_attribute('login', attributes[:user])
|
ruby
|
{
"resource": ""
}
|
q24772
|
Songkickr.Setlist.parse_setlist_items
|
train
|
def parse_setlist_items(setlist_item_array = nil)
return [] unless setlist_item_array
setlist_item_array.inject([]) do |setlist_items, item|
|
ruby
|
{
"resource": ""
}
|
q24773
|
Epp.Server.get_frame
|
train
|
def get_frame
raise SocketError.new("Connection closed by remote server") if !@socket or @socket.eof?
header = @socket.read(4)
raise SocketError.new("Error reading frame
|
ruby
|
{
"resource": ""
}
|
q24774
|
Epp.Server.login
|
train
|
def login
raise SocketError, "Socket must be opened before logging in" if !@socket or @socket.closed?
xml = new_epp_request
xml.root << command = Node.new("command")
command << login = Node.new("login")
login << Node.new("clID", tag)
login << Node.new("pw", password)
login << options = Node.new("options")
options << Node.new("version", version)
options << Node.new("lang", lang)
|
ruby
|
{
"resource": ""
}
|
q24775
|
Epp.Server.logout
|
train
|
def logout
raise SocketError, "Socket must be opened before logging out" if !@socket or @socket.closed?
xml = new_epp_request
xml.root << command = Node.new("command")
command << login
|
ruby
|
{
"resource": ""
}
|
q24776
|
ZenPush.Zendesk.find_category
|
train
|
def find_category(category_name, options = {})
categories = self.categories
if categories.is_a?(Array)
categories.detect { |c| c['name'] == category_name }
|
ruby
|
{
"resource": ""
}
|
q24777
|
ZenPush.Zendesk.find_forum
|
train
|
def find_forum(category_name, forum_name, options = {})
category = self.find_category(category_name, options)
if category
self.forums.detect
|
ruby
|
{
"resource": ""
}
|
q24778
|
ZenPush.Zendesk.find_or_create_forum
|
train
|
def find_or_create_forum(category_name, forum_name, options={ })
category = self.find_or_create_category(category_name, options)
if category
self.forums.detect
|
ruby
|
{
"resource": ""
}
|
q24779
|
ZenPush.Zendesk.find_topic
|
train
|
def find_topic(category_name, forum_name, topic_title, options = {})
forum = self.find_forum(category_name, forum_name, options)
if forum
|
ruby
|
{
"resource": ""
}
|
q24780
|
ZenPush.Zendesk.post_forum
|
train
|
def post_forum(category_id, forum_name, options={ })
self.post('/forums.json',
options.merge(
:body => { :forum => {
:name
|
ruby
|
{
"resource": ""
}
|
q24781
|
ZenPush.Zendesk.post_topic
|
train
|
def post_topic(forum_id, title, body, options = { })
self.post("/topics.json",
options.merge(
:body => { :topic => {
|
ruby
|
{
"resource": ""
}
|
q24782
|
Tenon.PieceHelper.responsive_image_tag
|
train
|
def responsive_image_tag(piece, options = {}, breakpoints)
srcset = generate_srcset(piece)
sizes = generate_sizes(piece, breakpoints)
# Let's just use an plain image_tag if responsive styles haven't been
|
ruby
|
{
"resource": ""
}
|
q24783
|
RWebSpec.Assert.assert
|
train
|
def assert test, msg = nil
msg ||= "Failed assertion, no message given."
# comment out self.assertions += 1 to counting assertions
unless test then
|
ruby
|
{
"resource": ""
}
|
q24784
|
RWebSpec.Assert.assert_link_present_with_text
|
train
|
def assert_link_present_with_text(link_text)
@web_browser.links.each { |link|
return if link.text.include?(link_text)
}
|
ruby
|
{
"resource": ""
}
|
q24785
|
RWebSpec.Assert.assert_radio_option_not_present
|
train
|
def assert_radio_option_not_present(radio_group, radio_option)
@web_browser.radios.each { |radio|
the_element_name = element_name(radio)
|
ruby
|
{
"resource": ""
}
|
q24786
|
JedisRb.Pool.yield_connection
|
train
|
def yield_connection
response = begin
resource = @connection_pool.resource
yield resource
|
ruby
|
{
"resource": ""
}
|
q24787
|
JedisRb.Pool.convert
|
train
|
def convert(value)
case value
when java.util.List then value.to_a
|
ruby
|
{
"resource": ""
}
|
q24788
|
DataSift.HistoricsPreview.create
|
train
|
def create(hash, sources, parameters, start, end_time = nil)
params = {
:hash => hash,
:sources => sources,
:parameters => parameters,
:start => start
}
requires params
|
ruby
|
{
"resource": ""
}
|
q24789
|
Youtrack.Client.connect!
|
train
|
def connect!
@connection = HTTParty.post(File.join(url, "rest/user/login"), body: credentials_hash )
|
ruby
|
{
"resource": ""
}
|
q24790
|
Tenon.ProxyAttachment.url
|
train
|
def url(style = :original, *args)
if style.to_sym == :original
original_url(*args)
else
|
ruby
|
{
"resource": ""
}
|
q24791
|
Hero.Observer.log_step
|
train
|
def log_step(id, step, context, options, error=nil)
return unless Hero.logger
if error
Hero.logger.error "HERO #{id.to_s.ljust(6)} #{formula_name} -> #{step.first} Context: #{context.inspect} Options: #{options.inspect} Error: #{error.message}"
else
|
ruby
|
{
"resource": ""
}
|
q24792
|
DataSift.Task.create
|
train
|
def create(service:, type:, subscription_id:, name:, parameters:)
DataSift.request(:POST, "pylon/#{service}/task", @config, {
type: type,
|
ruby
|
{
"resource": ""
}
|
q24793
|
DataSift.Task.list
|
train
|
def list(service:, type: 'analysis', **opts)
params = {}
params[:per_page] = opts[:per_page] if opts.key?(:per_page)
|
ruby
|
{
"resource": ""
}
|
q24794
|
EcsCompose.TaskDefinition.update
|
train
|
def update(cluster)
deployed = primary_deployment(cluster)
|
ruby
|
{
"resource": ""
}
|
q24795
|
EcsCompose.TaskDefinition.scale
|
train
|
def scale(cluster, count)
Ecs.update_ser
|
ruby
|
{
"resource": ""
}
|
q24796
|
EcsCompose.TaskDefinition.run
|
train
|
def run(cluster, started_by: nil, **args)
overrides_json = json_generator.generate_override_json(**args)
info = Ecs.run_task(cluster.name, register,
started_by: started_by,
|
ruby
|
{
"resource": ""
}
|
q24797
|
ClientVariable.TiltHandlebars.evaluate
|
train
|
def evaluate(scope, locals, &block)
binding.pry
template = data.dup
template.gsub!(/"/, '\\"')
|
ruby
|
{
"resource": ""
}
|
q24798
|
TeaLeaves.ArrayMethods.moving_average
|
train
|
def moving_average(average_specifier)
if average_specifier.kind_of?(Array)
avg = MovingAverage.weighted(average_specifier)
elsif average_specifier.kind_of?(Integer)
avg = MovingAverage.simple(average_specifier)
|
ruby
|
{
"resource": ""
}
|
q24799
|
TeaLeaves.MovingAverage.calculate
|
train
|
def calculate(array)
return [] if @span > array.length
array.each_cons(@span).map do |window|
|
ruby
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.