_id
stringlengths 2
6
| title
stringlengths 9
130
| partition
stringclasses 3
values | text
stringlengths 66
10.5k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q26800 | Sonos.Discovery.discover | test | def discover
result = SSDP::Consumer.new.search(service: 'urn:schemas-upnp-org:device:ZonePlayer:1', first_only: true, timeout: @timeout, filter: lambda {|r| r[:params]["ST"].match(/ZonePlayer/) })
@first_device_ip = result[:address]
end | ruby | {
"resource": ""
} |
q26801 | Sonos.Discovery.topology | test | def topology
self.discover unless @first_device_ip
return [] unless @first_device_ip
doc = Nokogiri::XML(open("http://#{@first_device_ip}:#{Sonos::PORT}/status/topology"))
doc.xpath('//ZonePlayers/ZonePlayer').map do |node|
TopologyNode.new(node)
end
end | ruby | {
"resource": ""
} |
q26802 | MTG.QueryBuilder.find | test | def find(id)
response = RestClient.get("#{@type.Resource}/#{id}")
singular_resource = @type.Resource[0...-1]
if response.body[singular_resource].nil?
raise ArgumentError, 'Resource not found'
end
type.new.from_json(response.body[singular_resource].to_json)
end | ruby | {
"resource": ""
} |
q26803 | MTG.QueryBuilder.all | test | def all
list = []
page = 1
fetch_all = true
if @query.has_key?(:page)
page = @query[:page]
fetch_all = false
end
while true
response = RestClient.get(@type.Resource, @query)
data = response.body[@type.Resource]
if !data.empty?
data.each {|item| list << @type.new.from_json(item.to_json)}
if !fetch_all
break
else
where(page: page += 1)
end
else
break
end
end
return list
end | ruby | {
"resource": ""
} |
q26804 | Reform::Form::ORM.UniquenessValidator.validate | test | def validate(form)
property = attributes.first
# here is the thing: why does AM::UniquenessValidator require a filled-out record to work properly? also, why do we need to set
# the class? it would be way easier to pass #validate a hash of attributes and get back an errors hash.
# the class for the finder could either be infered from the record or set in the validator instance itself in the call to ::validates.
record = form.model_for_property(property)
record.send("#{property}=", form.send(property))
@klass = record.class # this is usually done in the super-sucky #setup method.
super(record).tap do |res|
form.errors.add(property, record.errors.first.last) if record.errors.present?
end
end | ruby | {
"resource": ""
} |
q26805 | Reform::Form::ActiveModel.ClassMethods.validates | test | def validates(*args, &block)
validation(name: :default, inherit: true) { validates *args, &block }
end | ruby | {
"resource": ""
} |
q26806 | ROXML.XMLTextRef.update_xml | test | def update_xml(xml, value)
wrap(xml).tap do |xml|
if content?
add(xml, value)
elsif name?
xml.name = value
elsif array?
value.each do |v|
add(XML.add_node(xml, name), v)
end
else
add(XML.add_node(xml, name), value)
end
end
end | ruby | {
"resource": ""
} |
q26807 | Exonio.Financial.ipmt | test | def ipmt(rate, per, nper, pv, fv = 0, end_or_beginning = 0)
pmt = self.pmt(rate, nper, pv, fv, end_or_beginning)
fv = self.fv(rate, (per - 1), pmt, pv, end_or_beginning) * rate
temp = end_or_beginning == 1 ? fv / (1 + rate) : fv
(per == 1 && end_or_beginning == 1) ? 0.0 : temp
end | ruby | {
"resource": ""
} |
q26808 | Exonio.Financial.nper | test | def nper(rate, pmt, pv, fv = 0, end_or_beginning = 0)
z = pmt * (1 + rate * end_or_beginning) / rate
temp = Math.log((-fv + z) / (pv + z))
temp / Math.log(1 + rate)
end | ruby | {
"resource": ""
} |
q26809 | Exonio.Financial.pmt | test | def pmt(rate, nper, pv, fv = 0, end_or_beginning = 0)
temp = (1 + rate) ** nper
fact = (1 + rate * end_or_beginning) * (temp - 1) / rate
-(fv + pv * temp) / fact
end | ruby | {
"resource": ""
} |
q26810 | Exonio.Financial.rate | test | def rate(nper, pmt, pv, fv = 0, end_or_beginning = 0, rate_guess = 0.10)
guess = rate_guess
tolerancy = 1e-6
close = false
begin
temp = newton_iter(guess, nper, pmt, pv, fv, end_or_beginning)
next_guess = (guess - temp).round(20)
diff = (next_guess - guess).abs
close = diff < tolerancy
guess = next_guess
end while !close
next_guess
end | ruby | {
"resource": ""
} |
q26811 | Exonio.Financial.npv | test | def npv(discount, cashflows)
total = 0
cashflows.each_with_index do |cashflow, index|
total += (cashflow.to_f / (1 + discount.to_f) ** (index + 1))
end
total
end | ruby | {
"resource": ""
} |
q26812 | Exonio.Financial.irr | test | def irr(values)
func = Helpers::IrrHelper.new(values)
guess = [ func.eps ]
nlsolve( func, guess)
guess[0]
end | ruby | {
"resource": ""
} |
q26813 | Exonio.Financial.newton_iter | test | def newton_iter(r, n, p, x, y, w)
t1 = (r+1)**n
t2 = (r+1)**(n-1)
((y + t1*x + p*(t1 - 1)*(r*w + 1)/r) / (n*t2*x - p*(t1 - 1)*(r*w + 1)/(r**2) + n*p*t2*(r*w + 1)/r + p*(t1 - 1)*w/r))
end | ruby | {
"resource": ""
} |
q26814 | Sensu.Handler.event_summary | test | def event_summary(trim_at = 100)
summary = @event['check']['notification'] || @event['check']['description']
if summary.nil?
source = @event['check']['source'] || @event['client']['name']
event_context = [source, @event['check']['name']].join('/')
output = @event['check']['output'].chomp
output = output.length > trim_at ? output[0..trim_at] + '...' : output
summary = [event_context, output].join(' : ')
end
summary
end | ruby | {
"resource": ""
} |
q26815 | Ole.Storage.load | test | def load
# we always read 512 for the header block. if the block size ends up being different,
# what happens to the 109 fat entries. are there more/less entries?
@io.rewind
header_block = @io.read 512
@header = Header.new header_block
# create an empty bbat.
@bbat = AllocationTable::Big.new self
bbat_chain = header_block[Header::SIZE..-1].unpack 'V*'
mbat_block = @header.mbat_start
@header.num_mbat.times do
blocks = @bbat.read([mbat_block]).unpack 'V*'
mbat_block = blocks.pop
bbat_chain += blocks
end
# am i using num_bat in the right way?
@bbat.load @bbat.read(bbat_chain[0, @header.num_bat])
# get block chain for directories, read it, then split it into chunks and load the
# directory entries. semantics changed - used to cut at first dir where dir.type == 0
@dirents = @bbat.read(@header.dirent_start).to_enum(:each_chunk, Dirent::SIZE).
map { |str| Dirent.new self, str }
# now reorder from flat into a tree
# links are stored in some kind of balanced binary tree
# check that everything is visited at least, and at most once
# similarly with the blocks of the file.
# was thinking of moving this to Dirent.to_tree instead.
class << @dirents
def to_tree idx=0
return [] if idx == Dirent::EOT
d = self[idx]
to_tree(d.child).each { |child| d << child }
raise FormatError, "directory #{d.inspect} used twice" if d.idx
d.idx = idx
to_tree(d.prev) + [d] + to_tree(d.next)
end
end
@root = @dirents.to_tree.first
@dirents.reject! { |d| d.type_id == 0 }
# silence this warning by default, its not really important (issue #5).
# fairly common one appears to be "R" (from office OS X?) which smells
# like some kind of UTF16 snafu, but scottwillson also has had some kanji...
#Log.warn "root name was #{@root.name.inspect}" unless @root.name == 'Root Entry'
unused = @dirents.reject(&:idx).length
Log.warn "#{unused} unused directories" if unused > 0
# FIXME i don't currently use @header.num_sbat which i should
# hmm. nor do i write it. it means what exactly again?
# which mode to use here?
@sb_file = RangesIOResizeable.new @bbat, :first_block => @root.first_block, :size => @root.size
@sbat = AllocationTable::Small.new self
@sbat.load @bbat.read(@header.sbat_start)
end | ruby | {
"resource": ""
} |
q26816 | Ole.Storage.repack | test | def repack temp=:file
case temp
when :file
Tempfile.open 'ole-repack' do |io|
io.binmode
repack_using_io io
end
when :mem; StringIO.open(''.dup, &method(:repack_using_io))
else raise ArgumentError, "unknown temp backing #{temp.inspect}"
end
end | ruby | {
"resource": ""
} |
q26817 | WpApiClient.Relationship.load_relation | test | def load_relation(relationship, position = nil)
if objects = @resource.dig("_embedded", relationship)
location = position ? objects[position] : objects
begin
WpApiClient::Collection.new(location)
rescue WpApiClient::ErrorResponse
load_from_links(relationship, position)
end
else
load_from_links(relationship, position)
end
end | ruby | {
"resource": ""
} |
q26818 | WpApiClient.Client.native_representation_of | test | def native_representation_of(response_body)
# Do we have a collection of objects?
if response_body.is_a? Array
WpApiClient::Collection.new(response_body, @headers)
else
WpApiClient::Entities::Base.build(response_body)
end
end | ruby | {
"resource": ""
} |
q26819 | CITA.Contract.call_func | test | def call_func(method:, params: [], tx: {}) # rubocop:disable Naming/UncommunicativeMethodParamName
data, output_types = function_data_with_ot(method, *params)
resp = @rpc.call_rpc(:call, params: [tx.merge(data: data, to: address), "latest"])
result = resp["result"]
data = [Utils.remove_hex_prefix(result)].pack("H*")
return if data.nil?
re = decode_abi output_types, data
re.length == 1 ? re.first : re
end | ruby | {
"resource": ""
} |
q26820 | CITA.Contract.send_func | test | def send_func(tx:, private_key:, method:, params: []) # rubocop:disable Naming/UncommunicativeMethodParamName
data, _output_types = function_data_with_ot(method, *params)
transaction = if tx.is_a?(Hash)
Transaction.from_hash(tx)
else
tx
end
transaction.data = data
resp = @rpc.send_transaction(transaction, private_key)
resp&.dig("result")
end | ruby | {
"resource": ""
} |
q26821 | CITA.Contract.parse_url | test | def parse_url
uri = URI.parse(@url)
@host = uri.host
@port = uri.port
@scheme = uri.scheme
end | ruby | {
"resource": ""
} |
q26822 | CITA.Http.call_rpc | test | def call_rpc(method, jsonrpc: DEFAULT_JSONRPC, params: DEFAULT_PARAMS, id: DEFAULT_ID)
conn.post("/", rpc_params(method, jsonrpc: jsonrpc, params: params, id: id))
end | ruby | {
"resource": ""
} |
q26823 | CITA.Http.rpc_params | test | def rpc_params(method, jsonrpc: DEFAULT_JSONRPC, params: DEFAULT_PARAMS, id: DEFAULT_ID)
{
jsonrpc: jsonrpc,
id: id,
method: method,
params: params
}.to_json
end | ruby | {
"resource": ""
} |
q26824 | CITA.Http.conn | test | def conn
Faraday.new(url: url) do |faraday|
faraday.headers["Content-Type"] = "application/json"
faraday.request :url_encoded # form-encode POST params
faraday.adapter Faraday.default_adapter # make requests with Net::HTTP
end
end | ruby | {
"resource": ""
} |
q26825 | CITA.RPC.transfer | test | def transfer(to:, private_key:, value:, quota: 30_000)
valid_until_block = block_number["result"].hex + 88
meta_data = get_meta_data("latest")["result"]
version = meta_data["version"]
chain_id = if version.zero?
meta_data["chainId"]
elsif version == 1
meta_data["chainIdV1"]
end
transaction = Transaction.new(nonce: Utils.nonce, valid_until_block: valid_until_block, chain_id: chain_id, to: to, value: value, quota: quota, version: version)
send_transaction(transaction, private_key)
end | ruby | {
"resource": ""
} |
q26826 | Browser.Storage.replace | test | def replace(new)
if String === new
@data.replace(JSON.parse(new))
else
@data.replace(new)
end
end | ruby | {
"resource": ""
} |
q26827 | Browser.Storage.to_json | test | def to_json
io = StringIO.new("{")
io << JSON.create_id.to_json << ":" << self.class.name.to_json << ","
@data.each {|key, value|
io << key.to_json.to_s << ":" << value.to_json << ","
}
io.seek(-1, IO::SEEK_CUR)
io << "}"
io.string
end | ruby | {
"resource": ""
} |
q26828 | Browser.Console.time | test | def time(label, &block)
raise ArgumentError, "no block given" unless block
`#@native.time(label)`
begin
if block.arity == 0
instance_exec(&block)
else
block.call(self)
end
ensure
`#@native.timeEnd()`
end
end | ruby | {
"resource": ""
} |
q26829 | Browser.Console.group | test | def group(*args, &block)
raise ArgumentError, "no block given" unless block
`#@native.group.apply(#@native, args)`
begin
if block.arity == 0
instance_exec(&block)
else
block.call(self)
end
ensure
`#@native.groupEnd()`
end
end | ruby | {
"resource": ""
} |
q26830 | Browser.Console.group! | test | def group!(*args, &block)
return unless block_given?
`#@native.groupCollapsed.apply(#@native, args)`
begin
if block.arity == 0
instance_exec(&block)
else
block.call(self)
end
ensure
`#@native.groupEnd()`
end
end | ruby | {
"resource": ""
} |
q26831 | Metaforce.AbstractClient.authenticate! | test | def authenticate!
options = authentication_handler.call(self, @options)
@options.merge!(options)
client.config.soap_header = soap_headers
end | ruby | {
"resource": ""
} |
q26832 | Xcodeproj.Project.new_with_uuid | test | def new_with_uuid(klass, uuid)
if klass.is_a?(String)
klass = Object.const_get(klass)
end
object = klass.new(self, uuid)
object.initialize_defaults
object
end | ruby | {
"resource": ""
} |
q26833 | Xcodeproj::Project::Object.PBXGroup.new_reference_with_uuid | test | def new_reference_with_uuid(path, uuid, source_tree = :group)
# customize `FileReferencesFactory.new_file_reference`
path = Pathname.new(path)
ref = self.project.new_with_uuid(PBXFileReference, uuid)
self.children << ref
GroupableHelper.set_path_with_source_tree(ref, path, source_tree)
ref.set_last_known_file_type
# customize `FileReferencesFactory.configure_defaults_for_file_reference`
if ref.path.include?('/')
ref.name = ref.path.split('/').last
end
if File.extname(ref.path).downcase == '.framework'
ref.include_in_index = nil
end
ref
end | ruby | {
"resource": ""
} |
q26834 | Xcodeproj::Project::Object.AbstractBuildPhase.add_file_reference_with_uuid | test | def add_file_reference_with_uuid(file_ref, uuid, avoid_duplicates = false)
if avoid_duplicates && existing = build_file(file_ref)
existing
else
build_file = project.new_with_uuid(PBXBuildFile, uuid)
build_file.file_ref = file_ref
files.insert(0, build_file)
build_file
end
end | ruby | {
"resource": ""
} |
q26835 | Seeds.Core.remove_seeds | test | def remove_seeds
removings = self.locks.keys - self.seeds.keys
removings.each do |name|
say "Removing #{name} (#{self.locks[name].version})".red
dirname = File.join(self.root_path, "Seeds", name)
FileUtils.rm_rf(dirname)
end
end | ruby | {
"resource": ""
} |
q26836 | Seeds.Core.configure_phase | test | def configure_phase
self.project.targets.each do |target|
begin
phase = target.sources_build_phase
# support resources phase
resource_phase = target.resources_build_phase
next unless phase
rescue NoMethodError
next
end
# remove zombie build files
phase.files_references.each do |file|
begin
file.real_path
rescue
phase.files.each do |build_file|
phase.files.delete(build_file) if build_file.file_ref == file
end
end
end
resource_phase.files_references.each do |file|
begin
file.real_path
rescue
resource_phase.files.each do |build_file|
resource_phase.files.delete(build_file) if build_file.file_ref == file
end
end
end
removings = [] # name of seeds going to be removed from the target
addings = [] # name of seeds going to be added to the target
self.targets.keys.sort.each do |seed_name|
target_names = self.targets[seed_name]
if not target_names.include?(target.name)
removings << seed_name if not removings.include?(seed_name)
else
addings << seed_name if not addings.include?(seed_name)
end
end
self.file_references.each do |file|
removings.each do |seed_names|
next if not seed_names.include?(file.parent.name)
phase.files.each do |build_file|
phase.files.delete(build_file) if build_file.file_ref == file
end
resource_phase.files.each do |build_file|
resource_phase.files.delete(build_file) if build_file.file_ref == file
end
end
addings.each do |seed_names|
next if file.name.end_with? ".h"
next if not seed_names.include?(file.parent.name)
uuid = Xcodeproj::uuid_with_name "#{target.name}:#{file.name}"
# Treat a file as resource file unless confirm it can be compiled.
if self.valid_source_file?(file)
phase.add_file_reference_with_uuid(file, uuid, true)
else
resource_phase.add_file_reference_with_uuid(file, uuid, true)
end
end
end
end
end | ruby | {
"resource": ""
} |
q26837 | Seeds.Core.valid_source_file? | test | def valid_source_file? filename
suffixs = [".h", ".c", ".m", ".mm", ".swift", ".cpp"]
suffixs.each do |suffix|
return true if filename.name.end_with? suffix
end
return false
end | ruby | {
"resource": ""
} |
q26838 | Yast.SpellcheckTask.speller | test | def speller
return @speller if @speller
# raspell is an optional dependency, handle the missing case nicely
begin
require "raspell"
rescue LoadError
$stderr.puts "ERROR: Ruby gem \"raspell\" is not installed."
exit 1
end
# initialize aspell
@speller = Aspell.new("en_US")
@speller.suggestion_mode = Aspell::NORMAL
# ignore the HTML tags in the text
@speller.set_option("mode", "html")
@speller
end | ruby | {
"resource": ""
} |
q26839 | Yast.SpellcheckTask.files_to_check | test | def files_to_check
files = config["check"].reduce([]) { |a, e| a + Dir[e] }
config["ignore"].reduce(files) { |a, e| a - Dir[e] }
end | ruby | {
"resource": ""
} |
q26840 | Yast.SpellcheckTask.read_spell_config | test | def read_spell_config(file)
return {} unless File.exist?(file)
puts "Loading config file (#{file})..." if verbose == true
require "yaml"
YAML.load_file(file)
end | ruby | {
"resource": ""
} |
q26841 | Yast.SpellcheckTask.report_duplicates | test | def report_duplicates(dict1, dict2)
duplicates = dict1 & dict2
return if duplicates.empty?
$stderr.puts "Warning: Found dictionary duplicates in the local dictionary " \
"(#{CUSTOM_SPELL_CONFIG_FILE}):\n"
duplicates.each { |duplicate| $stderr.puts " #{duplicate}" }
$stderr.puts
end | ruby | {
"resource": ""
} |
q26842 | Yast.SpellcheckTask.config | test | def config
return @config if @config
@config = read_spell_config(GLOBAL_SPELL_CONFIG_FILE)
custom_config = read_spell_config(CUSTOM_SPELL_CONFIG_FILE)
report_duplicates(config["dictionary"], custom_config["dictionary"].to_a)
custom_config["dictionary"] = @config["dictionary"] + custom_config["dictionary"].to_a
custom_config["dictionary"].uniq!
# override the global values by the local if present
@config.merge!(custom_config)
@config
end | ruby | {
"resource": ""
} |
q26843 | Yast.SpellcheckTask.check_file | test | def check_file(file)
puts "Checking #{file}..." if verbose == true
# spell check each line separately so we can report error locations properly
lines = File.read(file).split("\n")
success = true
lines.each_with_index do |text, index|
misspelled = misspelled_on_line(text)
next if misspelled.empty?
success = false
print_misspelled(misspelled, index, text)
end
success
end | ruby | {
"resource": ""
} |
q26844 | OptParseValidator.OptPath.check_writable | test | def check_writable(path)
raise Error, "'#{path}' is not writable" if path.exist? && !path.writable? || !path.parent.writable?
end | ruby | {
"resource": ""
} |
q26845 | OptParseValidator.OptParser.check_option | test | def check_option(opt)
raise Error, "The option is not an OptBase, #{opt.class} supplied" unless opt.is_a?(OptBase)
raise Error, "The option #{opt.to_sym} is already used !" if @symbols_used.include?(opt.to_sym)
end | ruby | {
"resource": ""
} |
q26846 | OptParseValidator.OptParser.post_processing | test | def post_processing
@opts.each do |opt|
raise NoRequiredOption, "The option #{opt} is required" if opt.required? && !@results.key?(opt.to_sym)
next if opt.required_unless.empty? || @results.key?(opt.to_sym)
fail_msg = "One of the following options is required: #{opt}, #{opt.required_unless.join(', ')}"
raise NoRequiredOption, fail_msg unless opt.required_unless.any? do |sym|
@results.key?(sym)
end
end
end | ruby | {
"resource": ""
} |
q26847 | Zipping.ZipBuilder.subdir_entities | test | def subdir_entities(dir = @current_dir)
Dir.glob(dir[:path].gsub(/[*?\\\[\]{}]/, '\\\\\0') + '/*').map!{|path| {path: path, time: File.mtime(path), name: File.basename(path)}}
end | ruby | {
"resource": ""
} |
q26848 | Zipping.ZipBuilder.string_to_bytes | test | def string_to_bytes(str)
unless @e.nil? || @e == :utf8
if @e == :shift_jis
begin
str = str.gsub /[\\:*?"<>|\uff5e]/, '？'
str.encode! 'Shift_JIS', :invalid => :replace, :undef => :replace, :replace => '？'
rescue => e
end
end
end
[str].pack('a*')
end | ruby | {
"resource": ""
} |
q26849 | Zipping.ZipBuilder.pack | test | def pack(files)
entities = Entity.entities_from files
return if entities.empty?
reset_state
pack_entities entities
while has_dir?
cd next_dir
pack_current_dir
end
end | ruby | {
"resource": ""
} |
q26850 | Zipping.ZipBuilder.pack_symlinks | test | def pack_symlinks
reset_state
@l.each do |link|
if @w.path_exists? Entity.linked_path(link[:abs_path], File.readlink(link[:path]))
link[:name] = link[:abs_path]
pack_symbolic_link_entity link
end
end
end | ruby | {
"resource": ""
} |
q26851 | Zipping.ZipBuilder.pack_entities | test | def pack_entities(entities)
entities.each do |entity|
# ignore bad entities
next unless entity.is_a?(Hash) && entity[:path]
path = entity[:path]
if File.symlink? path
postpone_symlink entity
elsif File.directory? path
postpone_dir entity
elsif File.file? path
pack_file_entity entity
end
end
end | ruby | {
"resource": ""
} |
q26852 | UiBibz::Ui::Core::Lists::Components.List.header | test | def header content = nil, options = nil, html_options = nil, &block
@header = UiBibz::Ui::Core::Lists::Components::ListHeader.new content, options, html_options, &block
end | ruby | {
"resource": ""
} |
q26853 | UiBibz::Ui::Core::Lists::Components.List.body | test | def body content = nil, options = nil, html_options = nil, &block
@body = UiBibz::Ui::Core::Lists::Components::ListBody.new content, options, html_options, &block
end | ruby | {
"resource": ""
} |
q26854 | UiBibz::Ui::Ux::Tables.Table.td_content | test | def td_content record, col
content = col.count ? record.send(col.data_index).count : record.send(col.data_index)
unless content.nil?
content = content.strftime(col.date_format) unless col.date_format.nil?
content = link_to content, action.inject_url(col.link, record) unless col.link.nil?
content = col.format.call(@store.records, record) unless col.format.nil?
end
content = As.new(col, record, content, @options).render unless col.as.nil?
content
end | ruby | {
"resource": ""
} |
q26855 | UiBibz::Ui::Core::Boxes.Card.body | test | def body content = nil, options = nil, html_options = nil, &block
options, content = inherit_options(content, options, block)
if is_tap(content, options)
content = (content || {}).merge(collapse: options.try(:[], :collapse), parent_collapse: @options[:parent_collapse] )
@items << UiBibz::Ui::Core::Boxes::Components::CardBody.new(content, options, html_options).tap(&block).render
else
options = (options || {}).merge(collapse: options.try(:[], :collapse), parent_collapse: @options[:parent_collapse] )
@items << UiBibz::Ui::Core::Boxes::Components::CardBody.new(content, options, html_options, &block).render
end
end | ruby | {
"resource": ""
} |
q26856 | UiBibz::Ui::Core::Boxes.Card.footer | test | def footer content = nil, options = nil, html_options = nil, &block
options, content = inherit_options(content, options, block)
@footer = UiBibz::Ui::Core::Boxes::Components::CardFooter.new(content, options, html_options, &block).render
end | ruby | {
"resource": ""
} |
q26857 | UiBibz::Ui::Core::Boxes.Card.list_group | test | def list_group content = nil, options = nil, html_options = nil, &block
@items << UiBibz::Ui::Core::Boxes::Components::CardListGroup.new(content, options, html_options).tap(&block).render
end | ruby | {
"resource": ""
} |
q26858 | UiBibz::Ui::Core::Boxes.Card.image | test | def image content = nil, options = nil, html_options = nil, &block
@items << UiBibz::Ui::Core::Boxes::Components::CardImage.new(content, options, html_options, &block).render
end | ruby | {
"resource": ""
} |
q26859 | UiBibz::Ui::Core::Forms::Dropdowns.Dropdown.html | test | def html content = nil, &block
if !block.nil?
context = eval("self", block.binding)
@items << context.capture(&block)
else
@items << content
end
end | ruby | {
"resource": ""
} |
q26860 | UiBibz::Ui::Core::Forms::Selects.AbstractSelect.component_html_options | test | def component_html_options
super.merge({
multiple: options[:multiple],
disabled: options[:state] == :disabled,
include_blank: options[:include_blank],
prompt: options[:prompt]
})
end | ruby | {
"resource": ""
} |
q26861 | UiBibz::Ui::Core::Navigations.Nav.nav | test | def nav content = nil, options = {}, html_options = nil, &block
@items << UiBibz::Ui::Core::Component.new(Nav.new(content, options).tap(&block).render, {}, html_options)
end | ruby | {
"resource": ""
} |
q26862 | UiBibz::Ui::Core::Notifications.Alert.body | test | def body content = nil, options = nil, html_options = nil, &block
@body = UiBibz::Ui::Core::Notifications::Components::AlertBody.new(content, options, html_options, &block).render
end | ruby | {
"resource": ""
} |
q26863 | UiBibz::Ui::Core.Component.is_tap | test | def is_tap content, options
(content[:tap] if content.kind_of?(Hash)) || (options[:tap] unless options.nil?)
end | ruby | {
"resource": ""
} |
q26864 | UiBibz::Ui::Core.Component.component_html_data | test | def component_html_data
# To stimulusjs
data_target = html_options.try(:[], :data).try(:[], :target) || options.try(:delete, :target)
add_html_data(:target, data_target) unless data_target.nil?
data_controller = html_options.try(:[], :data).try(:[], :controller) || options.try(:delete, :controller)
add_html_data(:controller, data_controller) unless data_controller.nil?
data_action = html_options.try(:[], :data).try(:[], :action) || options.try(:delete, :action)
add_html_data(:action, data_action) unless data_action.nil?
# To turbolinks
data_turbolinks = html_options.try(:[], :data).try(:[], :turbolinks) || options.try(:delete, :turbolinks)
add_html_data(:turbolinks, data_turbolinks) unless data_turbolinks.nil?
end | ruby | {
"resource": ""
} |
q26865 | UiBibz::Ui::Core.Component.add_html_data | test | def add_html_data name, value = true
html_options[:data] = {} if html_options[:data].nil?
value = value.kind_of?(String) ? value.strip : value
html_options[:data].update(Hash[name, value])
end | ruby | {
"resource": ""
} |
q26866 | UiBibz::Ui::Ux::Tables.Sortable.header | test | def header column, name = nil
@column = column
defaults = [translate_headers_by_defaults, translate_headers_by_defaults_active_record, translate_headers_by_active_record, header_name(name)]
@name = UiBibz::Utils::Internationalization.new(translate_headers_by_model, default: defaults).translate
sortable? ? sortable_link : title
end | ruby | {
"resource": ""
} |
q26867 | UiBibz::Ui::Ux::Tables.Columns.column | test | def column data_index = nil, options = nil, html_options = nil, &block
@columns << Column.new(data_index, options, html_options, &block)
end | ruby | {
"resource": ""
} |
q26868 | UiBibz::Ui::Ux::Tables.Actions.link | test | def link content = nil, options = nil, html_options = nil, &block
@actions << UiBibz::Ui::Core::Forms::Dropdowns::Components::DropdownLink.new(content, options, html_options, &block).render
end | ruby | {
"resource": ""
} |
q26869 | SparkEngine.Scaffold.engine_scaffold | test | def engine_scaffold
FileUtils.mkdir_p(@gem_temp)
Dir.chdir(@gem_temp) do
response = Open3.capture3("rails plugin new #{gem} --mountable --dummy-path=site --skip-test-unit")
if !response[1].empty?
puts response[1]
abort "FAILED: Please be sure you have the rails gem installed with `gem install rails`"
end
# Remove files and directories that are unnecessary for the
# light-weight Rails documentation site
remove = %w(mailers models assets channels jobs views).map{ |f| File.join('app', f) }
remove.concat %w(cable.yml storage.yml database.yml).map{ |f| File.join('config', f) }
remove.each { |f| FileUtils.rm_rf File.join(@gem, 'site', f), secure: true }
end
engine_copy
end | ruby | {
"resource": ""
} |
q26870 | SparkEngine.Scaffold.engine_copy | test | def engine_copy
site_path = File.join path, 'site'
FileUtils.mkdir_p site_path
## Copy Rails plugin files
Dir.chdir "#{@gem_temp}/#{gem}/site" do
%w(app config bin config.ru Rakefile public log).each do |item|
target = File.join site_path, item
FileUtils.cp_r item, target
action_log "create", target.sub(@cwd+'/','')
end
end
# Remove temp dir
FileUtils.rm_rf @gem_temp
end | ruby | {
"resource": ""
} |
q26871 | SassC.SassYaml.make_map | test | def make_map(item)
'(' + item.map {|key, value| key.to_s + ':' + convert_to_sass_value(value) }.join(',') + ')'
end | ruby | {
"resource": ""
} |
q26872 | SparkEngine.Plugin.add_files | test | def add_files(klass)
ext = asset_ext klass
find_files(ext).map do |path|
klass.new(self, path)
end
end | ruby | {
"resource": ""
} |
q26873 | SparkEngine.Plugin.find_files | test | def find_files(ext)
files = Dir[File.join(paths[ext.to_sym], asset_glob(ext))]
# Filter out partials
files.reject { |f| File.basename(f).start_with?('_') }
end | ruby | {
"resource": ""
} |
q26874 | SparkEngine.Command.dispatch | test | def dispatch(command, *args)
@threads = []
send command, *args
@threads.each { |thr| thr.join }
end | ruby | {
"resource": ""
} |
q26875 | SparkEngine.Command.watch | test | def watch(options={})
build(options)
require 'listen'
trap("SIGINT") {
puts "\nspark_engine watcher stopped. Have a nice day!"
exit!
}
@threads.concat SparkEngine.load_plugin.watch(options)
end | ruby | {
"resource": ""
} |
q26876 | SportDb.ReaderBase.load_setup | test | def load_setup( name )
reader = create_fixture_reader( name )
reader.each do |fixture_name|
load( fixture_name )
end
end | ruby | {
"resource": ""
} |
q26877 | ODFReport.Images.avoid_duplicate_image_names | test | def avoid_duplicate_image_names(content)
nodes = content.xpath("//draw:frame[@draw:name]")
nodes.each_with_index do |node, i|
node.attribute('name').value = "pic_#{i}"
end
end | ruby | {
"resource": ""
} |
q26878 | DynamicScaffold.ControllerUtilities.scope_params | test | def scope_params
return {} if dynamic_scaffold.scope.nil?
case dynamic_scaffold.scope
when Array then
dynamic_scaffold.scope.each_with_object({}) do |val, res|
if val.is_a? Hash
val.each {|k, v| res[k] = v }
else
res[val] = params[val]
end
end
when Hash then
dynamic_scaffold.scope
end
end | ruby | {
"resource": ""
} |
q26879 | DynamicScaffold.ControllerUtilities.pkey_string_to_hash | test | def pkey_string_to_hash(pkey)
# https://github.com/gomo/dynamic_scaffold/pull/9/commits/ff5de0e38b3544347e82539c45ffd2efaf3410da
# Stop support multiple pkey, on this commit.
# Convert "key:1,code:foo" to {key: "1", code: "foo"}
pkey.split(',').map {|v| v.split(':') }.each_with_object({}) {|v, res| res[v.first] = v.last }
end | ruby | {
"resource": ""
} |
q26880 | DynamicScaffold.ControllerUtilities.update_values | test | def update_values # rubocop:disable Metrics/AbcSize
# set the parameters of carrierwave_image at the end for validates.
permitting = []
dynamic_scaffold.form.items.reject {|i| i.type?(:carrierwave_image) }.each do |item|
item.extract_parameters(permitting)
end
permitting.concat(dynamic_scaffold.form.permit_params)
dynamic_scaffold.form.items.select {|i| i.type?(:carrierwave_image) }.each do |item|
item.extract_parameters(permitting)
end
values = params
.require(dynamic_scaffold.model.name.underscore)
.permit(*permitting)
if dynamic_scaffold.scope && !valid_for_scope?(values)
raise DynamicScaffold::Error::InvalidOperation, "You can update only to #{scope_params} on this scope"
end
values
end | ruby | {
"resource": ""
} |
q26881 | DynamicScaffold.ControllerUtilities.valid_for_scope? | test | def valid_for_scope?(update_params)
return true if dynamic_scaffold.scope_options[:changeable]
result = true
scope_params.each do |key, value|
if update_params.key?(key) && update_params[key] != value
result = false
break
end
end
result
end | ruby | {
"resource": ""
} |
q26882 | RedisLocks.Semaphore.lock | test | def lock(timeout: nil, &block)
ensure_exists_and_release_stale_locks!
success = @redis.with do |conn|
if timeout
!conn.blpop(available_key, timeout.to_i).nil?
else
!conn.lpop(available_key).nil?
end
end
return false unless success
token = SecureRandom.hex(16)
@tokens.push(token)
@redis.with do |conn|
conn.zadd(grabbed_key, epoch_f(conn), token)
end
return_or_yield(token, &block)
end | ruby | {
"resource": ""
} |
q26883 | RedisLocks.Semaphore.unlock | test | def unlock(token = @tokens.pop)
return unless token
removed = false
@redis.with do |conn|
removed = conn.zrem grabbed_key, token
if removed
conn.lpush available_key, 1
end
end
removed
end | ruby | {
"resource": ""
} |
q26884 | Libnotify.API.apply_options | test | def apply_options(options={})
options.each { |key, value| send("#{key}=", value) if respond_to?(key) }
yield(self) if block_given?
end | ruby | {
"resource": ""
} |
q26885 | Libnotify.API.show! | test | def show!
notify_init(app_name) or raise "notify_init failed"
raw_ptr = notify_notification_new(summary, body, icon_path, nil)
@notification = ::FFI::AutoPointer.new(raw_ptr, method(:g_object_unref))
show
end | ruby | {
"resource": ""
} |
q26886 | Libnotify.API.update | test | def update(options={}, &block)
apply_options(options, &block)
if @notification
notify_notification_update(@notification, summary, body, icon_path, nil)
show
else
show!
end
end | ruby | {
"resource": ""
} |
q26887 | YoutubeDL.Video.download | test | def download
raise ArgumentError.new('url cannot be nil') if @url.nil?
raise ArgumentError.new('url cannot be empty') if @url.empty?
set_information_from_json(YoutubeDL::Runner.new(url, runner_options).run)
end | ruby | {
"resource": ""
} |
q26888 | YoutubeDL.Video.method_missing | test | def method_missing(method, *args, &block)
value = information[method]
if value.nil?
super
else
value
end
end | ruby | {
"resource": ""
} |
q26889 | YoutubeDL.Runner.options_to_commands | test | def options_to_commands
commands = []
@options.sanitize_keys.each_paramized_key do |key, paramized_key|
if @options[key].to_s == 'true'
commands.push "--#{paramized_key}"
elsif @options[key].to_s == 'false'
commands.push "--no-#{paramized_key}"
else
commands.push "--#{paramized_key} :#{key}"
end
end
commands.push quoted(url)
commands.join(' ')
end | ruby | {
"resource": ""
} |
q26890 | YoutubeDL.Options.with | test | def with(hash)
merged = Options.new(@store.merge(hash.to_h))
merged.banned_keys = @banned_keys
merged.send(:remove_banned)
merged
end | ruby | {
"resource": ""
} |
q26891 | YoutubeDL.Options.method_missing | test | def method_missing(method, *args, &_block)
remove_banned
if method.to_s.include? '='
method = method.to_s.tr('=', '').to_sym
return nil if banned? method
@store[method] = args.first
else
return nil if banned? method
@store[method]
end
end | ruby | {
"resource": ""
} |
q26892 | YoutubeDL.Options.manipulate_keys! | test | def manipulate_keys!(&block)
@store.keys.each do |old_name|
new_name = block.call(old_name)
unless new_name == old_name
@store[new_name] = @store[old_name]
@store.delete(old_name)
end
end
end | ruby | {
"resource": ""
} |
q26893 | YoutubeDL.Options.sanitize_keys! | test | def sanitize_keys!
# Symbolize
manipulate_keys! { |key_name| key_name.is_a?(Symbol) ? key_name : key_name.to_sym }
# Underscoreize (because Cocaine doesn't like hyphens)
manipulate_keys! { |key_name| key_name.to_s.tr('-', '_').to_sym }
end | ruby | {
"resource": ""
} |
q26894 | Roar::Rails.ControllerAdditions.representer_for | test | def representer_for(format, model, options={})
options.delete(:represent_with) || self.class.represents_options.for(format, model, controller_path)
end | ruby | {
"resource": ""
} |
q26895 | Easyzpl.LabelTemplate.variable_text_field | test | def variable_text_field(x, y, params = {})
x = 0 unless numeric?(x)
y = 0 unless numeric?(y)
options = { height: 0.1, width: 0.1 }.merge!(params)
# update the variable field count
self.variable_fields_count += 1
label_data.push('^FO' + Integer(x * printer_dpi).to_s + ',' +
Integer(y * printer_dpi).to_s)
if params[:orientation] == :landscape
label_data.push('^A0N,')
else
label_data.push('^A0B,')
end
label_data.push(Integer(options[:height] * printer_dpi).to_s + ',' +
Integer(options[:width] * printer_dpi).to_s +
'^FN' + variable_fields_count.to_s + '^FS')
# return unless label_height > 0 && label_width > 0
# pdf.text_box '{Variable Field ' + variable_fields_count.to_s + '}',
# at: [Integer(x * pdf_dpi), Integer(label_width * pdf_dpi) -
# Integer(y * pdf_dpi) -
# Integer(options[:height] / 10) * pdf_dpi],
# size: Integer(options[:height] * pdf_dpi) if label_height &&
# label_width
end | ruby | {
"resource": ""
} |
q26896 | Easyzpl.Label.home_position | test | def home_position(x, y)
x = 0 unless numeric?(x)
y = 0 unless numeric?(y)
label_data.push('^LH' + x.to_s + ',' + y.to_s)
end | ruby | {
"resource": ""
} |
q26897 | Easyzpl.Label.draw_border | test | def draw_border(x, y, height, width)
return unless numeric?(height) && numeric?(width)
x = 0 unless numeric?(x)
y = 0 unless numeric?(y)
label_data.push('^FO' + Integer(x * printer_dpi).to_s + ',' +
Integer(y * printer_dpi).to_s + '^GB' +
Integer(height * printer_dpi).to_s +
',' + Integer(width * printer_dpi).to_s + ',1^FS')
# draw_rectangle(x * pdf_dpi, y * pdf_dpi, height * pdf_dpi, width * pdf_dpi)
end | ruby | {
"resource": ""
} |
q26898 | Easyzpl.Label.reset_barcode_fields_to_default | test | def reset_barcode_fields_to_default
label_data.push('^BY' + Integer(self.barcode_default_module_width).to_s + ',' +
Float(self.barcode_default_width_ratio).to_s + ',' +
Integer(self.barcode_default_height).to_s)
end | ruby | {
"resource": ""
} |
q26899 | Easyzpl.Label.draw_bar_code_39 | test | def draw_bar_code_39(bar_code_string, x, y, height)
return unless label_height > 0 && label_width > 0
pdf.bounding_box [x, Integer(label_width) - y - (height * pdf_dpi)],
width: (height * pdf_dpi) do
barcode = Barby::Code39.new(bar_code_string)
barcode.annotate_pdf(pdf, height: (height * pdf_dpi))
end
end | ruby | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.