_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3 values | text stringlengths 66 10.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q2300 | LIFX.LightTarget.set_power | train | def set_power(state)
level = case state
when :on
1
when :off
0
else
raise ArgumentError.new("Must pass in either :on or :off")
end
send_message(Protocol::Device::SetPower.new(level: level))
self
end | ruby | {
"resource": ""
} |
q2301 | LIFX.LightTarget.set_site_id | train | def set_site_id(site_id)
send_message(Protocol::Device::SetSite.new(site: [site_id].pack('H*')))
end | ruby | {
"resource": ""
} |
q2302 | LIFX.LightTarget.set_time | train | def set_time(time = Time.now)
send_message(Protocol::Device::SetTime.new(time: (time.to_f * NSEC_IN_SEC).round))
end | ruby | {
"resource": ""
} |
q2303 | GemUpdater.RubyGemsFetcher.query_rubygems | train | def query_rubygems(tries = 0)
JSON.parse(open("https://rubygems.org/api/v1/gems/#{gem_name}.json").read)
rescue OpenURI::HTTPError => e
# We may trigger too many requests, in which case give rubygems a break
if e.io.status.include?(HTTP_TOO_MANY_REQUESTS)
if (tries += 1) < 2
sleep 1 && retry
end
end
end | ruby | {
"resource": ""
} |
q2304 | GemUpdater.RubyGemsFetcher.uri_from_other_sources | train | def uri_from_other_sources
uri = nil
source.remotes.each do |remote|
break if uri
uri = case remote.host
when 'rubygems.org' then next # already checked
when 'rails-assets.org'
uri_from_railsassets
else
Bundler.ui.error "Source #{remote} is not supported, ' \
'feel free to open a PR or an issue on https://github.com/MaximeD/gem_updater"
end
end
uri
end | ruby | {
"resource": ""
} |
q2305 | DirectedGraph.Graph.compute_key | train | def compute_key(external_identifier)
x = [external_identifier].flatten
x.map! {|xx| xx.to_s}
x.join("_")
end | ruby | {
"resource": ""
} |
q2306 | DirectedGraph.Graph.to_graphml | train | def to_graphml()
builder = Builder::XmlMarkup.new(:indent => 1)
builder.instruct! :xml, :version => "1.0"
graphml_attribs = {
"xmlns" => "http://graphml.graphdrawing.org/xmlns",
"xmlns:xsi" => "http://www.w3.org/2001/XMLSchema-instance",
"xmlns:y" => "http://www.yworks.com/xml/graphml",
"xmlns:yed" => "http://www.yworks.com/xml/yed/3",
"xsi:schemaLocation" => "http://graphml.graphdrawing.org/xmlns http://www.yworks.com/xml/schema/graphml/1.1/ygraphml.xsd",
:directed => "1",
:label => "test"
}
builder.graphml(graphml_attribs) do
# Define key id's at top of graphml file
builder.key({:for=>"node", :id=>"d3", "yfiles.type"=>"nodegraphics"})
# Build Graph
#
builder.graph({:id=>"G"}) do
vertices.each do |vertex|
builder.node(:id => compute_key([vertex.name, vertex.object_id])) do
builder.data({:key=>"d3"}) do
builder.tag!("y:ShapeNode") do
graphics = vertex.data.fetch(:graphics, {})
graphics.fetch(:fill, []).each {|f| builder.tag! "y:Fill", {:color=>f, :transparent=>"false"}}
graphics.fetch(:shape,[]).each {|s| builder.tag! "y:Shape", {:type=>s}}
graphics.fetch(:geometry,[]).each {|s| builder.tag! "y:Geometry", s}
graphics.fetch(:label,[]).each {|l| builder.tag! "y:NodeLabel", l}
end
end
end
end
edges.each do |edge|
source = edge.origin_vertex
target = edge.destination_vertex
options = edge.data[:options]
label = ""
builder.edge(
:source => s = compute_key([source.name, source.object_id]),
:target => t = compute_key([target.name, target.object_id]),
:id => compute_key([source.name, target.name, edge.object_id]),
:label => "#{label}"
) do
#edge[:attributes].each_pair { |k, v|
# id_str = compute_key([k,:edge_attr])
# builder.data(v.to_s, {:key=>@guid[id_str]})
#}
end
end
end
end
builder.target!
end | ruby | {
"resource": ""
} |
q2307 | LIFX.Color.to_hsbk | train | def to_hsbk
Protocol::Light::Hsbk.new(
hue: (hue / 360.0 * UINT16_MAX).to_i,
saturation: (saturation * UINT16_MAX).to_i,
brightness: (brightness * UINT16_MAX).to_i,
kelvin: [KELVIN_MIN, kelvin.to_i, KELVIN_MAX].sort[1]
)
end | ruby | {
"resource": ""
} |
q2308 | LIFX.Color.similar_to? | train | def similar_to?(other, threshold: DEFAULT_SIMILAR_THRESHOLD)
return false unless other.is_a?(Color)
conditions = []
conditions << (((hue - other.hue).abs < (threshold * 360)) || begin
# FIXME: Surely there's a better way.
hues = [hue, other.hue].sort
hues[0] += 360
(hues[0] - hues[1]).abs < (threshold * 360)
end)
conditions << ((saturation - other.saturation).abs < threshold)
conditions << ((brightness - other.brightness).abs < threshold)
conditions.all?
end | ruby | {
"resource": ""
} |
q2309 | Nominatim.Reverse.fetch | train | def fetch
body = get(Nominatim.config.reverse_url, @criteria).body
return nil if body.empty?
Nominatim::Place.new(body)
end | ruby | {
"resource": ""
} |
q2310 | Signature.Request.sign | train | def sign(token)
@auth_hash = {
:auth_version => "1.0",
:auth_key => token.key,
:auth_timestamp => Time.now.to_i.to_s
}
@auth_hash[:auth_signature] = signature(token)
@signed = true
return @auth_hash
end | ruby | {
"resource": ""
} |
q2311 | Signature.Request.authenticate_by_token! | train | def authenticate_by_token!(token, timestamp_grace = 600)
# Validate that your code has provided a valid token. This does not
# raise an AuthenticationError since passing tokens with empty secret is
# a code error which should be fixed, not reported to the API's consumer
if token.secret.nil? || token.secret.empty?
raise "Provided token is missing secret"
end
validate_version!
validate_timestamp!(timestamp_grace)
validate_signature!(token)
true
end | ruby | {
"resource": ""
} |
q2312 | Signature.Request.authenticate | train | def authenticate(timestamp_grace = 600)
raise ArgumentError, "Block required" unless block_given?
key = @auth_hash['auth_key']
raise AuthenticationError, "Missing parameter: auth_key" unless key
token = yield key
unless token
raise AuthenticationError, "Unknown auth_key"
end
authenticate_by_token!(token, timestamp_grace)
return token
end | ruby | {
"resource": ""
} |
q2313 | Signature.Request.authenticate_async | train | def authenticate_async(timestamp_grace = 600)
raise ArgumentError, "Block required" unless block_given?
df = EM::DefaultDeferrable.new
key = @auth_hash['auth_key']
unless key
df.fail(AuthenticationError.new("Missing parameter: auth_key"))
return
end
token_df = yield key
token_df.callback { |token|
begin
authenticate_by_token!(token, timestamp_grace)
df.succeed(token)
rescue AuthenticationError => e
df.fail(e)
end
}
token_df.errback {
df.fail(AuthenticationError.new("Unknown auth_key"))
}
ensure
return df
end | ruby | {
"resource": ""
} |
q2314 | Signature.Request.identical? | train | def identical?(a, b)
return true if a.nil? && b.nil?
return false if a.nil? || b.nil?
return false unless a.bytesize == b.bytesize
a.bytes.zip(b.bytes).reduce(0) { |memo, (a, b)| memo += a ^ b } == 0
end | ruby | {
"resource": ""
} |
q2315 | Sottolio.Script.method_missing | train | def method_missing(m, *args, &block)
if args.any?
args = args.first if args.length == 1
@var << { m.to_sym => args }
instance_variable_set "@#{m}", args
else
instance_variable_get "@#{m}"
end
end | ruby | {
"resource": ""
} |
q2316 | LIFX.TagManager.purge_unused_tags! | train | def purge_unused_tags!
unused_tags.each do |tag|
logger.info("Purging tag '#{tag}'")
entries_with(label: tag).each do |entry|
payload = Protocol::Device::SetTagLabels.new(tags: id_to_tags_field(entry.tag_id), label: '')
context.send_message(target: Target.new(site_id: entry.site_id),
payload: payload,
acknowledge: true)
end
end
Timeout.timeout(5) do
while !unused_tags.empty?
sleep 0.1
end
end
end | ruby | {
"resource": ""
} |
q2317 | GemUpdater.Updater.format_diff | train | def format_diff
gemfile.changes.map do |gem, details|
ERB.new(template, nil, '<>').result(binding)
end
end | ruby | {
"resource": ""
} |
q2318 | GemUpdater.Updater.fill_changelogs | train | def fill_changelogs
[].tap do |threads|
gemfile.changes.each do |gem_name, details|
threads << Thread.new { retrieve_gem_changes(gem_name, details) }
end
end.each(&:join)
end | ruby | {
"resource": ""
} |
q2319 | GemUpdater.Updater.find_source | train | def find_source(gem, source)
case source
when Bundler::Source::Rubygems
GemUpdater::RubyGemsFetcher.new(gem, source).source_uri
when Bundler::Source::Git
source.uri.gsub(/^git/, 'http').chomp('.git')
end
end | ruby | {
"resource": ""
} |
q2320 | GemUpdater.Updater.template | train | def template
File.read("#{Dir.home}/.gem_updater_template.erb")
rescue Errno::ENOENT
File.read(File.expand_path('../lib/gem_updater_template.erb', __dir__))
end | ruby | {
"resource": ""
} |
q2321 | OmniCat.Classifier.strategy= | train | def strategy=(classifier)
is_interchangeable?(classifier)
if @strategy && classifier.category_count == 0
previous_strategy = @strategy
@strategy = classifier
convert_categories_with_docs(previous_strategy)
else
@strategy = classifier
end
end | ruby | {
"resource": ""
} |
q2322 | OmniCat.Result.add_score | train | def add_score(score)
@total_score += score.value
@scores[score.key] = score
if @top_score_key.nil? || @scores[@top_score_key].value < score.value
@top_score_key = score.key
end
end | ruby | {
"resource": ""
} |
q2323 | LIFX.Light.add_hook | train | def add_hook(payload_class, hook_arg = nil, &hook_block)
hook = block_given? ? hook_block : hook_arg
if !hook || !hook.is_a?(Proc)
raise "Must pass a proc either as an argument or a block"
end
@message_hooks[payload_class] << hook
end | ruby | {
"resource": ""
} |
q2324 | LIFX.Light.color | train | def color(refresh: false, fetch: true)
@color = nil if refresh
send_message!(Protocol::Light::Get.new, wait_for: Protocol::Light::State) if fetch && !@color
@color
end | ruby | {
"resource": ""
} |
q2325 | LIFX.Light.set_label | train | def set_label(label)
if label.bytes.length > MAX_LABEL_LENGTH
raise LabelTooLong.new("Label length in bytes must be below or equal to #{MAX_LABEL_LENGTH}")
end
while self.label != label
send_message!(Protocol::Device::SetLabel.new(label: label.encode('utf-8')), wait_for: Protocol::Device::StateLabel)
end
self
end | ruby | {
"resource": ""
} |
q2326 | LIFX.Light.set_power! | train | def set_power!(state)
level = case state
when :on
1
when :off
0
else
raise ArgumentError.new("Must pass in either :on or :off")
end
send_message!(Protocol::Device::SetPower.new(level: level), wait_for: Protocol::Device::StatePower) do |payload|
if level == 0
payload.level == 0
else
payload.level > 0
end
end
self
end | ruby | {
"resource": ""
} |
q2327 | LIFX.Light.time | train | def time
send_message!(Protocol::Device::GetTime.new, wait_for: Protocol::Device::StateTime) do |payload|
Time.at(payload.time.to_f / NSEC_IN_SEC)
end
end | ruby | {
"resource": ""
} |
q2328 | LIFX.Light.latency | train | def latency
start = Time.now.to_f
send_message!(Protocol::Device::GetTime.new, wait_for: Protocol::Device::StateTime)
Time.now.to_f - start
end | ruby | {
"resource": ""
} |
q2329 | LIFX.Light.mesh_firmware | train | def mesh_firmware(fetch: true)
@mesh_firmware ||= begin
send_message!(Protocol::Device::GetMeshFirmware.new,
wait_for: Protocol::Device::StateMeshFirmware) do |payload|
Firmware.new(payload)
end if fetch
end
end | ruby | {
"resource": ""
} |
q2330 | LIFX.Light.wifi_firmware | train | def wifi_firmware(fetch: true)
@wifi_firmware ||= begin
send_message!(Protocol::Device::GetWifiFirmware.new,
wait_for: Protocol::Device::StateWifiFirmware) do |payload|
Firmware.new(payload)
end if fetch
end
end | ruby | {
"resource": ""
} |
q2331 | LIFX.Light.temperature | train | def temperature
send_message!(Protocol::Light::GetTemperature.new,
wait_for: Protocol::Light::StateTemperature) do |payload|
payload.temperature / 100.0
end
end | ruby | {
"resource": ""
} |
q2332 | LIFX.Light.mesh_info | train | def mesh_info
send_message!(Protocol::Device::GetMeshInfo.new,
wait_for: Protocol::Device::StateMeshInfo) do |payload|
{
signal: payload.signal, # This is in Milliwatts
tx: payload.tx,
rx: payload.rx
}
end
end | ruby | {
"resource": ""
} |
q2333 | LIFX.Light.wifi_info | train | def wifi_info
send_message!(Protocol::Device::GetWifiInfo.new,
wait_for: Protocol::Device::StateWifiInfo) do |payload|
{
signal: payload.signal, # This is in Milliwatts
tx: payload.tx,
rx: payload.rx
}
end
end | ruby | {
"resource": ""
} |
q2334 | LIFX.Light.version | train | def version
send_message!(Protocol::Device::GetVersion.new,
wait_for: Protocol::Device::StateVersion) do |payload|
{
vendor: payload.vendor,
product: payload.product,
version: payload.version
}
end
end | ruby | {
"resource": ""
} |
q2335 | LIFX.Light.uptime | train | def uptime
send_message!(Protocol::Device::GetInfo.new,
wait_for: Protocol::Device::StateInfo) do |payload|
payload.uptime.to_f / NSEC_IN_SEC
end
end | ruby | {
"resource": ""
} |
q2336 | LIFX.Light.last_downtime | train | def last_downtime
send_message!(Protocol::Device::GetInfo.new,
wait_for: Protocol::Device::StateInfo) do |payload|
payload.downtime.to_f / NSEC_IN_SEC
end
end | ruby | {
"resource": ""
} |
q2337 | LIFX.Light.send_message | train | def send_message(payload, acknowledge: true, at_time: nil)
context.send_message(target: Target.new(device_id: id), payload: payload, acknowledge: acknowledge, at_time: at_time)
end | ruby | {
"resource": ""
} |
q2338 | LIFX.Light.send_message! | train | def send_message!(payload, wait_for: wait_for, wait_timeout: Config.message_wait_timeout, retry_interval: Config.message_retry_interval, &block)
if Thread.current[:sync_enabled]
raise "Cannot use synchronous methods inside a sync block"
end
result = nil
begin
block ||= Proc.new { |msg| true }
proc = -> (payload) {
result = block.call(payload)
}
add_hook(wait_for, proc)
try_until -> { result }, timeout: wait_timeout, timeout_exception: TimeoutError, action_interval: retry_interval, signal: @message_signal do
send_message(payload)
end
result
rescue TimeoutError
backtrace = caller_locations(2).map { |c| c.to_s }
caller_method = caller_locations(2, 1).first.label
ex = MessageTimeout.new("#{caller_method}: Timeout exceeded waiting for response from #{self}")
ex.device = self
ex.set_backtrace(backtrace)
raise ex
ensure
remove_hook(wait_for, proc)
end
end | ruby | {
"resource": ""
} |
q2339 | Nexus.Client.gav_data | train | def gav_data(gav)
res = {}
request = Typhoeus::Request.new(
"#{host_url}/service/local/artifact/maven/resolve",
:params => gav.to_hash,:connecttimeout => 5,
:headers => { 'Accept' => 'application/json' }
)
request.on_failure do |response|
raise("Failed to get gav data for #{gav.to_s}")
end
request.on_complete do |response|
res = JSON.parse(response.response_body)
end
request.run
res['data']
end | ruby | {
"resource": ""
} |
q2340 | Nexus.Client.sha | train | def sha(file, use_sha_file=false)
if use_sha_file and File.exists?("#{file}.sha1")
# reading the file is faster than doing a hash, so we keep the hash in the file
# then we read back and compare. There is no reason to perform sha1 everytime
begin
File.open("#{file}.sha1", 'r') { |f| f.read().strip}
rescue
Digest::SHA1.file(File.expand_path(file)).hexdigest
end
else
Digest::SHA1.file(File.expand_path(file)).hexdigest
end
end | ruby | {
"resource": ""
} |
q2341 | Nexus.Client.sha_match? | train | def sha_match?(file, gav, use_sha_file=false)
if File.exists?(file)
if gav.sha1.nil?
gav.sha1 = gav_data(gav)['sha1']
end
sha(file,use_sha_file) == gav.sha1
else
false
end
end | ruby | {
"resource": ""
} |
q2342 | Nexus.Client.write_sha1 | train | def write_sha1(file,sha1)
shafile = "#{file}.sha1"
File.open(shafile, 'w') { |f| f.write(sha1) }
end | ruby | {
"resource": ""
} |
q2343 | GemUpdater.SourcePageParser.known_https | train | def known_https(uri)
case uri.host
when HOSTS[:github]
# remove possible subdomain like 'wiki.github.com'
URI "https://github.com#{uri.path}"
when HOSTS[:bitbucket]
URI "https://#{uri.host}#{uri.path}"
when HOSTS[:rubygems]
URI "https://#{uri.host}#{uri.path}"
else
uri
end
end | ruby | {
"resource": ""
} |
q2344 | GemUpdater.SourcePageParser.changelog_names | train | def changelog_names
CHANGELOG_NAMES.flat_map do |name|
[name, name.upcase, name.capitalize]
end.uniq
end | ruby | {
"resource": ""
} |
q2345 | Kss.ApplicationHelper.styleguide_block | train | def styleguide_block(section, &block)
raise ArgumentError, "Missing block" unless block_given?
@section = styleguide.section(section)
if !@section.raw
raise "KSS styleguide section is nil, is section '#{section}' defined in your css?"
end
content = capture(&block)
render 'kss/shared/styleguide_block', :section => @section, :example_html => content
end | ruby | {
"resource": ""
} |
q2346 | AkamaiApi::ECCU.SoapBody.array | train | def array name, values
array_attrs = {
'soapenc:arrayType' => "xsd:string[#{values.length}]",
'xsi:type' => 'wsdl:ArrayOfString'
}
builder.tag! name, array_attrs do |tag|
values.each { |value| tag.item value }
end
self
end | ruby | {
"resource": ""
} |
q2347 | AkamaiApi::CCU::PurgeStatus.Request.execute | train | def execute purge_id_or_progress_uri
purge_id_or_progress_uri = normalize_progress_uri purge_id_or_progress_uri
response = self.class.get purge_id_or_progress_uri, basic_auth: AkamaiApi.auth
parse_response response
end | ruby | {
"resource": ""
} |
q2348 | AkamaiApi::ECCU.FindRequest.execute | train | def execute retrieve_content = false
with_soap_error_handling do
response = client_call :get_info, message: request_body(retrieve_content).to_s
FindResponse.new response[:eccu_info]
end
end | ruby | {
"resource": ""
} |
q2349 | AkamaiApi::CCU::Purge.Request.execute | train | def execute *items
akamai = Akamai::Edgegrid::HTTP.new(address=baseuri.host, port=baseuri.port)
akamai.setup_edgegrid(creds)
http = Net::HTTP.new(address=baseuri.host, port=baseuri.port)
http.use_ssl = true
items = Array.wrap(items.first) if items.length == 1
req = Net::HTTP::Post.new(resource, initheader = @@headers).tap do |pq|
if for_ccu_v2?
pq.body = request_body items
else
pq.body = {"objects" => items}.to_json
end
end
timestamp = Akamai::Edgegrid::HTTP.eg_timestamp()
nonce = Akamai::Edgegrid::HTTP.new_nonce()
req['Authorization'] = akamai.make_auth_header(req, timestamp, nonce)
parse_response http.request(req)
end | ruby | {
"resource": ""
} |
q2350 | AkamaiApi::CCU::Purge.Request.request_body | train | def request_body items
{ type: type, action: action, domain: domain, objects: items }.to_json
end | ruby | {
"resource": ""
} |
q2351 | AkamaiApi.CCU.purge | train | def purge action, type, items, opts = {}
request = Purge::Request.new action, type, domain: opts[:domain]
request.execute items
end | ruby | {
"resource": ""
} |
q2352 | StringDirection.DominantStrategy.run | train | def run(string)
string = string.to_s
ltr_count = chars_count(string, ltr_regex)
rtl_count = chars_count(string, rtl_regex)
diff = ltr_count - rtl_count
return ltr if diff > 0
return rtl if diff < 0
nil
end | ruby | {
"resource": ""
} |
q2353 | AkamaiApi::ECCU.FindResponse.file | train | def file
content64 = get_if_handleable(raw[:contents])
{
:content => content64 ? Base64.decode64(content64) : nil,
:size => raw[:file_size].to_i,
:name => get_if_handleable(raw[:filename]),
:md5 => get_if_handleable(raw[:md5_digest])
}.reject { |k, v| v.nil? }
end | ruby | {
"resource": ""
} |
q2354 | AkamaiApi::ECCU.FindResponse.property | train | def property
{
:name => get_if_handleable(raw[:property_name]),
:exact_match => (raw[:property_name_exact_match] == true),
:type => get_if_handleable(raw[:property_type])
}.reject { |k, v| v.nil? }
end | ruby | {
"resource": ""
} |
q2355 | AkamaiApi::ECCU.FindResponse.get_if_handleable | train | def get_if_handleable value
case value
when String then value
when DateTime then value.to_time.utc.xmlschema(3)
else nil
end
end | ruby | {
"resource": ""
} |
q2356 | StringDirection.MarksStrategy.run | train | def run(string)
string = string.to_s
if ltr_mark?(string) && rtl_mark?(string)
bidi
elsif ltr_mark?(string)
ltr
elsif rtl_mark?(string)
rtl
end
end | ruby | {
"resource": ""
} |
q2357 | AhoC.Trie.add | train | def add pattern
node = @root
# If this is a string process each character
if String(pattern) == pattern
pattern.each_char do |char|
if node.goto(char) == nil
node = node.add(char)
else
node = node.goto(char)
end
end
else # Otherwise, pattern should support "each" method.
for item in pattern
if node.goto(item) == nil
node = node.add(item)
else
node = node.goto(item)
end
end
end
if block_given?
node.output = yield pattern
else
node.output = [pattern]
end
end | ruby | {
"resource": ""
} |
q2358 | Draper.CanCanCan.can? | train | def can?(action, subject, *extra_args)
while subject.is_a?(Draper::Decorator)
subject = subject.model
end
super(action, subject, *extra_args)
end | ruby | {
"resource": ""
} |
q2359 | Celerity.Element.method_missing | train | def method_missing(meth, *args, &blk)
assert_exists
meth = selector_to_attribute(meth)
if self.class::ATTRIBUTES.include?(meth) || (self.class == Element && @object.hasAttribute(meth.to_s))
return @object.getAttribute(meth.to_s)
end
Log.warn "Element\#method_missing calling super with #{meth.inspect}"
super
end | ruby | {
"resource": ""
} |
q2360 | ImageRuby.RubyBitmapModl.get_pixel | train | def get_pixel(x,y)
index = (y*@width + x)
pointindex = index*3
Color.from_rgba(
@array[pointindex+2].ord,
@array[pointindex+1].ord,
@array[pointindex].ord,
@alpha ? @alpha[index].ord : 255
)
end | ruby | {
"resource": ""
} |
q2361 | ImageRuby.RubyBitmapModl.set_pixel | train | def set_pixel(x,y,color)
index = (y*@width + x)
pointindex = index*3
@array[pointindex+2] = color.r.chr
@array[pointindex+1] = color.g.chr
@array[pointindex] = color.b.chr
if color.a != 255 then
@alpha = 255.chr*(@height * @width) unless @alpha
@alpha[index] = color.a.chr
end
self
end | ruby | {
"resource": ""
} |
q2362 | Rley.ParseTreeVisitor.traverse_subnodes | train | def traverse_subnodes(aParentNode)
subnodes = aParentNode.subnodes
broadcast(:before_subnodes, aParentNode, subnodes)
# Let's proceed with the visit of subnodes
subnodes.each { |a_node| a_node.accept(self) }
broadcast(:after_subnodes, aParentNode, subnodes)
end | ruby | {
"resource": ""
} |
q2363 | Rley.ParseTreeVisitor.broadcast | train | def broadcast(msg, *args)
subscribers.each do |subscr|
next unless subscr.respond_to?(msg) || subscr.respond_to?(:accept_all)
subscr.send(msg, *args)
end
end | ruby | {
"resource": ""
} |
q2364 | Celerity.Browser.goto | train | def goto(uri, headers = nil)
uri = "http://#{uri}" unless uri =~ %r{://}
request = HtmlUnit::WebRequest.new(::Java::JavaNet::URL.new(uri))
request.setAdditionalHeaders(headers) if headers
request.setCharset(@charset)
rescue_status_code_exception do
self.page = @webclient.getPage(request)
end
url()
end | ruby | {
"resource": ""
} |
q2365 | Celerity.Browser.send_keys | train | def send_keys(keys)
keys = keys.gsub(/\s*/, '').scan(/((?:\{[A-Z]+?\})|.)/u).flatten
keys.each do |key|
element = @page.getFocusedElement
case key
when "{TAB}"
@page.tabToNextElement
when /\w/
element.type(key)
else
raise NotImplementedError
end
end
end | ruby | {
"resource": ""
} |
q2366 | Celerity.Browser.resynchronized | train | def resynchronized(&block)
old_controller = @webclient.ajaxController
@webclient.setAjaxController(::HtmlUnit::NicelyResynchronizingAjaxController.new)
yield self
@webclient.setAjaxController(old_controller)
end | ruby | {
"resource": ""
} |
q2367 | Celerity.Browser.confirm | train | def confirm(bool, &block)
blk = lambda { bool }
listener.add_listener(:confirm, &blk)
yield
listener.remove_listener(:confirm, blk)
end | ruby | {
"resource": ""
} |
q2368 | Celerity.Browser.add_checker | train | def add_checker(checker = nil, &block)
if block_given?
@error_checkers << block
elsif Proc === checker
@error_checkers << checker
else
raise ArgumentError, "argument must be a Proc or block"
end
end | ruby | {
"resource": ""
} |
q2369 | Celerity.Browser.page= | train | def page=(value)
return if @page == value
@page = value
if @page.respond_to?("getDocumentElement")
@object = @page.getDocumentElement || @object
elsif @page.is_a? HtmlUnit::UnexpectedPage
raise UnexpectedPageException, @page.getWebResponse.getContentType
end
render unless @viewer == DefaultViewer
run_error_checks
value
end | ruby | {
"resource": ""
} |
q2370 | Celerity.Browser.enable_event_listener | train | def enable_event_listener
@event_listener ||= lambda do |event|
self.page = @page ? @page.getEnclosingWindow.getEnclosedPage : event.getNewPage
end
listener.add_listener(:web_window_event, &@event_listener)
end | ruby | {
"resource": ""
} |
q2371 | Celerity.Browser.render | train | def render
@viewer.render_html(self.send(@render_type), url)
rescue Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::EPIPE
@viewer = DefaultViewer
end | ruby | {
"resource": ""
} |
q2372 | ImageRuby.PureRubyImageMethods.[] | train | def [] (x,y)
if x.instance_of? Fixnum and y.instance_of? Fixnum
get_pixel(fixx(x),fixy(y))
else
x = (fixx(x)..fixx(x)) if x.instance_of? Fixnum
y = (fixy(y)..fixy(y)) if y.instance_of? Fixnum
if x.instance_of? Range
x = (fixx(x.first)..fixx(x.last))
end
if y.instance_of? Range
y = (fixy(y.first)..fixy(y.last))
end
newimg = Image.new(x.last + 1 - x.first, y.last + 1 - y.first)
width = x.count
(0..y.count).each do |y_|
destpointer = y_*width*3
origpointer = ((y.first + y_)*self.width + x.first)*3
newimg.pixel_data[destpointer..destpointer+width*3] =
self.pixel_data[origpointer..origpointer+width*3]
end
newimg
end
end | ruby | {
"resource": ""
} |
q2373 | ImageRuby.PureRubyImageMethods.[]= | train | def []= (x,y,obj)
if x.instance_of? Fixnum and y.instance_of? Fixnum
set_pixel(x,y,obj)
else
x = (x..x) if x.instance_of? Fixnum
y = (y..y) if y.instance_of? Fixnum
width = x.count
(0..y.count-1).each do |y_|
origpointer = y_*obj.width*3
destpointer = ((y.first + y_)*self.width + x.first)*3
self.pixel_data[destpointer..destpointer+obj.width*3-1] =
obj.pixel_data[origpointer..origpointer+obj.width*3-1]
end
end
end | ruby | {
"resource": ""
} |
q2374 | ImageRuby.PureRubyImageMethods.each_pixel | train | def each_pixel
(0..@width-1).each do |x|
(0..@height-1).each do |y|
yield(x,y,get_pixel(x,y))
end
end
end | ruby | {
"resource": ""
} |
q2375 | ImageRuby.PureRubyImageMethods.map_pixel | train | def map_pixel
Image.new(@width, @height) do |x,y|
yield(x,y,get_pixel(x,y))
end
end | ruby | {
"resource": ""
} |
q2376 | ImageRuby.PureRubyImageMethods.map_pixel! | train | def map_pixel!
each_pixel do |x,y,color|
set_pixel(x,y, yield(x,y,get_pixel(x,y)))
end
self
end | ruby | {
"resource": ""
} |
q2377 | ImageRuby.PureRubyImageMethods.color_replace | train | def color_replace(color1, color2)
newimage = self.dup
newimage.color_replace!(color1,color2)
newimage
end | ruby | {
"resource": ""
} |
q2378 | ImageRuby.PureRubyImageMethods.color_replace! | train | def color_replace!( color1, color2)
strcolor1 = color1.to_s
strcolor2 = color2.to_s
a = color2.a.chr
(0..width*height).each do |i|
if pixel_data[i*3..i*3+2] == strcolor1 then
pixel_data[i*3..i*3+2] = strcolor2
alpha_data[i] = a
end
end
end | ruby | {
"resource": ""
} |
q2379 | ImageRuby.PureRubyImageMethods.mask | train | def mask(color1 = nil)
color1 = color1 || Color.from_rgb(255,255,255)
color2 = color1.dup
color2.a = 0
color_replace(color1,color2)
end | ruby | {
"resource": ""
} |
q2380 | TDiff.Unordered.tdiff_unordered | train | def tdiff_unordered(tree,&block)
return enum_for(:tdiff_unordered,tree) unless block
# check if the nodes differ
unless tdiff_equal(tree)
yield '-', self
yield '+', tree
return self
end
yield ' ', self
tdiff_recursive_unordered(tree,&block)
return self
end | ruby | {
"resource": ""
} |
q2381 | TDiff.Unordered.tdiff_recursive_unordered | train | def tdiff_recursive_unordered(tree,&block)
x = enum_for(:tdiff_each_child,self)
y = enum_for(:tdiff_each_child,tree)
unchanged = {}
changes = []
x.each_with_index do |xi,i|
y.each_with_index do |yj,j|
if (!unchanged.has_value?(yj) && xi.tdiff_equal(yj))
unchanged[xi] = yj
changes << [i, ' ', xi]
break
end
end
unless unchanged.has_key?(xi)
changes << [i, '-', xi]
end
end
y.each_with_index do |yj,j|
unless unchanged.has_value?(yj)
changes << [j, '+', yj]
end
end
# order the changes by index to match the behavior of `tdiff`
changes.sort_by { |change| change[0] }.each do |index,change,node|
yield change, node
end
# explicitly release the changes variable
changes = nil
# recurse down the unchanged nodes
unchanged.each do |xi,yj|
xi.tdiff_recursive_unordered(yj,&block)
end
unchanged = nil
end | ruby | {
"resource": ""
} |
q2382 | OneDrive.V1.get_drive | train | def get_drive drive_id
url = base_api_url + "/drives/#{drive_id}"
@drives = JSON.parse(HTTParty.get(url,headers: set_headers).body)
end | ruby | {
"resource": ""
} |
q2383 | OneDrive.V1.get_users_drive | train | def get_users_drive id_or_user_principal_name
url = base_api_url + "/users/#{id_or_user_principal_name}/drive"
@drives = JSON.parse(HTTParty.get(url,headers: set_headers).body)
end | ruby | {
"resource": ""
} |
q2384 | OneDrive.V1.get_my_drive | train | def get_my_drive
url = base_api_url + "/me/drive"
@my_drive = JSON.parse(HTTParty.get(url,headers: set_headers).body)
end | ruby | {
"resource": ""
} |
q2385 | OneDrive.V1.get_library_for_site | train | def get_library_for_site site_id
url = base_api_url + "/sites/#{site_id}/drive"
@drives = JSON.parse(HTTParty.get(url,headers: set_headers).body)
end | ruby | {
"resource": ""
} |
q2386 | OneDrive.V1.get_special_folder_by_name | train | def get_special_folder_by_name name
url = base_api_url + "/me/drive/special/#{name}"
@special_drive = JSON.parse(HTTParty.get(url,headers: set_headers).body)
end | ruby | {
"resource": ""
} |
q2387 | Celerity.TableRow.child_cell | train | def child_cell(index)
assert_exists
if (index - Celerity.index_offset) >= @cells.length
raise UnknownCellException, "Unable to locate a cell at index #{index}"
end
TableCell.new(self, :object, @cells[index - Celerity.index_offset])
end | ruby | {
"resource": ""
} |
q2388 | Celerity.Table.to_a | train | def to_a
assert_exists
# @object.getRows.map do |table_row|
# table_row.getCells.map { |td| td.asText.strip }
# end
rows.map do |table_row|
table_row.map { |td| td.text }
end
end | ruby | {
"resource": ""
} |
q2389 | Skinny.Websocket.start! | train | def start!
# Steal any remaining data from rack.input
@buffer = @env[Thin::Request::RACK_INPUT].read + @buffer
# Remove references to Thin connection objects, freeing memory
@env.delete Thin::Request::RACK_INPUT
@env.delete Thin::Request::ASYNC_CALLBACK
@env.delete Thin::Request::ASYNC_CLOSE
# Figure out which version we're using
@version = @env['HTTP_SEC_WEBSOCKET_VERSION']
@version ||= "hixie-76" if @env.has_key?('HTTP_SEC_WEBSOCKET_KEY1') and @env.has_key?('HTTP_SEC_WEBSOCKET_KEY2')
@version ||= "hixie-75"
# Pull out the details we care about
@origin ||= @env['HTTP_SEC_WEBSOCKET_ORIGIN'] || @env['HTTP_ORIGIN']
@location ||= "ws#{secure? ? 's' : ''}://#{@env['HTTP_HOST']}#{@env['REQUEST_PATH']}"
@protocol ||= @env['HTTP_SEC_WEBSOCKET_PROTOCOL'] || @env['HTTP_WEBSOCKET_PROTOCOL']
EM.next_tick { callback :on_start, self rescue error! "Error in start callback" }
# Queue up the actual handshake
EM.next_tick method :handshake!
@state = :started
# Return self so we can be used as a response
self
rescue
error! "Error starting connection"
end | ruby | {
"resource": ""
} |
q2390 | Skinny.Websocket.send_frame | train | def send_frame opcode, payload="", masked=false
payload = payload.dup.force_encoding("ASCII-8BIT") if payload.respond_to? :force_encoding
payload_length = payload.bytesize
# We don't support continuations (yet), so always send fin
fin_byte = 0x80
send_data [fin_byte | opcode].pack("C")
# We shouldn't be sending mask, we're a server only
masked_byte = masked ? 0x80 : 0x00
if payload_length <= 125
send_data [masked_byte | payload_length].pack("C")
elsif payload_length < 2 ** 16
send_data [masked_byte | 126].pack("C")
send_data [payload_length].pack("n")
else
send_data [masked_byte | 127].pack("C")
send_data [payload_length / (2 ** 32), payload_length % (2 ** 32)].pack("NN")
end
if payload_length
if masked
mask_key = Array.new(4) { rand(256) }.pack("C*")
send_data mask_key
payload = mask payload, mask_key
end
send_data payload
end
end | ruby | {
"resource": ""
} |
q2391 | Skinny.Websocket.finish! | train | def finish!
if hixie_75? or hixie_76?
send_data "\xff\x00"
else
send_frame OPCODE_CLOSE
end
EM.next_tick { callback(:on_finish, self) rescue error! "Error in finish callback" }
EM.next_tick { close_connection_after_writing }
@state = :finished
rescue
error! "Error finishing WebSocket connection"
end | ruby | {
"resource": ""
} |
q2392 | Celerity.XpathSupport.elements_by_xpath | train | def elements_by_xpath(xpath)
assert_exists
objects = @page.getByXPath(xpath)
# should use an ElementCollection here?
objects.map { |o| element_from_dom_node(o) }
end | ruby | {
"resource": ""
} |
q2393 | Celerity.XpathSupport.element_from_dom_node | train | def element_from_dom_node(obj, identifier_string = nil)
element_class = Util.htmlunit2celerity(obj.class) || Element
element = element_class.new(self, :object, obj)
element.identifier_string = identifier_string
element.extend(ClickableElement) unless element.is_a?(ClickableElement)
element
end | ruby | {
"resource": ""
} |
q2394 | Celerity.TextField.contains_text | train | def contains_text(expected_text)
assert_exists
case expected_text
when Regexp
value() =~ expected_text
when String
value().index(expected_text)
else
raise TypeError, "expected String or Regexp, got #{expected_text.inspect}:#{expected_text.class}"
end
end | ruby | {
"resource": ""
} |
q2395 | SimpleCov.ArrayMergeHelper.merge_resultset | train | def merge_resultset(array)
new_array = dup
array.each_with_index do |element, i|
pair = [element, new_array[i]]
new_array[i] = if pair.any?(&:nil?) && pair.map(&:to_i).all?(&:zero?)
nil
else
element.to_i + new_array[i].to_i
end
end
new_array
end | ruby | {
"resource": ""
} |
q2396 | Celerity.Image.file_created_date | train | def file_created_date
assert_exists
web_response = @object.getWebResponse(true)
Time.parse(web_response.getResponseHeaderValue("Last-Modified").to_s)
end | ruby | {
"resource": ""
} |
q2397 | Celerity.Image.save | train | def save(filename)
assert_exists
image_reader = @object.getImageReader
file = java.io.File.new(filename)
buffered_image = image_reader.read(0);
javax.imageio.ImageIO.write(buffered_image, image_reader.getFormatName(), file);
end | ruby | {
"resource": ""
} |
q2398 | Celerity.Util.matches? | train | def matches?(string, what)
Regexp === what ? string.strip =~ what : string == what.to_s
end | ruby | {
"resource": ""
} |
q2399 | Celerity.Listener.add_listener | train | def add_listener(type, &block)
case type
when :status
@webclient.setStatusHandler(self)
when :alert
@webclient.setAlertHandler(self)
when :attachment
@webclient.setAttachmentHandler(self)
when :web_window_event
@webclient.addWebWindowListener(self)
when :html_parser
@webclient.setHTMLParserListener(self)
when :incorrectness
@webclient.setIncorrectnessListener(self)
when :confirm
@webclient.setConfirmHandler(self)
when :prompt
@webclient.setPromptHandler(self)
else
raise ArgumentError, "unknown listener type #{type.inspect}"
end
@procs[type] << block
end | ruby | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.