_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3
values | text stringlengths 66 10.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q24500 | Zlib.ZStream.get_bits | train | def get_bits need
val = @bit_bucket
while @bit_count < need
val |= (@input_buffer[@in_pos+=1] << @bit_count)
@bit_count += 8
end
@bit_bucket = val >> need
@bit_count -= need
val & ((1 << need) - 1)
end | ruby | {
"resource": ""
} |
q24501 | Zlib.Inflate.inflate | train | def inflate zstring=nil
@zstring = zstring unless zstring.nil?
#We can't use unpack, IronRuby doesn't have it yet.
@zstring.each_byte {|b| @input_buffer << b}
unless @rawdeflate then
compression_method_and_flags = @input_buffer[@in_pos+=1]
flags = @input_buffer[@in_pos+=1]
#CMF and FLG, ... | ruby | {
"resource": ""
} |
q24502 | Jekyll.Convertible.do_layout | train | def do_layout(payload, layouts)
pre_render if respond_to?(:pre_render) && hooks
if respond_to?(:merge_payload) && hooks
old_do_layout(merge_payload(payload.dup), layouts)
else
old_do_layout(payload, layouts)
end
post_render if respond_to?(:post_render) && hooks
end | ruby | {
"resource": ""
} |
q24503 | Jekyll.Site.site_payload | train | def site_payload
@cached_payload = begin
payload = old_site_payload
site_hooks.each do |hook|
p = hook.merge_payload(payload, self)
next unless p && p.is_a?(Hash)
payload = Jekyll::Utils.deep_merge_hashes(payload, p)
end
payload
end
end | ruby | {
"resource": ""
} |
q24504 | KnnBall.Ball.distance | train | def distance(coordinates)
coordinates = coordinates.center if coordinates.respond_to?(:center)
Math.sqrt([center, coordinates].transpose.map {|a,b| (b - a)**2}.reduce {|d1,d2| d1 + d2})
end | ruby | {
"resource": ""
} |
q24505 | Tool.Decoration.decorate | train | def decorate(block = nil, name: "generated", &callback)
@decorations << callback
if block
alias_name = "__" << name.to_s.downcase.gsub(/[^a-z]+/, ?_) << ?1
alias_name = alias_name.succ while private_method_defined? alias_name or method_defined? alias_name
without_decorations { defin... | ruby | {
"resource": ""
} |
q24506 | Scrapix.VBulletin.find | train | def find
reset; return @images unless @url
@page_no = @options["start"]
until @images.count > @options["total"] || thread_has_ended?
page = @agent.get "#{@url}&page=#{@page_no}"
puts "[VERBOSE] Searching: #{@url}&page=#{@page_no}" if @options["verbose"] && options["cli"]
s... | ruby | {
"resource": ""
} |
q24507 | Danger.DangerKotlinDetekt.detekt | train | def detekt(inline_mode: false)
unless skip_gradle_task || gradlew_exists?
fail("Could not find `gradlew` inside current directory")
return
end
unless SEVERITY_LEVELS.include?(severity)
fail("'#{severity}' is not a valid value for `severity` parameter.")
return
en... | ruby | {
"resource": ""
} |
q24508 | WinRM.WinRMWebService.get_builder_obj | train | def get_builder_obj(shell_id, command_id, &block)
body = { "#{NS_WIN_SHELL}:DesiredStream" => 'stdout stderr',
:attributes! => {"#{NS_WIN_SHELL}:DesiredStream" => {'CommandId' => command_id}}}
builder = Builder::XmlMarkup.new
builder.instruct!(:xml, :encoding => 'UTF-8')
builder.tag... | ruby | {
"resource": ""
} |
q24509 | WinRM.WinRMWebService.get_command_output | train | def get_command_output(shell_id, command_id, &block)
done_elems = []
output = Output.new
while done_elems.empty?
resp_doc = nil
builder = get_builder_obj(shell_id, command_id, &block)
request_msg = builder.target!
resp_doc = send_get_output_message(request_msg)... | ruby | {
"resource": ""
} |
q24510 | Hippo::Concerns.ApiAttributeAccess.setting_attribute_is_allowed? | train | def setting_attribute_is_allowed?(name, user)
return false unless user.can_write?(self, name)
(self.whitelisted_attributes && self.whitelisted_attributes.has_key?( name.to_sym)) ||
(
self.attribute_names.include?( name.to_s ) &&
( self.blacklisted_attribut... | ruby | {
"resource": ""
} |
q24511 | Turbot.Helpers.turbot_api_parameters | train | def turbot_api_parameters
uri = URI.parse(host)
{
:host => uri.host,
:port => uri.port,
:scheme => uri.scheme,
}
end | ruby | {
"resource": ""
} |
q24512 | Pling.Gateway.handles? | train | def handles?(device)
device = Pling._convert(device, :device)
self.class.handled_types.include?(device.type)
end | ruby | {
"resource": ""
} |
q24513 | Elparser.SExpList.to_h | train | def to_h
ret = Hash.new
@list.each do |i|
ret[i.car.to_ruby] = i.cdr.to_ruby
end
ret
end | ruby | {
"resource": ""
} |
q24514 | Elparser.Parser.parse | train | def parse(str)
if str.nil? || str == ""
raise ParserError.new("Empty input",0,"")
end
s = StringScanner.new str
@tokens = []
until s.eos?
s.skip(/\s+/) ? nil :
s.scan(/\A[-+]?[0-9]*\.[0-9]+(e[-+]?[0-9]+)?/i) ? (@tokens << [:FLOAT, s.matched]) :
s.scan(... | ruby | {
"resource": ""
} |
q24515 | Elparser.Parser.normalize | train | def normalize(ast)
if ast.class == SExpSymbol
case ast.name
when "nil"
return SExpNil.new
else
return ast
end
elsif ast.cons? then
ast.visit do |i|
normalize(i)
end
end
return ast
end | ruby | {
"resource": ""
} |
q24516 | MemoryIO.IO.write | train | def write(objects, from: nil, as: nil)
stream.pos = from if from
as ||= objects.class if objects.class.ancestors.include?(MemoryIO::Types::Type)
return stream.write(objects) if as.nil?
conv = to_proc(as, :write)
Array(objects).map { |o| conv.call(stream, o) }
end | ruby | {
"resource": ""
} |
q24517 | MemoryIO.Util.underscore | train | def underscore(str)
return '' if str.empty?
str = str.gsub('::', '/')
str.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
str.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
str.downcase!
str
end | ruby | {
"resource": ""
} |
q24518 | MemoryIO.Util.safe_eval | train | def safe_eval(str, **vars)
return str if str.is_a?(Integer)
# dentaku 2 doesn't support hex
str = str.gsub(/0x[0-9a-zA-Z]+/) { |c| c.to_i(16) }
Dentaku::Calculator.new.store(vars).evaluate(str)
end | ruby | {
"resource": ""
} |
q24519 | MemoryIO.Util.unpack | train | def unpack(str)
str.bytes.reverse.reduce(0) { |s, c| s * 256 + c }
end | ruby | {
"resource": ""
} |
q24520 | MemoryIO.Util.pack | train | def pack(val, b)
Array.new(b) { |i| (val >> (i * 8)) & 0xff }.pack('C*')
end | ruby | {
"resource": ""
} |
q24521 | KnnBall.KDTree.nearest | train | def nearest(coord, options = {})
return nil if root.nil?
return nil if coord.nil?
results = (options[:results] ? options[:results] : ResultSet.new({limit: options[:limit] || 1}))
root_ball = options[:root] || root
# keep the stack while finding the leaf best match.
parents = []
... | ruby | {
"resource": ""
} |
q24522 | KnnBall.KDTree.parent_ball | train | def parent_ball(coord)
current = root
d_idx = current.dimension-1
result = nil
while(result.nil?)
if(coord[d_idx] <= current.center[d_idx])
if current.left.nil?
result = current
else
current = current.left
end
else
i... | ruby | {
"resource": ""
} |
q24523 | Teamspeak.Client.command | train | def command(cmd, params = {}, options = '')
flood_control
out = ''
response = ''
out += cmd
params.each_pair do |key, value|
out += " #{key}=#{encode_param(value.to_s)}"
end
out += ' ' + options
@sock.puts out
if cmd == 'servernotifyregister'
2... | ruby | {
"resource": ""
} |
q24524 | TmlRails.ActionViewExtension.trh | train | def trh(tokens = {}, options = {}, &block)
return '' unless block_given?
label = capture(&block)
tokenizer = Tml::Tokenizers::Dom.new(tokens, options)
tokenizer.translate(label).html_safe
end | ruby | {
"resource": ""
} |
q24525 | TmlRails.ActionViewExtension.tml_language_flag_tag | train | def tml_language_flag_tag(lang = tml_current_language, opts = {})
return '' unless tml_application.feature_enabled?(:language_flags)
html = image_tag(lang.flag_url, :style => (opts[:style] || 'vertical-align:middle;'), :title => lang.native_name)
html << ' '.html_safe
html.html_safe
... | ruby | {
"resource": ""
} |
q24526 | TmlRails.ActionViewExtension.tml_language_name_tag | train | def tml_language_name_tag(lang = tml_current_language, opts = {})
show_flag = opts[:flag].nil? ? true : opts[:flag]
name_type = opts[:language].nil? ? :english : opts[:language].to_sym # :full, :native, :english, :locale, :both
html = []
html << "<span style='white-space: nowrap'>"
html <... | ruby | {
"resource": ""
} |
q24527 | TmlRails.ActionViewExtension.tml_language_selector_tag | train | def tml_language_selector_tag(type = nil, opts = {})
return unless Tml.config.enabled?
type ||= :default
type = :dropdown if type == :select
opts = opts.collect{|key, value| "data-tml-#{key}='#{value}'"}.join(' ')
"<div data-tml-language-selector='#{type}' #{opts}></div>".html_safe
e... | ruby | {
"resource": ""
} |
q24528 | TmlRails.ActionViewExtension.tml_style_attribute_tag | train | def tml_style_attribute_tag(attr_name = 'float', default = 'right', lang = tml_current_language)
return "#{attr_name}:#{default}".html_safe if Tml.config.disabled?
"#{attr_name}:#{lang.align(default)}".html_safe
end | ruby | {
"resource": ""
} |
q24529 | Effigy.ExampleElementTransformer.clone_and_transform_each | train | def clone_and_transform_each(collection, &block)
collection.inject(element_to_clone) do |sibling, item|
item_element = clone_with_item(item, &block)
sibling.add_next_sibling(item_element)
end
end | ruby | {
"resource": ""
} |
q24530 | Effigy.ExampleElementTransformer.clone_with_item | train | def clone_with_item(item, &block)
item_element = element_to_clone.dup
view.find(item_element) { yield(item) }
item_element
end | ruby | {
"resource": ""
} |
q24531 | Effigy.View.text | train | def text(selector, content)
select(selector).each do |node|
node.content = content
end
end | ruby | {
"resource": ""
} |
q24532 | Effigy.View.attr | train | def attr(selector, attributes_or_attribute_name, value = nil)
attributes = attributes_or_attribute_name.to_effigy_attributes(value)
select(selector).each do |element|
element.merge!(attributes)
end
end | ruby | {
"resource": ""
} |
q24533 | Effigy.View.replace_each | train | def replace_each(selector, collection, &block)
selected_elements = select(selector)
ExampleElementTransformer.new(self, selected_elements).replace_each(collection, &block)
end | ruby | {
"resource": ""
} |
q24534 | Effigy.View.add_class | train | def add_class(selector, *class_names)
select(selector).each do |element|
class_list = ClassList.new(element)
class_list.add class_names
end
end | ruby | {
"resource": ""
} |
q24535 | Effigy.View.remove_class | train | def remove_class(selector, *class_names)
select(selector).each do |element|
class_list = ClassList.new(element)
class_list.remove(class_names)
end
end | ruby | {
"resource": ""
} |
q24536 | Effigy.View.html | train | def html(selector, inner_html)
select(selector).each do |node|
node.inner_html = inner_html
end
end | ruby | {
"resource": ""
} |
q24537 | Effigy.View.append | train | def append(selector, html_to_append)
select(selector).each { |node| node.append_fragment html_to_append }
end | ruby | {
"resource": ""
} |
q24538 | Effigy.View.find | train | def find(selector)
if block_given?
old_context = @current_context
@current_context = select(selector)
yield
@current_context = old_context
else
Selection.new(self, selector)
end
end | ruby | {
"resource": ""
} |
q24539 | Effigy.View.clone_element_with_item | train | def clone_element_with_item(original_element, item, &block)
item_element = original_element.dup
find(item_element) { yield(item) }
item_element
end | ruby | {
"resource": ""
} |
q24540 | RETerm.ComponentInput.handle_input | train | def handle_input(*input)
while ch = next_ch(input)
quit = QUIT_CONTROLS.include?(ch)
enter = ENTER_CONTROLS.include?(ch)
inc = INC_CONTROLS.include?(ch)
dec = DEC_CONTROLS.include?(ch)
break if shutdown? ||
(quit && (!enter || quit_on_enter?))
... | ruby | {
"resource": ""
} |
q24541 | BabelBridge.RuleNode.match | train | def match(pattern_element)
@num_match_attempts += 1
return :no_pattern_element unless pattern_element
return :skipped if pattern_element.delimiter &&
(
if last_match
last_match.delimiter # don't match two delimiters in a row
else
@num_match_attempts > 1 # don't matc... | ruby | {
"resource": ""
} |
q24542 | BabelBridge.RuleNode.attempt_match | train | def attempt_match
matches_before = matches.length
match_length_before = match_length
(yield && match_length > match_length_before).tap do |success| # match_length test returns failure if no progress is made (our source position isn't advanced)
unless success
@matches = matches[0..matches_befo... | ruby | {
"resource": ""
} |
q24543 | PeoplePlacesThings.StreetAddress.to_canonical_s | train | def to_canonical_s
parts = []
parts << self.number.upcase if self.number
parts << StreetAddress.string_for(self.pre_direction, :short).upcase if self.pre_direction
parts << StreetAddress.string_for(StreetAddress.find_token(self.ordinal, ORDINALS), :short).upcase if self.ordinal
canonical_n... | ruby | {
"resource": ""
} |
q24544 | ActiveCucumber.Cucumparer.to_horizontal_table | train | def to_horizontal_table
mortadella = Mortadella::Horizontal.new headers: @cucumber_table.headers
@database_content = @database_content.all if @database_content.respond_to? :all
@database_content.each do |record|
cucumberator = cucumberator_for record
mortadella << @cucumber_table.heade... | ruby | {
"resource": ""
} |
q24545 | ActiveCucumber.Cucumparer.to_vertical_table | train | def to_vertical_table object
mortadella = Mortadella::Vertical.new
cucumberator = cucumberator_for object
@cucumber_table.rows_hash.each do |key, _|
mortadella[key] = cucumberator.value_for key
end
mortadella.table
end | ruby | {
"resource": ""
} |
q24546 | Barrister.Server.handle_json | train | def handle_json(json_str)
begin
req = JSON::parse(json_str)
resp = handle(req)
rescue JSON::ParserError => e
resp = err_resp({ }, -32700, "Unable to parse JSON: #{e.message}")
end
# Note the `:ascii_only` usage here. Important.
return JSON::generate(resp, { ... | ruby | {
"resource": ""
} |
q24547 | Barrister.Server.handle | train | def handle(req)
if req.kind_of?(Array)
resp_list = [ ]
req.each do |r|
resp_list << handle_single(r)
end
return resp_list
else
return handle_single(req)
end
end | ruby | {
"resource": ""
} |
q24548 | Barrister.Server.handle_single | train | def handle_single(req)
method = req["method"]
if !method
return err_resp(req, -32600, "No method provided on request")
end
# Special case - client is requesting the IDL bound to this server, so
# we return it verbatim. No further validation is needed in this case.
if method... | ruby | {
"resource": ""
} |
q24549 | Barrister.Client.init_proxies | train | def init_proxies
singleton = class << self; self end
@contract.interfaces.each do |iface|
proxy = InterfaceProxy.new(self, iface)
singleton.send :define_method, iface.name do
return proxy
end
end
end | ruby | {
"resource": ""
} |
q24550 | Barrister.Client.request | train | def request(method, params)
req = { "jsonrpc" => "2.0", "id" => Barrister::rand_str(22), "method" => method }
if params
req["params"] = params
end
# We always validate that the method is valid
err_resp, iface, func = @contract.resolve_method(req)
if err_resp != nil
... | ruby | {
"resource": ""
} |
q24551 | Barrister.HttpTransport.request | train | def request(req)
json_str = JSON::generate(req, { :ascii_only=>true })
http = Net::HTTP.new(@uri.host, @uri.port)
request = Net::HTTP::Post.new(@uri.request_uri)
request.body = json_str
request["Content-Type"] = "application/json"
response = http.request(request)
if response... | ruby | {
"resource": ""
} |
q24552 | Barrister.BatchClient.send | train | def send
if @trans.sent
raise "Batch has already been sent!"
end
@trans.sent = true
requests = @trans.requests
if requests.length < 1
raise RpcException.new(-32600, "Batch cannot be empty")
end
# Send request batch to server
resp_list = @parent.trans.re... | ruby | {
"resource": ""
} |
q24553 | Barrister.Contract.resolve_method | train | def resolve_method(req)
method = req["method"]
iface_name, func_name = Barrister::parse_method(method)
if iface_name == nil
return err_resp(req, -32601, "Method not found: #{method}")
end
iface = interface(iface_name)
if !iface
return err_resp(req, -32601, "Int... | ruby | {
"resource": ""
} |
q24554 | Barrister.Contract.validate_params | train | def validate_params(req, func)
params = req["params"]
if !params
params = []
end
e_params = func.params.length
r_params = params.length
if e_params != r_params
msg = "Function #{func.name}: Param length #{r_params} != expected length: #{e_params}"
return err... | ruby | {
"resource": ""
} |
q24555 | Barrister.Contract.validate_result | train | def validate_result(req, result, func)
invalid = validate("", func.returns, func.returns["is_array"], result)
if invalid == nil
return nil
else
return err_resp(req, -32001, invalid)
end
end | ruby | {
"resource": ""
} |
q24556 | Barrister.Contract.validate | train | def validate(name, expected, expect_array, val)
# If val is nil, then check if the IDL allows this type to be optional
if val == nil
if expected["optional"]
return nil
else
return "#{name} cannot be null"
end
else
exp_type = expected["type"]
... | ruby | {
"resource": ""
} |
q24557 | Barrister.Contract.all_struct_fields | train | def all_struct_fields(arr, struct)
struct["fields"].each do |f|
arr << f
end
if struct["extends"]
parent = @structs[struct["extends"]]
if parent
return all_struct_fields(arr, parent)
end
end
return arr
end | ruby | {
"resource": ""
} |
q24558 | Rusen.Notifier.notify | train | def notify(exception, request = {}, environment = {}, session = {})
begin
notification = Notification.new(exception, request, environment, session)
@notifiers.each do |notifier|
notifier.notify(notification)
end
# We need to ignore all the exceptions thrown by the notifie... | ruby | {
"resource": ""
} |
q24559 | Hashie.Mash.[]= | train | def []=(key, value)
coerced_value = coercion(key).present? ? coercion(key).call(value) : value
old_setter(key, coerced_value)
end | ruby | {
"resource": ""
} |
q24560 | RETerm.Panel.show | train | def show
Ncurses::Panel.top_panel(@panel)
update_reterm
@@registry.values.each { |panel|
if panel == self
dispatch :panel_show
else
panel.dispatch :panel_hide
end
}
end | ruby | {
"resource": ""
} |
q24561 | Related.Helpers.generate_id | train | def generate_id
Base64.encode64(
Digest::MD5.digest("#{Time.now}-#{rand}")
).gsub('/','x').gsub('+','y').gsub('=','').strip
end | ruby | {
"resource": ""
} |
q24562 | Chozo::Mixin.ParamsValidate._pv_opts_lookup | train | def _pv_opts_lookup(opts, key)
if opts.has_key?(key.to_s)
opts[key.to_s]
elsif opts.has_key?(key.to_sym)
opts[key.to_sym]
else
nil
end
end | ruby | {
"resource": ""
} |
q24563 | Chozo::Mixin.ParamsValidate._pv_required | train | def _pv_required(opts, key, is_required=true)
if is_required
if (opts.has_key?(key.to_s) && !opts[key.to_s].nil?) ||
(opts.has_key?(key.to_sym) && !opts[key.to_sym].nil?)
true
else
raise ValidationFailed, "Required argument #{key} is missing!"
... | ruby | {
"resource": ""
} |
q24564 | Chozo::Mixin.ParamsValidate._pv_respond_to | train | def _pv_respond_to(opts, key, method_name_list)
value = _pv_opts_lookup(opts, key)
unless value.nil?
Array(method_name_list).each do |method_name|
unless value.respond_to?(method_name)
raise ValidationFailed, "Option #{key} must have a #{method_name} method!"
... | ruby | {
"resource": ""
} |
q24565 | Chozo::Mixin.ParamsValidate._pv_default | train | def _pv_default(opts, key, default_value)
value = _pv_opts_lookup(opts, key)
if value == nil
opts[key] = default_value
end
end | ruby | {
"resource": ""
} |
q24566 | Chozo::Mixin.ParamsValidate._pv_regex | train | def _pv_regex(opts, key, regex)
value = _pv_opts_lookup(opts, key)
if value != nil
passes = false
[ regex ].flatten.each do |r|
if value != nil
if r.match(value.to_s)
passes = true
end
end
end
unl... | ruby | {
"resource": ""
} |
q24567 | Chozo::Mixin.ParamsValidate._pv_callbacks | train | def _pv_callbacks(opts, key, callbacks)
raise ArgumentError, "Callback list must be a hash!" unless callbacks.kind_of?(Hash)
value = _pv_opts_lookup(opts, key)
if value != nil
callbacks.each do |message, zeproc|
if zeproc.call(value) != true
raise ValidationFa... | ruby | {
"resource": ""
} |
q24568 | Chozo::Mixin.ParamsValidate._pv_name_attribute | train | def _pv_name_attribute(opts, key, is_name_attribute=true)
if is_name_attribute
if opts[key] == nil
opts[key] = self.instance_variable_get("@name")
end
end
end | ruby | {
"resource": ""
} |
q24569 | BeakerAnswers.Version20162.answer_hiera | train | def answer_hiera
# Render pretty JSON, because it is a subset of HOCON
json = JSON.pretty_generate(answers)
hocon = Hocon::Parser::ConfigDocumentFactory.parse_string(json)
hocon.render
end | ruby | {
"resource": ""
} |
q24570 | TripIt.Base.convertDT | train | def convertDT(tpitDT)
return nil if tpitDT.nil?
date = tpitDT["date"]
time = tpitDT["time"]
offset = tpitDT["utc_offset"]
if time.nil?
# Just return a date
Date.parse(date)
elsif date.nil?
# Or just a time
Time.parse(time)
else
# Ideally ... | ruby | {
"resource": ""
} |
q24571 | Rscons.Builder.standard_build | train | def standard_build(short_cmd_string, target, command, sources, env, cache)
unless cache.up_to_date?(target, command, sources, env)
unless Rscons.phony_target?(target)
cache.mkdir_p(File.dirname(target))
FileUtils.rm_f(target)
end
return false unless env.execute(short_cm... | ruby | {
"resource": ""
} |
q24572 | RETerm.Window.finalize! | train | def finalize!
erase
@@registry.delete(self)
children.each { |c|
del_child c
}
cdk_scr.destroy if cdk?
component.finalize! if component?
end | ruby | {
"resource": ""
} |
q24573 | RETerm.Window.child_containing | train | def child_containing(x, y, z)
found = nil
children.find { |c|
next if found
# recursively descend into layout children
if c.component.kind_of?(Layout)
found = c.child_containing(x, y, z)
else
found =
c.total_x <= x && c.total_y <= y && # c.z ... | ruby | {
"resource": ""
} |
q24574 | RETerm.Window.erase | train | def erase
children.each { |c|
c.erase
}
@win.werase if @win
component.component.erase if cdk? && component? && component.init?
end | ruby | {
"resource": ""
} |
q24575 | RETerm.Window.no_border! | train | def no_border!
@win.border(' '.ord, ' '.ord, ' '.ord, ' '.ord, ' '.ord, ' '.ord, ' '.ord, ' '.ord)
end | ruby | {
"resource": ""
} |
q24576 | RETerm.Window.sync_getch | train | def sync_getch
return self.getch unless sync_enabled?
c = -1
while c == -1 && !shutdown?
c = self.getch
run_sync!
end
c
end | ruby | {
"resource": ""
} |
q24577 | RETerm.Window.colors= | train | def colors=(c)
@colors = c.is_a?(ColorPair) ? c : ColorPair.for(c).first
@win.bkgd(Ncurses.COLOR_PAIR(@colors.id)) unless @win.nil?
component.colors = @colors if component?
children.each { |ch|
ch.colors = c
}
end | ruby | {
"resource": ""
} |
q24578 | RETerm.Window.dimensions | train | def dimensions
rows = []
cols = []
@win.getmaxyx(rows, cols)
rows = rows.first
cols = cols.first
[rows, cols]
end | ruby | {
"resource": ""
} |
q24579 | ChefWorkflow.IPSupport.next_ip | train | def next_ip(arg)
octets = arg.split(/\./, 4).map(&:to_i)
octets[3] += 1
raise "out of ips!" if octets[3] > 255
return octets.map(&:to_s).join(".")
end | ruby | {
"resource": ""
} |
q24580 | SanitizeAttributes.InstanceMethods.sanitize! | train | def sanitize!
self.class.sanitizable_attributes.each do |attr_name|
cleaned_text = process_text_via_sanitization_method(self.send(attr_name), attr_name)
self.send((attr_name.to_s + '='), cleaned_text)
end
end | ruby | {
"resource": ""
} |
q24581 | ActiveCucumber.Creator.factorygirl_attributes | train | def factorygirl_attributes
symbolize_attributes!
@attributes.each do |key, value|
next unless respond_to?(method = method_name(key))
if (result = send method, value) || value.nil?
@attributes[key] = result if @attributes.key? key
else
@attributes.delete key
... | ruby | {
"resource": ""
} |
q24582 | Configurate.LookupChain.add_provider | train | def add_provider(provider, *args)
unless provider.respond_to?(:instance_methods) && provider.instance_methods.include?(:lookup)
raise ArgumentError, "the given provider does not respond to lookup"
end
@provider << provider.new(*args)
end | ruby | {
"resource": ""
} |
q24583 | Configurate.LookupChain.lookup | train | def lookup(setting, *args)
setting = SettingPath.new setting if setting.is_a? String
@provider.each do |provider|
begin
return special_value_or_string(provider.lookup(setting.clone, *args))
rescue SettingNotFoundError; end
end
nil
end | ruby | {
"resource": ""
} |
q24584 | Rscons.Environment.build_dir | train | def build_dir(src_dir, obj_dir)
if src_dir.is_a?(String)
src_dir = src_dir.gsub("\\", "/").sub(%r{/*$}, "")
end
@build_dirs.unshift([src_dir, obj_dir])
end | ruby | {
"resource": ""
} |
q24585 | Rscons.Environment.process | train | def process
cache = Cache.instance
failure = nil
begin
while @job_set.size > 0 or @threaded_commands.size > 0
if failure
@job_set.clear!
job = nil
else
targets_still_building = @threaded_commands.map do |tc|
tc.build_operat... | ruby | {
"resource": ""
} |
q24586 | Rscons.Environment.expand_varref | train | def expand_varref(varref, extra_vars = nil)
vars = if extra_vars.nil?
@varset
else
@varset.merge(extra_vars)
end
lambda_args = [env: self, vars: vars]
vars.expand_varref(varref, lambda_args)
end | ruby | {
"resource": ""
} |
q24587 | Rscons.Environment.execute | train | def execute(short_desc, command, options = {})
print_builder_run_message(short_desc, command)
env_args = options[:env] ? [options[:env]] : []
options_args = options[:options] ? [options[:options]] : []
system(*env_args, *Rscons.command_executer, *command, *options_args).tap do |result|
u... | ruby | {
"resource": ""
} |
q24588 | Rscons.Environment.method_missing | train | def method_missing(method, *args)
if @builders.has_key?(method.to_s)
target, sources, vars, *rest = args
vars ||= {}
unless vars.is_a?(Hash) or vars.is_a?(VarSet)
raise "Unexpected construction variable set: #{vars.inspect}"
end
builder = @builders[method.to_s]
... | ruby | {
"resource": ""
} |
q24589 | Rscons.Environment.depends | train | def depends(target, *user_deps)
target = expand_varref(target.to_s)
user_deps = user_deps.map {|ud| expand_varref(ud)}
@user_deps[target] ||= []
@user_deps[target] = (@user_deps[target] + user_deps).uniq
build_after(target, user_deps)
end | ruby | {
"resource": ""
} |
q24590 | Rscons.Environment.build_sources | train | def build_sources(sources, suffixes, cache, vars)
sources.map do |source|
if source.end_with?(*suffixes)
source
else
converted = nil
suffixes.each do |suffix|
converted_fname = get_build_fname(source, suffix)
if builder = find_builder_for(conve... | ruby | {
"resource": ""
} |
q24591 | Rscons.Environment.register_builds | train | def register_builds(target, sources, suffixes, vars, options = {})
options[:features] ||= []
@registered_build_dependencies[target] ||= Set.new
sources.map do |source|
if source.end_with?(*suffixes)
source
else
output_fname = nil
suffixes.each do |suffix|
... | ruby | {
"resource": ""
} |
q24592 | Rscons.Environment.run_builder | train | def run_builder(builder, target, sources, cache, vars, options = {})
vars = @varset.merge(vars)
build_operation = {
builder: builder,
target: target,
sources: sources,
cache: cache,
env: self,
vars: vars,
setup_info: options[:setup_info]
}
... | ruby | {
"resource": ""
} |
q24593 | Rscons.Environment.expand_path | train | def expand_path(path)
if Rscons.phony_target?(path)
path
elsif path.is_a?(Array)
path.map do |path|
expand_path(path)
end
else
path.sub(%r{^\^(?=[\\/])}, @build_root).gsub("\\", "/")
end
end | ruby | {
"resource": ""
} |
q24594 | Rscons.Environment.shell | train | def shell(command)
shell_cmd =
if self["SHELL"]
flag = self["SHELLFLAG"] || (self["SHELL"] == "cmd" ? "/c" : "-c")
[self["SHELL"], flag]
else
Rscons.get_system_shell
end
IO.popen([*shell_cmd, command]) do |io|
io.read
end
end | ruby | {
"resource": ""
} |
q24595 | Rscons.Environment.merge_flags | train | def merge_flags(flags)
flags.each_pair do |key, val|
if self[key].is_a?(Array) and val.is_a?(Array)
self[key] += val
else
self[key] = val
end
end
end | ruby | {
"resource": ""
} |
q24596 | Rscons.Environment.dump | train | def dump
varset_hash = @varset.to_h
varset_hash.keys.sort_by(&:to_s).each do |var|
var_str = var.is_a?(Symbol) ? var.inspect : var
Ansi.write($stdout, :cyan, var_str, :reset, " => #{varset_hash[var].inspect}\n")
end
end | ruby | {
"resource": ""
} |
q24597 | Rscons.Environment.print_builder_run_message | train | def print_builder_run_message(short_description, command)
case @echo
when :command
if command.is_a?(Array)
message = command_to_s(command)
elsif command.is_a?(String)
message = command
elsif short_description.is_a?(String)
message = short_description
... | ruby | {
"resource": ""
} |
q24598 | Rscons.Environment.add_target | train | def add_target(target, builder, sources, vars, args)
setup_info = builder.setup(
target: target,
sources: sources,
env: self,
vars: vars)
@job_set.add_job(
builder: builder,
target: target,
sources: sources,
vars: vars,
setup_info: setu... | ruby | {
"resource": ""
} |
q24599 | Rscons.Environment.start_threaded_command | train | def start_threaded_command(tc)
print_builder_run_message(tc.short_description, tc.command)
env_args = tc.system_env ? [tc.system_env] : []
options_args = tc.system_options ? [tc.system_options] : []
system_args = [*env_args, *Rscons.command_executer, *tc.command, *options_args]
tc.thread... | ruby | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.