_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3
values | text stringlengths 30 4.3k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q21900 | BTC.Transaction.add_input | train | def add_input(txin)
raise ArgumentError, "Input is missing" if !txin
if !(txin.transaction == nil || txin.transaction == self)
raise ArgumentError, | ruby | {
"resource": ""
} |
q21901 | BTC.Data.data_from_hex | train | def data_from_hex(hex_string)
raise ArgumentError, "Hex string is missing" if !hex_string
hex_string = hex_string.strip
data = [hex_string].pack(HEX_PACK_CODE)
| ruby | {
"resource": ""
} |
q21902 | BTC.OpenSSL.regenerate_keypair | train | def regenerate_keypair(private_key, public_key_compressed: false)
autorelease do |pool|
eckey = pool.new_ec_key
priv_bn = pool.new_bn(private_key)
pub_key = pool.new_ec_point
EC_POINT_mul(self.group, pub_key, priv_bn, nil, nil, pool.bn_ctx)
EC_KEY_set_private_key(eckey,... | ruby | {
"resource": ""
} |
q21903 | BTC.OpenSSL.private_key_from_der_format | train | def private_key_from_der_format(der_key)
raise ArgumentError, "Missing DER private key" if !der_key
prepare_if_needed
buf = FFI::MemoryPointer.from_string(der_key)
ec_key = d2i_ECPrivateKey(nil, pointer_to_pointer(buf), buf.size-1)
if ec_key.null?
| ruby | {
"resource": ""
} |
q21904 | BTC.OpenSSL.data_from_bn | train | def data_from_bn(bn, min_length: nil, required_length: nil)
raise ArgumentError, "Missing big number" if !bn
length = BN_num_bytes(bn)
buf = FFI::MemoryPointer.from_string("\x00"*length)
BN_bn2bin(bn, buf)
s = buf.read_string(length)
s = s.rjust(min_length, "\x00") if min_length
... | ruby | {
"resource": ""
} |
q21905 | BTC.WireFormat.encode_varint | train | def encode_varint(i)
raise ArgumentError, "int must be present" if !i
raise ArgumentError, "int must be non-negative" if i < 0
buf = if i < 0xfd
[i].pack("C")
elsif i <= 0xffff
[0xfd, i].pack("Cv")
elsif i <= 0xffffffff
[0xfe, i].pack("CV")
| ruby | {
"resource": ""
} |
q21906 | BTC.WireFormat.write_varint | train | def write_varint(i, data: nil, stream: nil)
buf = encode_varint(i)
| ruby | {
"resource": ""
} |
q21907 | BTC.WireFormat.encode_string | train | def encode_string(string)
raise ArgumentError, "String must be present" | ruby | {
"resource": ""
} |
q21908 | BTC.WireFormat.write_string | train | def write_string(string, data: nil, stream: nil)
raise ArgumentError, "String must be present" if !string
intbuf = write_varint(string.bytesize, data: | ruby | {
"resource": ""
} |
q21909 | BTC.WireFormat.read_array | train | def read_array(data: nil, stream: nil, offset: 0)
count, len = read_varint(data: data, stream: stream, offset: offset)
| ruby | {
"resource": ""
} |
q21910 | BTC.WireFormat.encode_uleb128 | train | def encode_uleb128(value)
raise ArgumentError, "Signed integers are not supported" if value < 0
return "\x00" if value == 0
bytes = []
while value != 0
byte = value & 0b01111111 # 0x7f
value >>= 7
| ruby | {
"resource": ""
} |
q21911 | BTC.WireFormat.write_uleb128 | train | def write_uleb128(value, data: nil, stream: nil)
raise ArgumentError, "Integer must be present" if !value
buf = encode_uleb128(value)
| ruby | {
"resource": ""
} |
q21912 | Preferences.InstanceMethods.preferences | train | def preferences(group = nil)
preferences = preferences_group(group)
unless preferences_group_loaded?(group)
group_id, group_type = Preference.split_group(group)
find_preferences(:group_id => group_id, :group_type => group_type).each do |preference|
preferences[preference.nam... | ruby | {
"resource": ""
} |
q21913 | Preferences.InstanceMethods.preferred? | train | def preferred?(name, group = nil)
name = name.to_s
assert_valid_preference(name)
| ruby | {
"resource": ""
} |
q21914 | Preferences.InstanceMethods.preferred | train | def preferred(name, group = nil)
name = name.to_s
assert_valid_preference(name)
if preferences_group(group).include?(name)
# Value for this group/name has been written, but not saved yet:
# grab from the pending values
value = preferences_group(group)[name]
else
... | ruby | {
"resource": ""
} |
q21915 | Preferences.InstanceMethods.preference_changes | train | def preference_changes(group = nil)
preferences_changed(group).inject({}) do |changes, preference|
| ruby | {
"resource": ""
} |
q21916 | Preferences.InstanceMethods.preference_was | train | def preference_was(name, group)
preference_changed?(name, group) ? | ruby | {
"resource": ""
} |
q21917 | Preferences.InstanceMethods.reset_preference! | train | def reset_preference!(name, group)
write_preference(name, | ruby | {
"resource": ""
} |
q21918 | Preferences.InstanceMethods.preference_value_changed? | train | def preference_value_changed?(name, old, value)
definition = preference_definitions[name]
if definition.type == :integer && (old.nil? || old == 0)
# For nullable numeric columns, NULL gets stored in database for blank (i.e. '') values.
| ruby | {
"resource": ""
} |
q21919 | Preferences.InstanceMethods.find_preferences | train | def find_preferences(attributes)
if stored_preferences.loaded?
stored_preferences.select do |preference|
| ruby | {
"resource": ""
} |
q21920 | DBus.ProxyObject.[] | train | def [](intfname)
introspect unless introspected
ifc = @interfaces[intfname]
raise DBus::Error, "no | ruby | {
"resource": ""
} |
q21921 | DBus.ProxyObjectInterface.define_method_from_descriptor | train | def define_method_from_descriptor(m)
m.params.each do |fpar|
par = fpar.type
# This is the signature validity check
Type::Parser.new(par).parse
end
singleton_class.class_eval do
define_method m.name do |*args, &reply_handler|
if m.params.size != args.size
... | ruby | {
"resource": ""
} |
q21922 | DBus.ProxyObjectInterface.define | train | def define(m)
if m.is_a?(Method)
define_method_from_descriptor(m)
| ruby | {
"resource": ""
} |
q21923 | DBus.ProxyObjectInterface.define_method | train | def define_method(methodname, prototype)
m = Method.new(methodname)
| ruby | {
"resource": ""
} |
q21924 | DBus.ProxyObjectInterface.[] | train | def [](propname)
ret = object[PROPERTY_INTERFACE].Get(name, propname)
# this method always returns the single property
| ruby | {
"resource": ""
} |
q21925 | DBus.ProxyObjectInterface.all_properties | train | def all_properties
ret = object[PROPERTY_INTERFACE].GetAll(name)
# this method always returns the single property
| ruby | {
"resource": ""
} |
q21926 | DBus.MessageQueue.connect | train | def connect
addresses = @address.split ";"
# connect to first one that succeeds
worked = addresses.find do |a|
transport, keyvaluestring = a.split ":"
kv_list = keyvaluestring.split ","
kv_hash = {}
kv_list.each do |kv|
key, escaped_value = kv.split "="
... | ruby | {
"resource": ""
} |
q21927 | DBus.MessageQueue.connect_to_tcp | train | def connect_to_tcp(params)
# check if the path is sufficient
if params.key?("host") && params.key?("port")
begin
# initialize the tcp socket
@socket = TCPSocket.new(params["host"], params["port"].to_i)
@socket.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
| ruby | {
"resource": ""
} |
q21928 | DBus.MessageQueue.connect_to_unix | train | def connect_to_unix(params)
@socket = Socket.new(Socket::Constants::PF_UNIX, Socket::Constants::SOCK_STREAM, 0)
@socket.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
if !params["abstract"].nil?
sockaddr = if HOST_END == LIL_END
"\1\0\0#{params["abstract"]}"
e... | ruby | {
"resource": ""
} |
q21929 | DBus.Message.add_param | train | def add_param(type, val)
type = type.chr if type.is_a?(Integer) | ruby | {
"resource": ""
} |
q21930 | DBus.Message.marshall | train | def marshall
if @path == "/org/freedesktop/DBus/Local"
raise InvalidDestinationName
end
params = PacketMarshaller.new
@params.each do |param|
params.append(param[0], param[1])
end
@body_length = params.packet.bytesize
marshaller = PacketMarshaller.new
ma... | ruby | {
"resource": ""
} |
q21931 | DBus.Message.unmarshall_buffer | train | def unmarshall_buffer(buf)
buf = buf.dup
endianness = if buf[0] == "l"
LIL_END
else
BIG_END
end
pu = PacketUnmarshaller.new(buf, endianness)
mdata = pu.unmarshall(MESSAGE_SIGNATURE)
_, @message_type, @flags, @p... | ruby | {
"resource": ""
} |
q21932 | DBus.Message.annotate_exception | train | def annotate_exception(ex)
new_ex = ex.exception("#{ex}; caused by #{self}")
| ruby | {
"resource": ""
} |
q21933 | DBus.PacketUnmarshaller.unmarshall | train | def unmarshall(signature, len = nil)
if !len.nil?
if @buffy.bytesize < @idx + len
raise IncompleteBufferException
| ruby | {
"resource": ""
} |
q21934 | DBus.PacketUnmarshaller.align | train | def align(a)
case a
when 1
nil
when 2, 4, 8
bits = a - 1
@idx = @idx + bits & ~bits
raise IncompleteBufferException if @idx > | ruby | {
"resource": ""
} |
q21935 | DBus.PacketUnmarshaller.read | train | def read(nbytes)
raise IncompleteBufferException if @idx + nbytes > @buffy.bytesize
ret | ruby | {
"resource": ""
} |
q21936 | DBus.PacketUnmarshaller.read_string | train | def read_string
align(4)
str_sz = read(4).unpack(@uint32)[0]
ret = @buffy.slice(@idx, str_sz)
raise IncompleteBufferException if @idx + str_sz | ruby | {
"resource": ""
} |
q21937 | DBus.PacketUnmarshaller.read_signature | train | def read_signature
str_sz = read(1).unpack("C")[0]
ret = @buffy.slice(@idx, str_sz)
raise IncompleteBufferException if @idx + str_sz + 1 | ruby | {
"resource": ""
} |
q21938 | DBus.PacketMarshaller.num_align | train | def num_align(n, a)
case a
when 1, 2, 4, 8
bits = a - 1
n + bits & ~bits
| ruby | {
"resource": ""
} |
q21939 | DBus.PacketMarshaller.array | train | def array(type)
# Thanks to Peter Rullmann for this line
align(4)
sizeidx = @packet.bytesize
@packet += "ABCD"
align(type.alignment)
| ruby | {
"resource": ""
} |
q21940 | DBus.Service.object | train | def object(path, api: ApiOptions::A0)
node = get_node(path, _create = true)
if node.object.nil? || node.object.api != api
node.object = ProxyObject.new(
| ruby | {
"resource": ""
} |
q21941 | DBus.Service.get_node | train | def get_node(path, create = false)
n = @root
path.sub(%r{^/}, "").split("/").each do |elem|
if !(n[elem])
return nil if !create
n[elem] = Node.new(elem)
end
n | ruby | {
"resource": ""
} |
q21942 | DBus.Service.rec_introspect | train | def rec_introspect(node, path)
xml = bus.introspect_data(@name, path)
intfs, subnodes = IntrospectXMLParser.new(xml).parse
subnodes.each do |nodename|
subnode = node[nodename] = Node.new(nodename)
subpath = if path == "/"
"/" + nodename
else
... | ruby | {
"resource": ""
} |
q21943 | DBus.Node.to_xml | train | def to_xml
xml = '<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN"
"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
<node>
'
each_pair do |k, _v|
xml += "<node name=\"#{k}\" />"
end
if @object
@object.intfs.each_pair do |_k, v|
| ruby | {
"resource": ""
} |
q21944 | DBus.Connection.glibize | train | def glibize
require "glib2"
# Circumvent a ruby-glib bug
@channels ||= []
gio = GLib::IOChannel.new(@message_queue.socket.fileno)
| ruby | {
"resource": ""
} |
q21945 | DBus.Connection.request_service | train | def request_service(name)
# Use RequestName, but asynchronously!
# A synchronous call would not work with service activation, where
# method calls to be serviced arrive before the reply for RequestName
# (Ticket#29).
proxy.RequestName(name, NAME_FLAG_REPLACE_EXISTING) do |rmsg, r|
... | ruby | {
"resource": ""
} |
q21946 | DBus.Connection.proxy | train | def proxy
if @proxy.nil?
path = "/org/freedesktop/DBus"
dest = "org.freedesktop.DBus"
pof = DBus::ProxyObjectFactory.new(
DBUSXMLINTRO, self, dest, path,
| ruby | {
"resource": ""
} |
q21947 | DBus.Connection.add_match | train | def add_match(mr, &slot)
# check this is a signal.
mrs = mr.to_s
DBus.logger.debug "#{@signal_matchrules.size} rules, adding #{mrs.inspect}"
| ruby | {
"resource": ""
} |
q21948 | DBus.Connection.send_hello | train | def send_hello
m = Message.new(DBus::Message::METHOD_CALL)
m.path = "/org/freedesktop/DBus"
m.destination = "org.freedesktop.DBus"
m.interface = "org.freedesktop.DBus"
m.member = "Hello"
send_sync(m) do |rmsg|
@unique_name = rmsg.destination
| ruby | {
"resource": ""
} |
q21949 | DBus.Main.run | train | def run
# before blocking, empty the buffers
# https://bugzilla.novell.com/show_bug.cgi?id=537401
@buses.each_value do |b|
while (m = b.message_queue.message_from_buffer_nonblock)
b.process(m)
end
end
while !@quitting && !@buses.empty?
ready = IO.select(@b... | ruby | {
"resource": ""
} |
q21950 | DBus.External.authenticate | train | def authenticate
# Take the user id (eg integer 1000) make a string out of it "1000", take
# each character and determin hex value "1" => 0x31, "0" => 0x30. You
# obtain for "1000" => 31303030 This is what the server is expecting.
| ruby | {
"resource": ""
} |
q21951 | DBus.DBusCookieSHA1.hex_decode | train | def hex_decode(encoded)
encoded.scan(/[[:xdigit:]]{2}/).map | ruby | {
"resource": ""
} |
q21952 | DBus.Client.authenticate | train | def authenticate
if RbConfig::CONFIG["target_os"] =~ /freebsd/
@socket.sendmsg(0.chr, 0, nil, [:SOCKET, :SCM_CREDS, ""])
else
@socket.write(0.chr)
end
next_authenticator
@state = :Starting
| ruby | {
"resource": ""
} |
q21953 | DBus.Client.next_authenticator | train | def next_authenticator
raise AuthenticationFailed if @auth_list.empty?
@authenticator = @auth_list.shift.new
auth_msg = ["AUTH", @authenticator.name, @authenticator.authenticate]
DBus.logger.debug | ruby | {
"resource": ""
} |
q21954 | DBus.Interface.validate_name | train | def validate_name(name)
raise InvalidIntrospectionData if name.bytesize > 255
raise InvalidIntrospectionData if name =~ /^\./ || name =~ /\.$/
raise InvalidIntrospectionData if name =~ /\.\./
raise InvalidIntrospectionData if | ruby | {
"resource": ""
} |
q21955 | DBus.Interface.define | train | def define(m)
if m.is_a?(Method)
@methods[m.name.to_sym] = | ruby | {
"resource": ""
} |
q21956 | DBus.Interface.define_method | train | def define_method(id, prototype)
m = Method.new(id)
| ruby | {
"resource": ""
} |
q21957 | DBus.Method.from_prototype | train | def from_prototype(prototype)
prototype.split(/, */).each do |arg|
arg = arg.split(" ")
raise InvalidClassDefinition if arg.size != 2
dir, arg = arg
if arg =~ /:/
arg = arg.split(":")
name, sig = arg
else
sig = arg
end
case | ruby | {
"resource": ""
} |
q21958 | DBus.Method.to_xml | train | def to_xml
xml = %(<method name="#{@name}">\n)
@params.each do |param|
name = param.name ? %(name="#{param.name}" ) : ""
xml += %(<arg #{name}direction="in" type="#{param.type}"/>\n)
| ruby | {
"resource": ""
} |
q21959 | DBus.Signal.from_prototype | train | def from_prototype(prototype)
prototype.split(/, */).each do |arg|
if arg =~ /:/
arg = arg.split(":")
name, sig = arg
else
| ruby | {
"resource": ""
} |
q21960 | DBus.Signal.to_xml | train | def to_xml
xml = %(<signal name="#{@name}">\n)
@params.each do |param|
name = param.name ? | ruby | {
"resource": ""
} |
q21961 | DBus.MatchRule.from_s | train | def from_s(str)
str.split(",").each do |eq|
next unless eq =~ /^(.*)='([^']*)'$/
# "
name = Regexp.last_match(1)
val = Regexp.last_match(2)
| ruby | {
"resource": ""
} |
q21962 | DBus.MatchRule.from_signal | train | def from_signal(intf, signal)
signal = signal.name unless signal.is_a?(String)
self.type = "signal"
self.interface = intf.name
| ruby | {
"resource": ""
} |
q21963 | DBus.MatchRule.match | train | def match(msg)
if @type
if { Message::SIGNAL => "signal", Message::METHOD_CALL => "method_call",
Message::METHOD_RETURN => "method_return",
Message::ERROR => "error" }[msg.message_type] != @type
return false
end
end
| ruby | {
"resource": ""
} |
q21964 | ScreenObject.Accessors.button | train | def button(name, locator)
# generates method for clicking button.
# this method will not return any value.
# @example click on 'Submit' button.
# button(:login_button,"xpath~//UIButtonField")
# def click_login_button
# login_button # This will click on the button.
... | ruby | {
"resource": ""
} |
q21965 | ScreenObject.Accessors.checkbox | train | def checkbox(name, locator)
# generates method for checking the checkbox object.
# this will not return any value
# @example check if 'remember me' checkbox is not checked.
# checkbox(:remember_me,"xpath~//UICheckBox")
# DSL to check the 'remember me' check box.
# def ch... | ruby | {
"resource": ""
} |
q21966 | ScreenObject.Accessors.text | train | def text(name,locator)
# generates method for clicking button.
# this method will not return any value.
# @example click on 'Submit' button.
# button(:login_button,"xpath~//UIButtonField")
# def click_login_button
# login_button # This will click on the button.
... | ruby | {
"resource": ""
} |
q21967 | ScreenObject.Accessors.text_field | train | def text_field(name,locator)
# generates method for setting text into text field.
# There is no return value for this method.
# @example setting username field.
# DSL for entering text in username text field.
# def set_username_text_field(username)
# self.username=user... | ruby | {
"resource": ""
} |
q21968 | ScreenObject.Accessors.image | train | def image(name,locator)
# generates method for checking the existence of the image.
# this will return true or false based on if image is available or not
# @example check if 'logo' image is displayed on the page
# text(:logo,"xpath~//UITextField")
# DSL for clicking the logo im... | ruby | {
"resource": ""
} |
q21969 | ScreenObject.Accessors.table | train | def table(name, locator)
#generates method for counting total no of cells in table
define_method("#{name}_cell_count") do
| ruby | {
"resource": ""
} |
q21970 | Nugrant.Bag.__convert_value | train | def __convert_value(value)
case
# Converts Hash to Bag instance
when value.kind_of?(Hash)
Bag.new(value, @__config)
# Converts Array elements to Bag instances if needed
| ruby | {
"resource": ""
} |
q21971 | Furik.PullRequests.pull_requests | train | def pull_requests(repo_name)
org_name = org_name_from(repo_name)
unless @block
if @org_name == org_name
print '-'
else
puts ''
print "#{org_name} -"
@org_name = org_name
end
end
issues = @client.issues(repo_name, creator: @login, ... | ruby | {
"resource": ""
} |
q21972 | Darksky.API.precipitation | train | def precipitation(latitudes_longitudes_times, options = {})
return if latitudes_longitudes_times.size % 3 != 0
params = []
latitudes_longitudes_times.each_slice(3) do |data|
params << data.join(',')
| ruby | {
"resource": ""
} |
q21973 | Darksky.API.interesting | train | def interesting(options = {})
response = Typhoeus::Request.get("#{DARKSKY_API_URL}/interesting/#{@api_key}", DEFAULT_OPTIONS.dup.merge(options))
| ruby | {
"resource": ""
} |
q21974 | Rib.Shell.loop | train | def loop
before_loop
set_trap
start
in_loop
stop
self
rescue Exception => e
Rib.warn("Error while running | ruby | {
"resource": ""
} |
q21975 | Rib.Paging.one_screen? | train | def one_screen? str
cols, lines = `tput cols`.to_i, `tput lines`.to_i
(str.count("\n") + 2) <= lines && # count last line | ruby | {
"resource": ""
} |
q21976 | Vegas.Runner.daemonize! | train | def daemonize!
if JRUBY
# It's not a true daemon but when executed with & works like one
thread = Thread.new {daemon_execute}
thread.join
elsif RUBY_VERSION < "1.9"
logger.debug "Parent Process: #{Process.pid}"
exit!(0) if fork
logger.debug "Child | ruby | {
"resource": ""
} |
q21977 | Vegas.Runner.load_config_file | train | def load_config_file(config_path)
abort "Can not find config file at #{config_path}" if !File.readable?(config_path)
config = File.read(config_path)
# trim off | ruby | {
"resource": ""
} |
q21978 | KPeg.CodeGenerator.output_grammar | train | def output_grammar(code)
code << " # :stopdoc:\n"
handle_ast(code)
fg = @grammar.foreign_grammars
if fg.empty?
if @standalone
code << " def setup_foreign_grammar; end\n"
end
else
code << " def setup_foreign_grammar\n"
@grammar.foreign_grammars... | ruby | {
"resource": ""
} |
q21979 | KPeg.CodeGenerator.output_header | train | def output_header(code)
if header = @grammar.directives['header']
code << header.action.strip
code << "\n"
end
pre_class = @grammar.directives['pre-class']
if @standalone
if pre_class
code << pre_class.action.strip
code << "\n"
end
co... | ruby | {
"resource": ""
} |
q21980 | YNAB.TransactionsApi.create_transaction | train | def create_transaction(budget_id, data, opts = {})
data, _status_code, _headers = | ruby | {
"resource": ""
} |
q21981 | YNAB.TransactionsApi.get_transaction_by_id | train | def get_transaction_by_id(budget_id, transaction_id, opts = {})
data, | ruby | {
"resource": ""
} |
q21982 | YNAB.TransactionsApi.get_transactions | train | def get_transactions(budget_id, opts = {})
data, _status_code, _headers = | ruby | {
"resource": ""
} |
q21983 | YNAB.TransactionsApi.get_transactions_by_account | train | def get_transactions_by_account(budget_id, account_id, opts = {})
data, | ruby | {
"resource": ""
} |
q21984 | YNAB.TransactionsApi.get_transactions_by_category | train | def get_transactions_by_category(budget_id, category_id, opts = {})
data, | ruby | {
"resource": ""
} |
q21985 | YNAB.TransactionsApi.get_transactions_by_payee | train | def get_transactions_by_payee(budget_id, payee_id, opts = {})
data, _status_code, _headers = | ruby | {
"resource": ""
} |
q21986 | YNAB.TransactionsApi.update_transaction | train | def update_transaction(budget_id, transaction_id, data, opts = {})
data, | ruby | {
"resource": ""
} |
q21987 | YNAB.TransactionsApi.update_transactions | train | def update_transactions(budget_id, data, opts = {})
data, _status_code, _headers = | ruby | {
"resource": ""
} |
q21988 | YNAB.AccountsApi.get_account_by_id | train | def get_account_by_id(budget_id, account_id, opts = {})
data, _status_code, _headers = | ruby | {
"resource": ""
} |
q21989 | YNAB.AccountsApi.get_accounts | train | def get_accounts(budget_id, opts = {})
data, _status_code, _headers = | ruby | {
"resource": ""
} |
q21990 | YNAB.MonthsApi.get_budget_month | train | def get_budget_month(budget_id, month, opts = {})
data, _status_code, _headers = | ruby | {
"resource": ""
} |
q21991 | YNAB.MonthsApi.get_budget_months | train | def get_budget_months(budget_id, opts = {})
data, _status_code, _headers = | ruby | {
"resource": ""
} |
q21992 | Chess.Pgn.to_s | train | def to_s
s = ''
TAGS.each do |t|
tag = instance_variable_get("@#{t}")
s << "[#{t.capitalize} \"#{tag}\"]\n"
end
s << "\n"
m = ''
@moves.each_with_index do |move, i|
m << "#{i/2+1}. " if i % 2 == | ruby | {
"resource": ""
} |
q21993 | Chess.Game.pgn | train | def pgn
pgn = Chess::Pgn.new
pgn.moves = self.moves
pgn.result | ruby | {
"resource": ""
} |
q21994 | YNAB.PayeeLocationsApi.get_payee_location_by_id | train | def get_payee_location_by_id(budget_id, payee_location_id, opts = {})
data, | ruby | {
"resource": ""
} |
q21995 | YNAB.PayeeLocationsApi.get_payee_locations | train | def get_payee_locations(budget_id, opts = {})
data, _status_code, _headers = | ruby | {
"resource": ""
} |
q21996 | YNAB.PayeeLocationsApi.get_payee_locations_by_payee | train | def get_payee_locations_by_payee(budget_id, payee_id, opts = {})
data, | ruby | {
"resource": ""
} |
q21997 | YNAB.CategoriesApi.update_month_category | train | def update_month_category(budget_id, month, category_id, data, opts = {})
data, | ruby | {
"resource": ""
} |
q21998 | YNAB.BudgetsApi.get_budget_by_id | train | def get_budget_by_id(budget_id, opts = {})
data, _status_code, _headers = | ruby | {
"resource": ""
} |
q21999 | YNAB.BudgetsApi.get_budget_settings_by_id | train | def get_budget_settings_by_id(budget_id, opts = {})
data, _status_code, _headers = | ruby | {
"resource": ""
} |
Subsets and Splits
SQL Console for CoIR-Retrieval/CodeSearchNet-ccr-ruby-queries-corpus
Retrieves a large number of entries in the 'ruby' language, providing basic information but limited analytical value.