_id
stringlengths 2
6
| title
stringlengths 9
130
| partition
stringclasses 3
values | text
stringlengths 30
4.3k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q27500
|
Ropenstack.Image::Version2.upload_image_from_file
|
test
|
def upload_image_from_file(name, disk_format, container_format, minDisk, minRam, is_public, file)
data = {
"name" => name,
"disk_format" => disk_format,
"container_format" => container_format,
"minDisk" => minDisk,
"minRam" => minRam,
"public" => is_public
}
imagesBefore = images()
|
ruby
|
{
"resource": ""
}
|
q27501
|
Ropenstack.Image::Version2.put_octect
|
test
|
def put_octect(uri, data, manage_errors)
headers = build_headers(@token)
headers["Content-Type"] = 'application/octet-stream'
req =
|
ruby
|
{
"resource": ""
}
|
q27502
|
Qwiki.App.relative_path
|
test
|
def relative_path(path)
path = File.expand_path(path)
root = full_path("")
if path.size >= root.size && path[0...root.size] == root
|
ruby
|
{
"resource": ""
}
|
q27503
|
Qwiki.App.index
|
test
|
def index(path)
@entries = []
Dir.entries(path).each do |entry|
relative_path = relative_path(File.join(path, entry))
if entry != "." && relative_path
|
ruby
|
{
"resource": ""
}
|
q27504
|
Tabledata.Table.accessors_from_headers!
|
test
|
def accessors_from_headers!
raise "Can't define accessors from headers in a table without headers" unless @has_headers
|
ruby
|
{
"resource": ""
}
|
q27505
|
Tabledata.Table.<<
|
test
|
def <<(row)
index = @data.size
begin
row = row.to_ary
rescue NoMethodError
raise ArgumentError, "Row must be provided as Array or respond to `to_ary`, but got #{row.class}
|
ruby
|
{
"resource": ""
}
|
q27506
|
Hemingway.FootnoteNode.html
|
test
|
def html(id, time)
inline_footnote_label = Build.tag("span", Build.tag("sup", id.to_s), :class => "inline-footnote-number")
|
ruby
|
{
"resource": ""
}
|
q27507
|
Hemingway.FootnoteNode.footnote_html
|
test
|
def footnote_html(id, time)
footnote_label = Build.tag("span", Build.tag("sup", id.to_s), :class => "footnote-number")
footnote_content = sequence.elements.map { |s| s.html }.join
|
ruby
|
{
"resource": ""
}
|
q27508
|
Ropenstack.Database::Version1.instance_action
|
test
|
def instance_action(id, action, param)
case action
when "RESTART"
post_request(address("/instances/" + id + "/action"), {:restart => {}}, @token)
when "RESIZE"
if param.is_a? String
post_request(address("/instances/" + id + "/action"), {:resize => {:flavorRef => param }}, @token)
elsif param.is_a? Int
post_request(address("/instances/" + id + "/action"), {:resize
|
ruby
|
{
"resource": ""
}
|
q27509
|
Revenc.Errors.add
|
test
|
def add(error_on, message = "Unknown error")
# humanize error_on
if error_on.is_a?(Symbol)
error_on_str = error_on.to_s
else
error_on_str = underscore(error_on.class.name)
end
error_on_str = error_on_str.gsub(/\//, '_')
error_on_str = error_on_str.gsub(/_/, ' ')
|
ruby
|
{
"resource": ""
}
|
q27510
|
GameOfLife.Board.coords_of_neighbors
|
test
|
def coords_of_neighbors(x, y)
coords_of_neighbors = []
(x - 1).upto(x + 1).each do |neighbors_x|
(y - 1).upto(y + 1).each do |neighbors_y|
|
ruby
|
{
"resource": ""
}
|
q27511
|
RSqoot.Merchant.merchant
|
test
|
def merchant(id, options = {})
options = update_by_expire_time options
if merchant_not_latest?(id)
@rsqoot_merchant = get("merchants/#{id}", options, SqootMerchant)
@rsqoot_merchant = @rsqoot_merchant.merchant if @rsqoot_merchant
|
ruby
|
{
"resource": ""
}
|
q27512
|
EventMachine::WebSocketCodec.Encoder.encode
|
test
|
def encode data, opcode=TEXT_FRAME
frame = []
frame << (opcode | 0x80)
packr = "CC"
if opcode == TEXT_FRAME
data.force_encoding("UTF-8")
if !data.valid_encoding?
raise "Invalid UTF!"
end
end
# append frame length and mask bit 0x80
len = data ? data.bytesize : 0
if len <= 125
frame << (len | 0x80)
elsif
|
ruby
|
{
"resource": ""
}
|
q27513
|
Challah::Rolls.Permission.challah_permission
|
test
|
def challah_permission
unless included_modules.include?(InstanceMethods)
include InstanceMethods
extend ClassMethods
end
class_eval do
validates_presence_of :name, :key
validates_uniqueness_of :name, :key
validates_format_of :key, :with => /^([a-z0-9_])*$/, :message => :invalid_key
has_many :permission_roles, :dependent => :destroy
has_many :roles, :through => :permission_roles, :order => 'roles.name'
|
ruby
|
{
"resource": ""
}
|
q27514
|
Connectors.ApiConnector.post
|
test
|
def post hash={}, payload
raise 'Payload cannot be blank' if payload.nil? || payload.empty?
|
ruby
|
{
"resource": ""
}
|
q27515
|
Ropenstack.Networking.create_network
|
test
|
def create_network(name, tenant, admin_state_up = true)
data = {
'network' => {
'name' => name,
'tenant_id' => tenant,
|
ruby
|
{
"resource": ""
}
|
q27516
|
Ropenstack.Networking.create_port
|
test
|
def create_port(network, subnet = nil, device = nil, device_owner = nil)
data = {
'port' => {
'network_id' => network,
}
}
unless device_owner.nil?
data['port']['device_owner'] = device_owner
end
unless device.nil?
data['port']['device_id'] = device
end
|
ruby
|
{
"resource": ""
}
|
q27517
|
Ropenstack.Networking.move_port_to_subnets
|
test
|
def move_port_to_subnets(port_id, subnet_ids)
id_list = Array.new()
subnet_ids.each do
|
ruby
|
{
"resource": ""
}
|
q27518
|
Rack.Action.json
|
test
|
def json(data={}, options={})
response[CONTENT_TYPE] = APPLICATION_JSON
response.status = options[:status] if options.has_key?(:status)
|
ruby
|
{
"resource": ""
}
|
q27519
|
Rack.Action.redirect_to
|
test
|
def redirect_to(url, options={})
full_url = absolute_url(url, options)
response[LOCATION] =
|
ruby
|
{
"resource": ""
}
|
q27520
|
Ropenstack.Compute.servers
|
test
|
def servers(id)
endpoint = "/servers"
unless id.nil?
endpoint = endpoint + "/" + id
end
|
ruby
|
{
"resource": ""
}
|
q27521
|
Ropenstack.Compute.create_server
|
test
|
def create_server(name, image, flavor, networks = nil, keypair = nil, security_group = nil, metadata = nil)
data = {
"server" => {
"name" => name,
"imageRef" => image,
"flavorRef" => flavor,
|
ruby
|
{
"resource": ""
}
|
q27522
|
Ropenstack.Compute.action
|
test
|
def action(id, act, *args)
data = case act
when "reboot" then {'reboot' =>{"type" => args[0]}}
when "vnc" then {'os-getVNCConsole' => { "type" => "novnc" }}
when "stop" then {'os-stop' => 'null'}
when "start" then {'os-start' => 'null'}
when "pause" then {'pause' => 'null'}
when "unpause" then {'unpause' => 'null'}
when "suspend" then
|
ruby
|
{
"resource": ""
}
|
q27523
|
Ropenstack.Compute.delete_image
|
test
|
def delete_image(id)
uri = URI.parse("http://" + @location.host
|
ruby
|
{
"resource": ""
}
|
q27524
|
RSqoot.Request.get
|
test
|
def get(path, opts = {}, wrapper = ::Hashie::Mash)
uri, headers = url_generator(path, opts)
begin
json = JSON.parse uri.open(headers).read
result = wrapper.new json
|
ruby
|
{
"resource": ""
}
|
q27525
|
Optimacms.Template.set_basepath
|
test
|
def set_basepath
if self.parent.nil?
self.basepath = self.basename
self.basedirpath ||= ''
else
self.basepath
|
ruby
|
{
"resource": ""
}
|
q27526
|
RSqoot.Commission.commissions
|
test
|
def commissions(options = {})
options = update_by_expire_time options
if commissions_not_latest?(options)
@rsqoot_commissions = get('commissions', options, SqootCommission)
@rsqoot_commissions = @rsqoot_commissions.commissions if @rsqoot_commissions
|
ruby
|
{
"resource": ""
}
|
q27527
|
FootballRuby.Client.leagues
|
test
|
def leagues(opts={})
season = opts.fetch(:season) { Time.now.year }
|
ruby
|
{
"resource": ""
}
|
q27528
|
Ov.Ext.match
|
test
|
def match(*args, &block)
z = Module.new do
include Ov
extend self
def try(*args, &block)
let :anon_method, *args, &block
end
def otherwise(&block)
let :otherwise, &block
|
ruby
|
{
"resource": ""
}
|
q27529
|
Tabledata.Row.fetch
|
test
|
def fetch(column, *default_value, &default_block)
raise ArgumentError, "Must only provide at max one default value or one default block" if default_value.size > (block_given? ? 0 : 1)
index = case column
when Symbol then @table.index_for_accessor(column)
when String then @table.index_for_header(column)
when Integer then column
else
|
ruby
|
{
"resource": ""
}
|
q27530
|
Tabledata.Row.at
|
test
|
def at(column)
case column
when Symbol then at_accessor(column)
when String then at_header(column)
when Integer then at_index(column)
when Range then @data[column]
|
ruby
|
{
"resource": ""
}
|
q27531
|
Tabledata.Row.values_at
|
test
|
def values_at(*columns)
result = []
columns.each do |column|
data = at(column)
if column.is_a?(Range)
|
ruby
|
{
"resource": ""
}
|
q27532
|
Tabledata.Row.method_missing
|
test
|
def method_missing(name, *args, &block)
return super unless @table.accessors?
name =~ /^(\w+)(=)?$/
name_mod, assign = $1, $2
index = @table.index_for_accessor(name_mod)
arg_count = assign ? 1 : 0
return super unless index
|
ruby
|
{
"resource": ""
}
|
q27533
|
TaskMapper::Provider.Unfuddle.authorize
|
test
|
def authorize(auth = {})
@authentication ||= TaskMapper::Authenticator.new(auth)
auth = @authentication
if (auth.account.nil? and auth.subdomain.nil?) or auth.username.nil? or auth.password.nil?
|
ruby
|
{
"resource": ""
}
|
q27534
|
Ropenstack::Networking::Version2::Extensions.L3.routers
|
test
|
def routers(id = nil)
endpoint = "routers"
unless id.nil?
endpoint = endpoint + "/" + id
|
ruby
|
{
"resource": ""
}
|
q27535
|
Ropenstack::Networking::Version2::Extensions.L3.create_router
|
test
|
def create_router(name, admin_state_up = true)
data = {
'router' =>{
'name' => name,
'admin_state_up' => admin_state_up,
|
ruby
|
{
"resource": ""
}
|
q27536
|
Ropenstack::Networking::Version2::Extensions.L3.delete_router_interface
|
test
|
def delete_router_interface(router, id, type)
data = case type
when 'port' then { 'port_id' => id }
when 'subnet' then { 'subnet_id' => id }
else raise "Invalid Interface Type"
end
|
ruby
|
{
"resource": ""
}
|
q27537
|
Ov.OA.where
|
test
|
def where(method)
@complete, @result = nil, nil
z = find_or_next(method) { |method|
self.find{|m| m.eql?(method) }
}.find_or_next(method) { |method|
|
ruby
|
{
"resource": ""
}
|
q27538
|
Semistatic.Configuration.load
|
test
|
def load
config_files.each do |file|
config = YAML::load(File.open(file))
|
ruby
|
{
"resource": ""
}
|
q27539
|
RSqoot.Provider.providers
|
test
|
def providers(options = {})
options = update_by_expire_time options
query = options.delete(:query)
if providers_not_latest?(options)
@rsqoot_providers = get('providers', options, SqootProvider)
@rsqoot_providers = @rsqoot_providers.providers.map(&:provider) if @rsqoot_providers
|
ruby
|
{
"resource": ""
}
|
q27540
|
RSqoot.Category.categories
|
test
|
def categories(options = {})
options = update_by_expire_time options
query = options.delete(:query)
if categories_not_latest?(options)
@rsqoot_categories = get('categories', options, SqootCategory)
@rsqoot_categories = @rsqoot_categories.categories.map(&:category) if @rsqoot_categories
|
ruby
|
{
"resource": ""
}
|
q27541
|
Challah::Rolls.Role.challah_role
|
test
|
def challah_role
unless included_modules.include?(InstanceMethods)
include InstanceMethods
extend ClassMethods
end
class_eval do
# Validations
################################################################
validates :name, :presence => true, :uniqueness => true
# Relationships
################################################################
has_many :permission_roles, :dependent => :destroy
has_many :permissions, :through => :permission_roles,
:order => 'permissions.name'
|
ruby
|
{
"resource": ""
}
|
q27542
|
Tang.Subscription.check_for_upgrade
|
test
|
def check_for_upgrade
if plan_id_changed?
old_plan = Plan.find(plan_id_was) if plan_id_was.present?
|
ruby
|
{
"resource": ""
}
|
q27543
|
ZeevexProxy.Base.method_missing
|
test
|
def method_missing(name, *args, &block)
obj = __getobj__
|
ruby
|
{
"resource": ""
}
|
q27544
|
RSqoot.Deal.deals
|
test
|
def deals(options = {})
options = update_by_expire_time options
if deals_not_latest?(options)
uniq = !!options.delete(:uniq)
@rsqoot_deals = get('deals', options, SqootDeal) || []
@rsqoot_deals = @rsqoot_deals.deals.map(&:deal) unless @rsqoot_deals.empty?
|
ruby
|
{
"resource": ""
}
|
q27545
|
RSqoot.Deal.deal
|
test
|
def deal(id, options = {})
options = update_by_expire_time options
if deal_not_latest?(id)
@rsqoot_deal = get("deals/#{id}", options, SqootDeal)
@rsqoot_deal = @rsqoot_deal.deal if @rsqoot_deal
|
ruby
|
{
"resource": ""
}
|
q27546
|
RSqoot.Deal.total_sqoot_deals
|
test
|
def total_sqoot_deals(options = {})
@total_deals ||= []
@cached_pages ||= []
page = options[:page] || 1
check_query_change options
unless page_cached? page
|
ruby
|
{
"resource": ""
}
|
q27547
|
RSqoot.Deal.uniq_deals
|
test
|
def uniq_deals(deals = [])
titles = deals.map(&:title).uniq
titles.map do |title|
deals.map do |deal|
|
ruby
|
{
"resource": ""
}
|
q27548
|
Watir.Browser.load_cookies
|
test
|
def load_cookies(file)
now = ::Time.now
io = case file
when String
open(file)
else
file
end
io.each_line do |line|
line.chomp!
line.gsub!(/#.+/, '')
fields = line.split("\t")
next if fields.length != 7
name, value, domain, for_domain, path, secure, version = fields[5], fields[6],
fields[0], (fields[1] == "TRUE"), fields[2], (fields[3] == "TRUE"), 0
|
ruby
|
{
"resource": ""
}
|
q27549
|
Watir.Browser.dump_cookies
|
test
|
def dump_cookies(file)
io = case file
when String
open(file, "w")
else
file
end
cookies.to_a.each do |cookie|
io.puts([
cookie[:domain],
"FALSE", # for_domain
cookie[:path],
cookie[:secure] ?
|
ruby
|
{
"resource": ""
}
|
q27550
|
Watir.Element.set2
|
test
|
def set2(selector, value=nil)
elem = element(xpath: selector).to_subtype
case elem
when Watir::Radio
elem.set
|
ruby
|
{
"resource": ""
}
|
q27551
|
RSqoot.Helper.update_by_expire_time
|
test
|
def update_by_expire_time(options = {})
@expired_in = options[:expired_in] if options[:expired_in].present?
time =
|
ruby
|
{
"resource": ""
}
|
q27552
|
RubyMeetup.Client.get
|
test
|
def get(options={})
uri = new_uri
params = merge_params(options)
uri.query = URI.encode_www_form(params)
Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') do |http|
request = Net::HTTP::Get.new(uri)
|
ruby
|
{
"resource": ""
}
|
q27553
|
Ropenstack.Image::Version1.images
|
test
|
def images(id, tenant_id)
if id.nil?
return get_request(address(tenant_id, "images/detail"), @token)
else
return
|
ruby
|
{
"resource": ""
}
|
q27554
|
Ropenstack.Image::Version1.image_create
|
test
|
def image_create(name, disk_format, container_format, create_image, tenant_id)
data = {
:name => name,
:disk_format => disk_format,
|
ruby
|
{
"resource": ""
}
|
q27555
|
Ropenstack.Image::Version1.replace_memberships
|
test
|
def replace_memberships(id, memberships, tenant_id)
data = {
:memberships =>
|
ruby
|
{
"resource": ""
}
|
q27556
|
Ropenstack.Image::Version1.add_member
|
test
|
def add_member(id, member_id, can_share, tenant_id)
if can_share.nil?
data = {
:member => {:can_share => false}
}
else
data = {
|
ruby
|
{
"resource": ""
}
|
q27557
|
Scripto.FileCommands.mkdir
|
test
|
def mkdir(dir, owner: nil, mode: nil)
FileUtils.mkdir_p(dir, verbose: verbose?)
chown(dir,
|
ruby
|
{
"resource": ""
}
|
q27558
|
Scripto.FileCommands.cp
|
test
|
def cp(src, dst, mkdir: false, owner: nil, mode: nil)
mkdir_if_necessary(File.dirname(dst)) if mkdir
FileUtils.cp_r(src, dst, preserve: true, verbose: verbose?)
|
ruby
|
{
"resource": ""
}
|
q27559
|
Scripto.FileCommands.mv
|
test
|
def mv(src, dst, mkdir: false)
mkdir_if_necessary(File.dirname(dst))
|
ruby
|
{
"resource": ""
}
|
q27560
|
Scripto.FileCommands.ln
|
test
|
def ln(src, dst)
FileUtils.ln_sf(src, dst, verbose: verbose?)
rescue Errno::EEXIST => e
# It's a race - this can occur because ln_sf removes the old
# dst, then creates the
|
ruby
|
{
"resource": ""
}
|
q27561
|
Scripto.FileCommands.chmod
|
test
|
def chmod(file, mode)
return if File.stat(file).mode
|
ruby
|
{
"resource": ""
}
|
q27562
|
Scripto.FileCommands.rm_and_mkdir
|
test
|
def rm_and_mkdir(dir)
raise "don't do this" if dir == ""
FileUtils.rm_rf(dir,
|
ruby
|
{
"resource": ""
}
|
q27563
|
Scripto.FileCommands.copy_metadata
|
test
|
def copy_metadata(src, dst)
stat = File.stat(src)
File.chmod(stat.mode, dst)
|
ruby
|
{
"resource": ""
}
|
q27564
|
Scripto.FileCommands.atomic_write
|
test
|
def atomic_write(path)
tmp = Tempfile.new(File.basename(path))
yield(tmp)
tmp.close
chmod(tmp.path, 0o644)
|
ruby
|
{
"resource": ""
}
|
q27565
|
Capybarbecue.Server.handle_requests
|
test
|
def handle_requests
until @requestmq.empty?
request = @requestmq.deq(true)
begin
request.response = @app.call(request.env)
rescue Exception => e
request.exception = e
ensure
|
ruby
|
{
"resource": ""
}
|
q27566
|
Vagrantomatic.Instance.configfile_hash
|
test
|
def configfile_hash
config = {}
begin
json = File.read(configfile)
config = JSON.parse(json)
rescue Errno::ENOENT
# depending on whether the instance has been saved or not, we may not
# yet have a configfile - allow to proceed
@logger.debug "#{configfile} does not exist"
@force_save = true
|
ruby
|
{
"resource": ""
}
|
q27567
|
SimpleFormat.AutoLink.email_addresses
|
test
|
def email_addresses(text)
text.gsub(@regex[:mail]) do
text = $&
if auto_linked?($`, $')
text
|
ruby
|
{
"resource": ""
}
|
q27568
|
Risky::Inflector.Inflections.plural
|
test
|
def plural(rule, replacement)
@uncountables.delete(rule) if rule.is_a?(String)
|
ruby
|
{
"resource": ""
}
|
q27569
|
Risky::Inflector.Inflections.singular
|
test
|
def singular(rule, replacement)
@uncountables.delete(rule) if rule.is_a?(String)
|
ruby
|
{
"resource": ""
}
|
q27570
|
Risky::Inflector.Inflections.irregular
|
test
|
def irregular(singular, plural)
@uncountables.delete(singular)
@uncountables.delete(plural)
if singular[0,1].upcase == plural[0,1].upcase
plural(Regexp.new("(#{singular[0,1]})#{singular[1..-1]}$", "i"), '\1' + plural[1..-1])
singular(Regexp.new("(#{plural[0,1]})#{plural[1..-1]}$", "i"), '\1' + singular[1..-1])
|
ruby
|
{
"resource": ""
}
|
q27571
|
Revenc.ActionFolder.execute
|
test
|
def execute
raise errors.to_sentences unless valid?
# default failing command
result = false
# protect command from recursion
mutex = Mutagem::Mutex.new('revenc.lck')
lock_successful = mutex.execute
|
ruby
|
{
"resource": ""
}
|
q27572
|
HanselCore.Hansel.output
|
test
|
def output
opts = options
if opts.format
FileUtils.mkdir_p opts.output_dir
|
ruby
|
{
"resource": ""
}
|
q27573
|
HanselCore.Hansel.run
|
test
|
def run
while @jobs.length > 0 do
# do a warm up run first with the highest connection rate
@current_job = @jobs.pop
@current_rate = @current_job.high_rate.to_i
|
ruby
|
{
"resource": ""
}
|
q27574
|
Ropenstack.Identity::Version2.authenticate
|
test
|
def authenticate(username, password, tenant = nil)
data = {
"auth" => {
"passwordCredentials" => {
"username" => username,
"password" => password
}
}
}
|
ruby
|
{
"resource": ""
}
|
q27575
|
Ropenstack.Identity::Version2.add_to_services
|
test
|
def add_to_services(name, type, description)
data = {
'OS-KSADM:service' => {
'name' => name,
'type' => type,
'description'
|
ruby
|
{
"resource": ""
}
|
q27576
|
Ropenstack.Identity::Version2.add_endpoint
|
test
|
def add_endpoint(region, service_id, publicurl, adminurl, internalurl)
data = {
'endpoint' => {
'region' => region,
'service_id' => service_id,
'publicurl' => publicurl,
|
ruby
|
{
"resource": ""
}
|
q27577
|
Ropenstack.Identity::Version2.get_endpoints
|
test
|
def get_endpoints(token = nil)
if token.nil?
return get_request(address("/endpoints"), token())
else
|
ruby
|
{
"resource": ""
}
|
q27578
|
MethodDisabling.ClassMethods.disable_method
|
test
|
def disable_method(method_name, message = nil)
disabled_methods[method_name]
|
ruby
|
{
"resource": ""
}
|
q27579
|
MethodDisabling.DisabledMethod.to_proc
|
test
|
def to_proc
disabled_method = self
# This proc will be evaluated with "self" set to the original object.
Proc.new do |*args, &block|
|
ruby
|
{
"resource": ""
}
|
q27580
|
MethodDisabling.DisabledMethod.execute
|
test
|
def execute(object, *args, &block)
if disabled?
raise NoMethodError,
|
ruby
|
{
"resource": ""
}
|
q27581
|
MethodDisabling.DisabledMethod.alias_method!
|
test
|
def alias_method!
klass.send(:define_method, replacement_name, &self)
klass.send(:alias_method,
|
ruby
|
{
"resource": ""
}
|
q27582
|
Ed25519Keccak.Ed25519Base.secret_to_public
|
test
|
def secret_to_public(secret, form=:byte)
publickey = p_secret_to_public( change_argument_format(secret, form) )
|
ruby
|
{
"resource": ""
}
|
q27583
|
Ed25519Keccak.Ed25519Base.point_equal
|
test
|
def point_equal(pa, pb)
# x1 / z1 == x2 / z2 <==> x1 * z2 == x2 * z1
return false if (pa[0] * pb[2] - pb[0] * pa[2]) % @@p != 0
|
ruby
|
{
"resource": ""
}
|
q27584
|
Ed25519Keccak.Ed25519Base.recover_x
|
test
|
def recover_x(y, sign)
return nil if y >= @@p
# x2 means x^2
x2 = (y*y-1) * modp_inv(@@d*y*y+1)
# when x2==0 and sign!=0, these combination of arguments is illegal
if x2.equal? 0 then
unless sign.equal? 0 then
return nil
else
return 0
end
end
# Compute square root of x2
x = pow_mod(x2 ,
|
ruby
|
{
"resource": ""
}
|
q27585
|
Ed25519Keccak.Ed25519Base.point_decompress
|
test
|
def point_decompress(s)
# check argument
raise ArgumentError , "Invalid input length for decompression" unless s.length.equal? 32
y = int_form_bytes(s)
sign = y >> 255
y &= (1 << 255) - 1
|
ruby
|
{
"resource": ""
}
|
q27586
|
Ed25519Keccak.Ed25519Base.p_secret_to_public
|
test
|
def p_secret_to_public(secret)
expanded = secret_expand(secret)
|
ruby
|
{
"resource": ""
}
|
q27587
|
Semistatic.Page.part
|
test
|
def part(name)
parts.select {|p| p.name.downcase ==
|
ruby
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.