_id
stringlengths 2
6
| title
stringlengths 9
130
| partition
stringclasses 3
values | text
stringlengths 30
4.3k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q800
|
JOSE.JWE.key_encrypt
|
train
|
def key_encrypt(key, decrypted_key)
encrypted_key, new_alg = alg.key_encrypt(key, enc, decrypted_key)
|
ruby
|
{
"resource": ""
}
|
q801
|
JOSE.JWE.next_cek
|
train
|
def next_cek(key)
decrypted_key, new_alg = alg.next_cek(key, enc)
new_jwe = JOSE::JWE.from_map(to_map)
|
ruby
|
{
"resource": ""
}
|
q802
|
Stove.Validator.run
|
train
|
def run(cookbook, options = {})
log.info("Running validations for `#{klass.id}.#{id}'")
inside(cookbook) do
instance = klass.new(cookbook, options)
unless result = instance.instance_eval(&block)
log.debug("Validation failed, result: #{result.inspect}")
# Convert the class and id to their magical equivalents
error =
|
ruby
|
{
"resource": ""
}
|
q803
|
Stove.Packager.tar
|
train
|
def tar(root, slip)
io = StringIO.new('', 'r+b')
Gem::Package::TarWriter.new(io) do |tar|
slip.each do |original_file, tarball_file|
mode = File.stat(original_file).mode
if File.directory?(original_file)
tar.mkdir(tarball_file, mode)
else
|
ruby
|
{
"resource": ""
}
|
q804
|
Stove.Cli.option_parser
|
train
|
def option_parser
@option_parser ||= OptionParser.new do |opts|
opts.banner = 'Usage: stove [OPTIONS]'
opts.separator ''
opts.separator 'Plugins:'
opts.on('--no-git', 'Do not use the git plugin. Skips tagging if specified.') do
options[:no_git] = true
end
opts.separator ''
opts.separator 'Upload Options:'
opts.on('--endpoint [URL]', 'Supermarket endpoint') do |v|
options[:endpoint] = v
end
opts.on('--username [USERNAME]', 'Username to authenticate with') do |v|
options[:username] = v
end
opts.on('--key [PATH]', 'Path to the private key on disk') do |v|
options[:key] = v
end
opts.on('--[no-]extended-metadata', 'Include non-backwards compatible metadata keys such as `issues_url`') do |v|
options[:extended_metadata] = v
end
opts.on('--no-ssl-verify', 'Turn off ssl verify') do
options[:ssl_verify] = false
end
|
ruby
|
{
"resource": ""
}
|
q805
|
Stove.Cli.options
|
train
|
def options
@options ||= {
# Upload options
:endpoint => nil,
:username => Config.username,
:key => Config.key,
:extended_metadata => true,
:ssl_verify => true,
# Git options
:remote => 'origin',
:branch => 'master',
:sign => false,
# Artifactory options
|
ruby
|
{
"resource": ""
}
|
q806
|
Stove.Supermarket.upload
|
train
|
def upload(cookbook, extended_metadata = false)
connection.post('cookbooks', {
'tarball' => cookbook.tarball(extended_metadata),
# This is for legacy, backwards-compatability reasons. The new
# Supermarket site does not require a category, but many of the testing
# tools still assume
|
ruby
|
{
"resource": ""
}
|
q807
|
Stove.Supermarket.connection
|
train
|
def connection
@connection ||= ChefAPI::Connection.new do |conn|
conn.endpoint = ENV['STOVE_ENDPOINT'] || Config.endpoint || DEFAULT_ENDPOINT
conn.client = ENV['STOVE_USERNAME'] || Config.username
conn.key
|
ruby
|
{
"resource": ""
}
|
q808
|
Stove.Artifactory.upload
|
train
|
def upload(cookbook, extended_metadata = false)
# Artifactory doesn't prevent uploading over an existing release in
# some cases so let's check for that. Seriously never do this, go delete
# and then re-upload if you have to.
response = request(:get, "api/v1/cookbooks/#{cookbook.name}/versions/#{cookbook.version}")
# Artifactory's version of the cookbook_version endpoint returns an
|
ruby
|
{
"resource": ""
}
|
q809
|
Stove.Artifactory.connection
|
train
|
def connection
@connection ||= begin
uri = URI(Config.artifactory.strip)
# Open the HTTP connection to artifactory.
http = Net::HTTP.new(uri.host, uri.port)
if uri.scheme == 'https'
http.use_ssl = true
# Mimic the behavior of the Cookbook uploader for SSL verification.
|
ruby
|
{
"resource": ""
}
|
q810
|
Stove.Artifactory.request
|
train
|
def request(method, path, &block)
uri_string = Config.artifactory.strip
# Make sure we end up with the right number of separators.
uri_string << '/' unless uri_string.end_with?('/')
uri_string << path
uri = URI(uri_string)
|
ruby
|
{
"resource": ""
}
|
q811
|
Stove.Cookbook.released?
|
train
|
def released?
Supermarket.cookbook(name, version)
true
|
ruby
|
{
"resource": ""
}
|
q812
|
Stove.Filter.run
|
train
|
def run(cookbook, options = {})
log.info(message)
instance = klass.new(cookbook, options)
inside(cookbook)
|
ruby
|
{
"resource": ""
}
|
q813
|
Erubis.RubyEvaluator.evaluate
|
train
|
def evaluate(_context=Context.new)
_context = Context.new(_context) if _context.is_a?(Hash)
#return _context.instance_eval(@src, @filename || '(erubis)')
#@_proc ||= eval("proc { #{@src} }", Erubis::EMPTY_BINDING, @filename || '(erubis)')
|
ruby
|
{
"resource": ""
}
|
q814
|
Erubis.RubyEvaluator.def_method
|
train
|
def def_method(object, method_name, filename=nil)
m = object.is_a?(Module) ? :module_eval : :instance_eval
object.__send__(m,
|
ruby
|
{
"resource": ""
}
|
q815
|
Erubis.Converter.convert
|
train
|
def convert(input)
codebuf = "" # or []
@preamble.nil? ? add_preamble(codebuf) : (@preamble && (codebuf << @preamble))
convert_input(codebuf, input)
|
ruby
|
{
"resource": ""
}
|
q816
|
Erubis.Converter.detect_spaces_at_bol
|
train
|
def detect_spaces_at_bol(text, is_bol)
lspace = nil
if text.empty?
lspace = "" if is_bol
elsif text[-1] == ?\n
lspace = ""
else
rindex = text.rindex(?\n)
if rindex
s = text[rindex+1..-1]
if s =~ /\A[ \t]*\z/
lspace = s
#text = text[0..rindex]
text[rindex+1..-1] = ''
end
|
ruby
|
{
"resource": ""
}
|
q817
|
Erubis.Engine.process
|
train
|
def process(input, context=nil, filename=nil)
code = convert(input)
filename ||= '(erubis)'
if context.is_a?(Binding)
return eval(code, context, filename)
|
ruby
|
{
"resource": ""
}
|
q818
|
Erubis.Engine.process_proc
|
train
|
def process_proc(proc_obj, context=nil, filename=nil)
if context.is_a?(Binding)
filename ||= '(erubis)'
return eval(proc_obj, context, filename)
else
|
ruby
|
{
"resource": ""
}
|
q819
|
LIBUSB.Device.open
|
train
|
def open
ppHandle = FFI::MemoryPointer.new :pointer
res = Call.libusb_open(@pDev, ppHandle)
LIBUSB.raise_error res, "in libusb_open" if res!=0
handle = DevHandle.new self, ppHandle.read_pointer
|
ruby
|
{
"resource": ""
}
|
q820
|
LIBUSB.Device.max_packet_size
|
train
|
def max_packet_size(endpoint)
endpoint = endpoint.bEndpointAddress if endpoint.respond_to? :bEndpointAddress
|
ruby
|
{
"resource": ""
}
|
q821
|
LIBUSB.Device.max_iso_packet_size
|
train
|
def max_iso_packet_size(endpoint)
endpoint = endpoint.bEndpointAddress if endpoint.respond_to? :bEndpointAddress
|
ruby
|
{
"resource": ""
}
|
q822
|
LIBUSB.Device.config_descriptor
|
train
|
def config_descriptor(index)
ppConfig = FFI::MemoryPointer.new :pointer
res = Call.libusb_get_config_descriptor(@pDev, index, ppConfig)
LIBUSB.raise_error res, "in libusb_get_config_descriptor" if res!=0
|
ruby
|
{
"resource": ""
}
|
q823
|
LIBUSB.Device.configurations
|
train
|
def configurations
configs = []
bNumConfigurations.times do |config_index|
begin
configs << config_descriptor(config_index)
rescue RuntimeError
|
ruby
|
{
"resource": ""
}
|
q824
|
LIBUSB.Context.eventmachine_register
|
train
|
def eventmachine_register
@eventmachine_attached_fds = {}
@eventmachine_timer = nil
pollfds = self.pollfds
if pollfds
pollfds.each do |pollfd|
eventmachine_add_pollfd(pollfd)
end
self.on_pollfd_added do |pollfd|
eventmachine_add_pollfd(pollfd)
end
self.on_pollfd_removed do |pollfd|
eventmachine_rm_pollfd(pollfd)
|
ruby
|
{
"resource": ""
}
|
q825
|
LIBUSB.DevHandle.claim_interface
|
train
|
def claim_interface(interface)
interface = interface.bInterfaceNumber if interface.respond_to? :bInterfaceNumber
res = Call.libusb_claim_interface(@pHandle, interface)
LIBUSB.raise_error res, "in libusb_claim_interface" if res!=0
|
ruby
|
{
"resource": ""
}
|
q826
|
LIBUSB.DevHandle.set_configuration
|
train
|
def set_configuration(configuration)
configuration = configuration.bConfigurationValue if configuration.respond_to? :bConfigurationValue
res =
|
ruby
|
{
"resource": ""
}
|
q827
|
LIBUSB.DevHandle.set_interface_alt_setting
|
train
|
def set_interface_alt_setting(setting_or_interface_number, alternate_setting=nil)
alternate_setting ||= setting_or_interface_number.bAlternateSetting if setting_or_interface_number.respond_to? :bAlternateSetting
|
ruby
|
{
"resource": ""
}
|
q828
|
LIBUSB.DevHandle.kernel_driver_active?
|
train
|
def kernel_driver_active?(interface)
interface = interface.bInterfaceNumber if interface.respond_to? :bInterfaceNumber
|
ruby
|
{
"resource": ""
}
|
q829
|
LIBUSB.DevHandle.detach_kernel_driver
|
train
|
def detach_kernel_driver(interface)
interface = interface.bInterfaceNumber if interface.respond_to? :bInterfaceNumber
res = Call.libusb_detach_kernel_driver(@pHandle,
|
ruby
|
{
"resource": ""
}
|
q830
|
LIBUSB.DevHandle.bulk_transfer
|
train
|
def bulk_transfer(args={}, &block)
timeout = args.delete(:timeout) || 1000
endpoint = args.delete(:endpoint) || raise(ArgumentError, "no endpoint given")
endpoint = endpoint.bEndpointAddress if endpoint.respond_to? :bEndpointAddress
if endpoint&ENDPOINT_IN != 0
dataIn = args.delete(:dataIn) || raise(ArgumentError, "no :dataIn given for bulk read")
|
ruby
|
{
"resource": ""
}
|
q831
|
LIBUSB.DevHandle.control_transfer
|
train
|
def control_transfer(args={}, &block)
bmRequestType = args.delete(:bmRequestType) || raise(ArgumentError, "param :bmRequestType not given")
bRequest = args.delete(:bRequest) || raise(ArgumentError, "param :bRequest not given")
wValue = args.delete(:wValue) || raise(ArgumentError, "param :wValue not given")
wIndex = args.delete(:wIndex) || raise(ArgumentError, "param :wIndex not given")
timeout = args.delete(:timeout) || 1000
if bmRequestType&ENDPOINT_IN != 0
dataIn = args.delete(:dataIn) || 0
dataOut = ''
else
dataOut = args.delete(:dataOut) || ''
end
raise ArgumentError, "invalid params #{args.inspect}" unless args.empty?
# reuse transfer struct to speed up transfer
|
ruby
|
{
"resource": ""
}
|
q832
|
LIBUSB.Bos.device_capabilities
|
train
|
def device_capabilities
pp_ext = FFI::MemoryPointer.new :pointer
caps = []
# Capabilities are appended to the bos header
ptr = pointer + offset_of(:dev_capability)
bNumDeviceCaps.times do
cap = DeviceCapability.new self, ptr.read_pointer
case cap.bDevCapabilityType
when LIBUSB::BT_WIRELESS_USB_DEVICE_CAPABILITY
# no struct defined in libusb -> use generic DeviceCapability
when LIBUSB::BT_USB_2_0_EXTENSION
|
ruby
|
{
"resource": ""
}
|
q833
|
LIBUSB.Transfer.submit!
|
train
|
def submit!(&block)
self.callback = block if block_given?
# puts "submit transfer #{@transfer.inspect} buffer: #{@transfer[:buffer].inspect} length: #{@transfer[:length].inspect} status: #{@transfer[:status].inspect} callback: #{@transfer[:callback].inspect}
|
ruby
|
{
"resource": ""
}
|
q834
|
LIBUSB.Transfer.submit_and_wait
|
train
|
def submit_and_wait
raise ArgumentError, "#{self.class}#dev_handle not set" unless @dev_handle
@completion_flag.completed = false
submit! do |tr2|
@completion_flag.completed = true
end
until @completion_flag.completed?
|
ruby
|
{
"resource": ""
}
|
q835
|
LIBUSB.Context.handle_events
|
train
|
def handle_events(timeout=nil, completion_flag=nil)
if completion_flag && !completion_flag.is_a?(Context::CompletionFlag)
raise ArgumentError, "completion_flag is not a CompletionFlag"
end
if timeout
timeval = Call::Timeval.new
timeval.in_ms = timeout
res = if Call.respond_to?(:libusb_handle_events_timeout_completed)
Call.libusb_handle_events_timeout_completed(@ctx, timeval, completion_flag)
else
Call.libusb_handle_events_timeout(@ctx, timeval)
|
ruby
|
{
"resource": ""
}
|
q836
|
LIBUSB.Context.devices
|
train
|
def devices(filter_hash={})
device_list.select do |dev|
( !filter_hash[:bClass] || (dev.bDeviceClass==CLASS_PER_INTERFACE ?
dev.settings.map(&:bInterfaceClass).&([filter_hash[:bClass]].flatten).any? :
[filter_hash[:bClass]].flatten.include?(dev.bDeviceClass))) &&
( !filter_hash[:bSubClass] || (dev.bDeviceClass==CLASS_PER_INTERFACE ?
dev.settings.map(&:bInterfaceSubClass).&([filter_hash[:bSubClass]].flatten).any? :
[filter_hash[:bSubClass]].flatten.include?(dev.bDeviceSubClass))) &&
( !filter_hash[:bProtocol] || (dev.bDeviceClass==CLASS_PER_INTERFACE ?
dev.settings.map(&:bInterfaceProtocol).&([filter_hash[:bProtocol]].flatten).any? :
|
ruby
|
{
"resource": ""
}
|
q837
|
LIBUSB.Context.pollfds
|
train
|
def pollfds
ppPollfds = Call.libusb_get_pollfds(@ctx)
return nil if ppPollfds.null?
offs = 0
pollfds = []
while !(pPollfd=ppPollfds.get_pointer(offs)).null?
pollfd = Call::Pollfd.new pPollfd
pollfds << Pollfd.new(pollfd[:fd], pollfd[:events])
offs += FFI.type_size :pointer
end
|
ruby
|
{
"resource": ""
}
|
q838
|
LIBUSB.Context.next_timeout
|
train
|
def next_timeout
timeval = Call::Timeval.new
res = Call.libusb_get_next_timeout @ctx, timeval
LIBUSB.raise_error
|
ruby
|
{
"resource": ""
}
|
q839
|
LIBUSB.Context.on_pollfd_added
|
train
|
def on_pollfd_added &block
@on_pollfd_added = proc do |fd, events, _|
pollfd = Pollfd.new fd, events
block.call pollfd
|
ruby
|
{
"resource": ""
}
|
q840
|
LIBUSB.Context.on_pollfd_removed
|
train
|
def on_pollfd_removed &block
@on_pollfd_removed = proc do |fd, _|
pollfd = Pollfd.new fd
block.call pollfd
end
|
ruby
|
{
"resource": ""
}
|
q841
|
LIBUSB.Context.on_hotplug_event
|
train
|
def on_hotplug_event(args={}, &block)
events = args.delete(:events) || (HOTPLUG_EVENT_DEVICE_ARRIVED | HOTPLUG_EVENT_DEVICE_LEFT)
flags = args.delete(:flags) || 0
vendor_id = args.delete(:vendor_id) || HOTPLUG_MATCH_ANY
product_id = args.delete(:product_id) || HOTPLUG_MATCH_ANY
dev_class = args.delete(:dev_class) || HOTPLUG_MATCH_ANY
raise ArgumentError, "invalid params #{args.inspect}" unless args.empty?
handle = HotplugCallback.new self, @ctx, @hotplug_callbacks
block2 = proc do |ctx, pDevice, event, _user_data|
|
ruby
|
{
"resource": ""
}
|
q842
|
Telegrammer.Bot.send_message
|
train
|
def send_message(params)
extra_params_validation = {
text: { required: true, class: [String] },
parse_mode: { required: false,
|
ruby
|
{
"resource": ""
}
|
q843
|
Telegrammer.Bot.forward_message
|
train
|
def forward_message(params)
params_validation = {
chat_id: { required: true, class: [Fixnum] },
from_chat_id: { required: true, class: [String] },
|
ruby
|
{
"resource": ""
}
|
q844
|
Telegrammer.Bot.send_photo
|
train
|
def send_photo(params)
extra_params_validation = {
photo: { required: true, class: [File, String] },
caption: { required: false, class: [String] }
|
ruby
|
{
"resource": ""
}
|
q845
|
Telegrammer.Bot.send_audio
|
train
|
def send_audio(params)
extra_params_validation = {
audio: { required: true, class: [File, String] },
duration: { required: false, class: [Integer] },
performer: { required: false, class: [String]
|
ruby
|
{
"resource": ""
}
|
q846
|
Telegrammer.Bot.send_voice
|
train
|
def send_voice(params)
extra_params_validation = {
voice: { required: true, class: [File, String] },
duration: { required: false, class: [Integer] }
|
ruby
|
{
"resource": ""
}
|
q847
|
Telegrammer.Bot.send_document
|
train
|
def send_document(params)
extra_params_validation = {
document: { required: true, class: [File, String] }
}
|
ruby
|
{
"resource": ""
}
|
q848
|
Telegrammer.Bot.send_sticker
|
train
|
def send_sticker(params)
extra_params_validation = {
sticker: { required: true, class: [File, String] }
}
|
ruby
|
{
"resource": ""
}
|
q849
|
Telegrammer.Bot.send_video
|
train
|
def send_video(params)
extra_params_validation = {
video: { required: true, class: [File, String] },
duration: { required: false, class: [Integer] },
caption: {
|
ruby
|
{
"resource": ""
}
|
q850
|
Telegrammer.Bot.send_location
|
train
|
def send_location(params)
extra_params_validation = {
latitude: { required: true, class: [Float] },
longitude: { required: true, class: [Float] }
|
ruby
|
{
"resource": ""
}
|
q851
|
Telegrammer.Bot.send_chat_action
|
train
|
def send_chat_action(params)
params_validation = {
chat_id: { required: true, class: [Fixnum, String] },
action: { required: true, class: [String] }
|
ruby
|
{
"resource": ""
}
|
q852
|
Telegrammer.Bot.get_user_profile_photos
|
train
|
def get_user_profile_photos(params)
params_validation = {
user_id: { required: true, class: [Fixnum] },
offset: { required: false, class: [Fixnum] },
|
ruby
|
{
"resource": ""
}
|
q853
|
Telegrammer.Bot.get_file
|
train
|
def get_file(params)
params_validation = {
file_id: { required: true, class: [String] }
}
response = api_request("getFile", params, params_validation)
file_object
|
ruby
|
{
"resource": ""
}
|
q854
|
Telegrammer.Bot.answer_inline_query
|
train
|
def answer_inline_query(params)
params_validation = {
inline_query_id: { required: true, class: [String] },
results: { required: true, class: [Array] },
cache_time: { required: false, class: [Fixnum] },
is_personal: { required: false,
|
ruby
|
{
"resource": ""
}
|
q855
|
GoogleMapsService::Apis.DistanceMatrix.distance_matrix
|
train
|
def distance_matrix(origins, destinations,
mode: nil, language: nil, avoid: nil, units: nil,
departure_time: nil, arrival_time: nil, transit_mode: nil,
transit_routing_preference: nil)
params = {
origins: GoogleMapsService::Convert.waypoints(origins),
destinations: GoogleMapsService::Convert.waypoints(destinations)
}
params[:language] = language if language
params[:mode] = GoogleMapsService::Validator.travel_mode(mode) if mode
|
ruby
|
{
"resource": ""
}
|
q856
|
GoogleMapsService.Convert.components
|
train
|
def components(arg)
if arg.kind_of?(Hash)
arg = arg.sort.map { |k, v| "#{k}:#{v}" }
return arg.join("|")
end
|
ruby
|
{
"resource": ""
}
|
q857
|
GoogleMapsService.Convert.waypoint
|
train
|
def waypoint(waypoint)
if waypoint.kind_of?(String)
return waypoint
end
|
ruby
|
{
"resource": ""
}
|
q858
|
GoogleMapsService::Apis.Geocoding.reverse_geocode
|
train
|
def reverse_geocode(latlng, location_type: nil, result_type: nil, language: nil)
params = {
latlng: GoogleMapsService::Convert.latlng(latlng)
}
params[:result_type] = GoogleMapsService::Convert.join_list('|', result_type) if result_type
|
ruby
|
{
"resource": ""
}
|
q859
|
GoogleMapsService::Apis.TimeZone.timezone
|
train
|
def timezone(location, timestamp: Time.now, language: nil)
location = GoogleMapsService::Convert.latlng(location)
timestamp = GoogleMapsService::Convert.time(timestamp)
|
ruby
|
{
"resource": ""
}
|
q860
|
GoogleMapsService.Url.sign_hmac
|
train
|
def sign_hmac(secret, payload)
secret = secret.encode('ASCII')
payload = payload.encode('ASCII')
# Decode the private key
raw_key = Base64.urlsafe_decode64(secret)
# Create a signature using the private key and the URL
digest = OpenSSL::Digest.new('sha1')
|
ruby
|
{
"resource": ""
}
|
q861
|
GoogleMapsService.Url.unquote_unreserved
|
train
|
def unquote_unreserved(uri)
parts = uri.split('%')
(1..parts.length-1).each do |i|
h = parts[i][0..1]
if h =~ /^([\h]{2})(.*)/ and c = $1.to_i(16).chr and UNRESERVED_SET.include?(c)
|
ruby
|
{
"resource": ""
}
|
q862
|
GoogleMapsService.Client.new_client
|
train
|
def new_client
client = Hurley::Client.new
client.request_options.query_class = Hurley::Query::Flat
client.request_options.redirection_limit = 0
client.header[:user_agent] = user_agent
client.connection = @connection if @connection
|
ruby
|
{
"resource": ""
}
|
q863
|
GoogleMapsService.Client.get
|
train
|
def get(path, params, base_url: DEFAULT_BASE_URL, accepts_client_id: true, custom_response_decoder: nil)
url = base_url + generate_auth_url(path, params, accepts_client_id)
Retriable.retriable timeout: @retry_timeout, on: RETRIABLE_ERRORS do |try|
begin
request_query_ticket
response =
|
ruby
|
{
"resource": ""
}
|
q864
|
GoogleMapsService.Client.generate_auth_url
|
train
|
def generate_auth_url(path, params, accepts_client_id)
# Deterministic ordering through sorting by key.
# Useful for tests, and in the future, any caching.
if params.kind_of?(Hash)
params = params.sort
else
params = params.dup
end
if accepts_client_id and @client_id and @client_secret
params << ["client", @client_id]
path = [path, GoogleMapsService::Url.urlencode_params(params)].join("?")
sig = GoogleMapsService::Url.sign_hmac(@client_secret,
|
ruby
|
{
"resource": ""
}
|
q865
|
GoogleMapsService.Client.decode_response_body
|
train
|
def decode_response_body(response)
check_response_status_code(response)
|
ruby
|
{
"resource": ""
}
|
q866
|
GoogleMapsService.Client.check_response_status_code
|
train
|
def check_response_status_code(response)
case response.status_code
when 200..300
# Do-nothing
when 301, 302, 303, 307
raise GoogleMapsService::Error::RedirectError.new(response), sprintf('Redirect to %s', response.header[:location])
when 401
raise GoogleMapsService::Error::ClientError.new(response), 'Unauthorized'
when 304, 400, 402...500
|
ruby
|
{
"resource": ""
}
|
q867
|
GoogleMapsService::Apis.Directions.directions
|
train
|
def directions(origin, destination,
mode: nil, waypoints: nil, alternatives: false, avoid: nil,
language: nil, units: nil, region: nil, departure_time: nil,
arrival_time: nil, optimize_waypoints: false, transit_mode: nil,
transit_routing_preference: nil)
params = {
origin: GoogleMapsService::Convert.waypoint(origin),
destination: GoogleMapsService::Convert.waypoint(destination)
}
params[:mode] = GoogleMapsService::Validator.travel_mode(mode) if mode
if waypoints = waypoints
waypoints = GoogleMapsService::Convert.as_list(waypoints)
waypoints = waypoints.map { |waypoint| GoogleMapsService::Convert.waypoint(waypoint) }
waypoints = ['optimize:true'] + waypoints if optimize_waypoints
params[:waypoints] = GoogleMapsService::Convert.join_list("|", waypoints)
end
params[:alternatives] = 'true' if alternatives
params[:avoid] = GoogleMapsService::Convert.join_list('|', avoid) if avoid
params[:language] = language if language
|
ruby
|
{
"resource": ""
}
|
q868
|
GoogleMapsService::Apis.Elevation.elevation_along_path
|
train
|
def elevation_along_path(path, samples)
if path.kind_of?(String)
path = "enc:%s" % path
else
path = GoogleMapsService::Convert.waypoints(path)
|
ruby
|
{
"resource": ""
}
|
q869
|
GoogleMapsService::Apis.Roads.snap_to_roads
|
train
|
def snap_to_roads(path, interpolate: false)
path = GoogleMapsService::Convert.waypoints(path)
params = {
path: path
}
params[:interpolate] = 'true' if interpolate
return get('/v1/snapToRoads', params,
base_url: ROADS_BASE_URL,
|
ruby
|
{
"resource": ""
}
|
q870
|
GoogleMapsService::Apis.Roads.nearest_roads
|
train
|
def nearest_roads(points)
points = GoogleMapsService::Convert.waypoints(points)
params = {
points: points
}
return get('/v1/nearestRoads', params,
base_url: ROADS_BASE_URL,
|
ruby
|
{
"resource": ""
}
|
q871
|
GoogleMapsService::Apis.Roads.extract_roads_body
|
train
|
def extract_roads_body(response)
begin
body = MultiJson.load(response.body, :symbolize_keys => true)
rescue
unless response.status_code == 200
check_response_status_code(response)
end
raise GoogleMapsService::Error::ApiError.new(response), 'Received a malformed response.'
end
|
ruby
|
{
"resource": ""
}
|
q872
|
GoogleMapsService.Polyline.encode
|
train
|
def encode(points)
last_lat = last_lng = 0
result = ""
points.each do |point|
ll = GoogleMapsService::Convert.normalize_latlng(point)
lat = (ll[0] * 1e5).round.to_i
lng = (ll[1] * 1e5).round.to_i
d_lat = lat - last_lat
d_lng = lng - last_lng
[d_lat, d_lng].each do |v|
v = (v < 0) ? ~(v << 1) : (v << 1)
while v >= 0x20
|
ruby
|
{
"resource": ""
}
|
q873
|
Mongoid::FullTextSearch.ClassMethods.map_query_filters
|
train
|
def map_query_filters(filters)
Hash[filters.map do |key, value|
case value
when Hash then
if value.key? :any then format_query_filter('$in', key, value[:any])
elsif value.key? :all then format_query_filter('$all', key, value[:all])
|
ruby
|
{
"resource": ""
}
|
q874
|
Stickler.SpecLite.=~
|
train
|
def =~(other)
other = coerce( other )
return (other and
self.name == other.name and
self.version.to_s ==
|
ruby
|
{
"resource": ""
}
|
q875
|
::Stickler::Repository.RemoteMirror.mirror
|
train
|
def mirror( spec, upstream_host )
raise Stickler::Repository::Error, "gem #{spec.full_name} already exists in remote repository" if remote_gem_file_exist?( spec )
|
ruby
|
{
"resource": ""
}
|
q876
|
Stickler::Middleware.Index.marshalled_specs
|
train
|
def marshalled_specs( spec_a )
a = spec_a.collect { |s| s.to_rubygems_a }
|
ruby
|
{
"resource": ""
}
|
q877
|
Stickler.Client.parser
|
train
|
def parser
me = self # scoping forces this
@parser ||= Trollop::Parser.new do
banner me.class.banner
opt :server, "The gem or stickler server URL", :type => :string, :default => Client.config.server
|
ruby
|
{
"resource": ""
}
|
q878
|
Flickr.Attribute.find_value
|
train
|
def find_value(context)
locations.each do |location|
begin
value = context.instance_exec(&location)
next if value.nil?
|
ruby
|
{
"resource": ""
}
|
q879
|
Flickr.AttributeSet.add_locations
|
train
|
def add_locations(hash)
hash.each do |attribute_name, locations|
|
ruby
|
{
"resource": ""
}
|
q880
|
Helpers.ClassMethods.record_api_methods
|
train
|
def record_api_methods
before do
stub_const("Flickr::Client::Data", Class.new(Flickr::Client::Data) do
def do_request(http_method, flickr_method, params = {})
VCR.use_cassette(flickr_method) { super }
end
end)
stub_const("Flickr::Client::Upload", Class.new(Flickr::Client::Upload) do
|
ruby
|
{
"resource": ""
}
|
q881
|
Flickr.Object.inspect
|
train
|
def inspect
attribute_values = self.class.attributes
.inject({}) { |hash, attribute| hash.update(attribute.name => send(attribute.name)) }
.reject { |name, value| value.nil? or (value.respond_to?(:empty?) and value.empty?)
|
ruby
|
{
"resource": ""
}
|
q882
|
Flickr.SanitizedFile.sanitize!
|
train
|
def sanitize!
if rails_file?
@file = @original
@content_type = @original.content_type
@path = @original.tempfile
elsif sinatra_file?
@file = @original[:tempfile]
@content_type = @original[:type]
@path = @original[:tempfile].path
elsif io?
@file = @original
@content_type = @original.content_type if @original.respond_to?(:content_type)
|
ruby
|
{
"resource": ""
}
|
q883
|
Jquery.Helpers.link_to_modal
|
train
|
def link_to_modal(*args, &block)
if block_given?
options = args.first || {}
html_options = args.second
block_result = capture(&block)
link_to_modal(block_result, options, html_options)
else
name = args[0]
options = args[1] || {}
html_options = args[2] || {}
# extend the html_options
html_options[:rel] = "modal:open"
if (html_options.has_key?(:remote))
if (html_options[:remote] == true)
html_options[:rel] = "modal:open:ajaxpost"
end
# remove the remote tag
|
ruby
|
{
"resource": ""
}
|
q884
|
JekyllData.Reader.read_theme_data
|
train
|
def read_theme_data
if @theme.data_path
#
# show contents of "<theme>/_data/" dir being read while degugging.
inspect_theme_data
theme_data = ThemeDataReader.new(site).read(site.config["data_dir"])
@site.data = Jekyll::Utils.deep_merge_hashes(theme_data, @site.data)
#
# show contents of merged site.data hash
|
ruby
|
{
"resource": ""
}
|
q885
|
JekyllData.Reader.inspect_inner_hash
|
train
|
def inspect_inner_hash(hash)
hash.each do |key, value|
if value.is_a? Array
print_label key
extract_hashes_and_print value
elsif value.is_a? Hash
|
ruby
|
{
"resource": ""
}
|
q886
|
JekyllData.Reader.print_subkey_and_value
|
train
|
def print_subkey_and_value(key, value)
print_label key
value.each do |subkey, val|
if val.is_a? Hash
print_inner_subkey subkey
inspect_inner_hash val
elsif val.is_a? Array
print_inner_subkey subkey
|
ruby
|
{
"resource": ""
}
|
q887
|
PahoMqtt.ConnectionHelper.should_send_ping?
|
train
|
def should_send_ping?(now, keep_alive, last_packet_received_at)
last_pingreq_sent_at = @sender.last_pingreq_sent_at
last_pingresp_received_at = @handler.last_pingresp_received_at
if !last_pingreq_sent_at || (last_pingresp_received_at && (last_pingreq_sent_at <= last_pingresp_received_at))
|
ruby
|
{
"resource": ""
}
|
q888
|
Picasa.Utils.array_wrap
|
train
|
def array_wrap(object)
if object.nil?
[]
elsif object.respond_to?(:to_ary)
object.to_ary
|
ruby
|
{
"resource": ""
}
|
q889
|
RSpecCommand.MatchFixture.failure_message
|
train
|
def failure_message
matching_files = @fixture.files & @local.files
fixture_only_files = @fixture.files - @local.files
local_only_files = @local.files - @fixture.files
buf = "expected fixture #{@fixture.path} to match files:\n"
(@fixture.files | @local.files).sort.each do |file|
if matching_files.include?(file)
local_file = @local.absolute(file)
fixture_file = @fixture.absolute(file)
if File.directory?(local_file) && File.directory?(fixture_file)
# Do nothing
elsif File.directory?(fixture_file)
buf << " #{file} should be a directory\n"
elsif File.directory?(local_file)
buf << " #{file} should not be a directory"
else
actual = IO.read(local_file)
expected = IO.read(fixture_file)
if actual != expected
# Show a diff
|
ruby
|
{
"resource": ""
}
|
q890
|
RSpecCommand.MatchFixture.file_content_match?
|
train
|
def file_content_match?
@fixture.full_files.zip(@local.full_files).all? do |fixture_file, local_file|
if File.directory?(fixture_file)
File.directory?(local_file)
|
ruby
|
{
"resource": ""
}
|
q891
|
RSpecCommand.ClassMethods.file
|
train
|
def file(path, content=nil, &block)
raise "file path should be relative the the temporary directory." if path == File.expand_path(path)
before do
content = instance_eval(&block) if
|
ruby
|
{
"resource": ""
}
|
q892
|
RSpecCommand.ClassMethods.fixture_file
|
train
|
def fixture_file(path, dest=nil)
raise "file path should be relative the the temporary directory." if path == File.expand_path(path)
before do |example|
fixture_path = find_fixture(example.file_path, path)
dest_path = dest ? File.join(temp_path, dest) : temp_path
FileUtils.mkdir_p(dest_path)
file_list = MatchFixture::FileList.new(fixture_path)
file_list.files.each do |file|
|
ruby
|
{
"resource": ""
}
|
q893
|
RSpecCommand.ClassMethods.environment
|
train
|
def environment(variables)
before do
variables.each do |key, value|
if value.nil?
_environment.delete(key.to_s)
else
|
ruby
|
{
"resource": ""
}
|
q894
|
DataMagic.StandardTranslation.randomize
|
train
|
def randomize(value)
case value
when Array then value[rand(value.size)]
when Range then
|
ruby
|
{
"resource": ""
}
|
q895
|
DataMagic.StandardTranslation.sequential
|
train
|
def sequential(value)
index = index_variable_for(value)
index = (index ? index + 1 : 0)
index = 0 if index ==
|
ruby
|
{
"resource": ""
}
|
q896
|
ActionAccess.Keeper.let
|
train
|
def let(clearance_level, actions, resource, options = {})
clearance_level = clearance_level.to_s.singularize.to_sym
actions = Array(actions).map(&:to_sym)
controller = get_controller_name(resource, options)
@rules[controller] ||= {}
|
ruby
|
{
"resource": ""
}
|
q897
|
ActionAccess.Keeper.lets?
|
train
|
def lets?(clearance_level, action, resource, options = {})
clearance_level = clearance_level.to_s.singularize.to_sym
action = action.to_sym
controller = get_controller_name(resource, options)
# Load the controller to ensure its rules are loaded (lazy loading rules).
controller.constantize.new
rules = @rules[controller]
return false unless rules
|
ruby
|
{
"resource": ""
}
|
q898
|
ActionAccess.ControllerAdditions.validate_access!
|
train
|
def validate_access!
action = self.action_name
clearance_levels = Array(current_clearance_levels)
authorized
|
ruby
|
{
"resource": ""
}
|
q899
|
ActionAccess.ControllerAdditions.not_authorized!
|
train
|
def not_authorized!(*args)
options = args.extract_options!
message = options[:message] ||
I18n.t('action_access.redirection_message', default: 'Not authorized.')
|
ruby
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.