_id
stringlengths 2
6
| title
stringlengths 9
130
| partition
stringclasses 3
values | text
stringlengths 30
4.3k
| 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', | 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"))
| ruby | {
"resource": ""
} |
q26802 | MTG.QueryBuilder.find | test | def find(id)
response = RestClient.get("#{@type.Resource}/#{id}")
singular_resource = @type.Resource[0...-1]
| 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)
| 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)
| ruby | {
"resource": ""
} |
q26805 | Reform::Form::ActiveModel.ClassMethods.validates | test | def validates(*args, &block)
validation(name: :default, inherit: true) { | 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|
| 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 | 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
| ruby | {
"resource": ""
} |
q26809 | Exonio.Financial.pmt | test | def pmt(rate, nper, pv, fv = 0, end_or_beginning = 0)
temp = (1 + rate) ** | 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 - | ruby | {
"resource": ""
} |
q26811 | Exonio.Financial.npv | test | def npv(discount, cashflows)
total = 0
cashflows.each_with_index do |cashflow, | ruby | {
"resource": ""
} |
q26812 | Exonio.Financial.irr | test | def irr(values)
func = Helpers::IrrHelper.new(values)
| 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) | 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']
| 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 | 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
| 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
| 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 | 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"]
| 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
| ruby | {
"resource": ""
} |
q26821 | CITA.Contract.parse_url | test | def parse_url
uri = URI.parse(@url)
@host = uri.host
@port | ruby | {
"resource": ""
} |
q26822 | CITA.Http.call_rpc | test | def call_rpc(method, jsonrpc: DEFAULT_JSONRPC, params: DEFAULT_PARAMS, id: DEFAULT_ID)
conn.post("/", | ruby | {
"resource": ""
} |
q26823 | CITA.Http.rpc_params | test | def rpc_params(method, jsonrpc: DEFAULT_JSONRPC, params: DEFAULT_PARAMS, id: DEFAULT_ID)
| 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
| 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"]
| ruby | {
"resource": ""
} |
q26826 | Browser.Storage.replace | test | def replace(new)
if String === new
@data.replace(JSON.parse(new)) | 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 << | ruby | {
"resource": ""
} |
q26828 | Browser.Console.time | test | def time(label, &block)
raise ArgumentError, "no block given" unless block
`#@native.time(label)`
| ruby | {
"resource": ""
} |
q26829 | Browser.Console.group | test | def group(*args, &block)
raise ArgumentError, "no block given" unless block
`#@native.group.apply(#@native, args)`
| 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
| ruby | {
"resource": ""
} |
q26831 | Metaforce.AbstractClient.authenticate! | test | def authenticate!
options = authentication_handler.call(self, @options)
@options.merge!(options)
| 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)
| 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 | 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)
| 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
| 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|
| 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 | 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
| ruby | {
"resource": ""
} |
q26839 | Yast.SpellcheckTask.files_to_check | test | def files_to_check
files = config["check"].reduce([]) { |a, e| a + Dir[e] }
| ruby | {
"resource": ""
} |
q26840 | Yast.SpellcheckTask.read_spell_config | test | def read_spell_config(file)
return {} unless File.exist?(file)
puts | ruby | {
"resource": ""
} |
q26841 | Yast.SpellcheckTask.report_duplicates | test | def report_duplicates(dict1, dict2)
duplicates = dict1 & dict2
return if duplicates.empty?
$stderr.puts "Warning: Found | 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
| 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)
| ruby | {
"resource": ""
} |
q26844 | OptParseValidator.OptPath.check_writable | test | def check_writable(path)
raise Error, "'#{path}' is not writable" if path.exist? | 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 | 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 | ruby | {
"resource": ""
} |
q26847 | Zipping.ZipBuilder.subdir_entities | test | def subdir_entities(dir = @current_dir)
Dir.glob(dir[:path].gsub(/[*?\\\[\]{}]/, '\\\\\0') + '/*').map!{|path| {path: | 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, | ruby | {
"resource": ""
} |
q26849 | Zipping.ZipBuilder.pack | test | def pack(files)
entities = Entity.entities_from files
return if entities.empty?
reset_state
pack_entities entities
| 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]))
| 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 | ruby | {
"resource": ""
} |
q26852 | UiBibz::Ui::Core::Lists::Components.List.header | test | def header content = nil, options = nil, html_options = nil, &block
| ruby | {
"resource": ""
} |
q26853 | UiBibz::Ui::Core::Lists::Components.List.body | test | def body content = nil, options = nil, html_options = nil, &block
| 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?
| 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] )
| 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 | ruby | {
"resource": ""
} |
q26857 | UiBibz::Ui::Core::Boxes.Card.list_group | test | def list_group content = nil, options = nil, html_options = nil, &block
@items | ruby | {
"resource": ""
} |
q26858 | UiBibz::Ui::Core::Boxes.Card.image | test | def image content = nil, options = nil, html_options = nil, &block
@items | ruby | {
"resource": ""
} |
q26859 | UiBibz::Ui::Core::Forms::Dropdowns.Dropdown.html | test | def html content = nil, &block
if !block.nil?
context = eval("self", block.binding)
| ruby | {
"resource": ""
} |
q26860 | UiBibz::Ui::Core::Forms::Selects.AbstractSelect.component_html_options | test | def component_html_options
super.merge({
multiple: options[:multiple],
disabled: | 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, | ruby | {
"resource": ""
} |
q26862 | UiBibz::Ui::Core::Notifications.Alert.body | test | def body content = nil, options = nil, html_options = nil, &block
@body | ruby | {
"resource": ""
} |
q26863 | UiBibz::Ui::Core.Component.is_tap | test | def is_tap content, options
(content[:tap] | 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)
| 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) | 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 | ruby | {
"resource": ""
} |
q26867 | UiBibz::Ui::Ux::Tables.Columns.column | test | def column data_index = nil, options = nil, html_options = nil, &block
@columns << | ruby | {
"resource": ""
} |
q26868 | UiBibz::Ui::Ux::Tables.Actions.link | test | def link content = nil, options = nil, html_options = nil, &block
@actions << | 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
| 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 | ruby | {
"resource": ""
} |
q26871 | SassC.SassYaml.make_map | test | def make_map(item)
'(' + item.map {|key, value| key.to_s + ':' + | ruby | {
"resource": ""
} |
q26872 | SparkEngine.Plugin.add_files | test | def add_files(klass)
ext = asset_ext klass
find_files(ext).map do |path|
| ruby | {
"resource": ""
} |
q26873 | SparkEngine.Plugin.find_files | test | def find_files(ext)
files = Dir[File.join(paths[ext.to_sym], asset_glob(ext))]
| ruby | {
"resource": ""
} |
q26874 | SparkEngine.Command.dispatch | test | def dispatch(command, *args)
@threads = []
| 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!
| ruby | {
"resource": ""
} |
q26876 | SportDb.ReaderBase.load_setup | test | def load_setup( name )
reader = create_fixture_reader( name )
reader.each do | ruby | {
"resource": ""
} |
q26877 | ODFReport.Images.avoid_duplicate_image_names | test | def avoid_duplicate_image_names(content)
nodes = content.xpath("//draw:frame[@draw:name]")
| 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|
| 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" | 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)
| 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) && | 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 | 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
| ruby | {
"resource": ""
} |
q26884 | Libnotify.API.apply_options | test | def apply_options(options={})
options.each { |key, value| | 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)
| ruby | {
"resource": ""
} |
q26886 | Libnotify.API.update | test | def update(options={}, &block)
apply_options(options, &block)
if @notification
notify_notification_update(@notification, | 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?
| ruby | {
"resource": ""
} |
q26888 | YoutubeDL.Video.method_missing | test | def method_missing(method, *args, &block)
value = information[method]
| 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
| ruby | {
"resource": ""
} |
q26890 | YoutubeDL.Options.with | test | def with(hash)
merged = Options.new(@store.merge(hash.to_h))
| 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
| 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
| 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 | ruby | {
"resource": ""
} |
q26894 | Roar::Rails.ControllerAdditions.representer_for | test | def representer_for(format, model, options={})
options.delete(:represent_with) | 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 | ruby | {
"resource": ""
} |
q26896 | Easyzpl.Label.home_position | test | def home_position(x, y)
x = 0 unless numeric?(x)
y = 0 unless numeric?(y)
| 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 + ',' +
| 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 + ',' +
| 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
| ruby | {
"resource": ""
} |