_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3 values | text stringlengths 66 10.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q1000 | Sweetify.SweetAlert.sweetalert | train | def sweetalert(text, title = '', opts = {})
opts = {
showConfirmButton: false,
timer: 2000,
allowOutsideClick: true,
confirmButtonText: 'OK'
}.merge(opts)
opts[:text] = text
opts[:title] = title
if opts[:button]
opts[:showConfirmButton] = true
opts[:confirmButtonText] = opts[:button] if opts[:button].is_a?(String)
opts.delete(:button)
end
if opts[:persistent]
opts[:showConfirmButton] = true
opts[:allowOutsideClick] = false
opts[:timer] = nil
opts[:confirmButtonText] = opts[:persistent] if opts[:persistent].is_a?(String)
opts.delete(:persistent)
end
flash_config(opts)
end | ruby | {
"resource": ""
} |
q1001 | Sweetify.SweetAlert.flash_config | train | def flash_config(opts)
if opts[:title].blank?
opts[:title] = opts[:text]
opts.delete(:text)
end
flash[:sweetify] = opts.to_json
end | ruby | {
"resource": ""
} |
q1002 | Exchanger.Element.to_xml | train | def to_xml(options = {})
doc = Nokogiri::XML::Document.new
root = doc.create_element(tag_name)
self.class.keys.each do |name|
value = read_attribute(name)
next if value.blank?
root[name.to_s.camelize] = value
end
self.class.elements.each do |name, field|
next if options[:only] && !options[:only].include?(name)
next if field.options[:readonly]
value = read_attribute(name)
next if field.type.is_a?(Array) && value.blank?
next if new_record? && field.type == Identifier
next if new_record? && value.blank?
if name == :text
root << value.to_s
else
root << field.to_xml(value)
end
end
root
end | ruby | {
"resource": ""
} |
q1003 | Middleware.Builder.insert | train | def insert(index, middleware, *args, &block)
index = self.index(index) unless index.is_a?(Integer)
raise "no such middleware to insert before: #{index.inspect}" unless index
stack.insert(index, [middleware, args, block])
end | ruby | {
"resource": ""
} |
q1004 | Middleware.Builder.replace | train | def replace(index, middleware, *args, &block)
if index.is_a?(Integer)
delete(index)
insert(index, middleware, *args, &block)
else
insert_before(index, middleware, *args, &block)
delete(index)
end
end | ruby | {
"resource": ""
} |
q1005 | Exchanger.Persistence.reload | train | def reload
if new_record?
false
else
reloaded_element = self.class.find(self.id)
@attributes = reloaded_element.attributes
reset_modifications
true
end
end | ruby | {
"resource": ""
} |
q1006 | Exchanger.Field.to_xml | train | def to_xml(value, options = {})
if value.is_a?(Exchanger::Element)
value.tag_name = tag_name
value.to_xml(options)
else
doc = Nokogiri::XML::Document.new
root = doc.create_element(tag_name)
case value
when Array
value.each do |sub_value|
root << sub_field.to_xml(sub_value, options)
end
when Boolean
root << doc.create_text_node(value == true)
when Time
root << doc.create_text_node(value.xmlschema)
else # String, Integer, etc
root << doc.create_text_node(value.to_s)
end
root
end
end | ruby | {
"resource": ""
} |
q1007 | Exchanger.Field.value_from_xml | train | def value_from_xml(node)
if type.respond_to?(:new_from_xml)
type.new_from_xml(node)
elsif type.is_a?(Array)
node.children.map do |sub_node|
sub_field.value_from_xml(sub_node)
end
elsif type == Boolean
node.text == "true"
elsif type == Integer
node.text.to_i unless node.text.empty?
elsif type == Time
Time.xmlschema(node.text) unless node.text.empty?
else
node.text
end
end | ruby | {
"resource": ""
} |
q1008 | Exchanger.Dirty.reset_attribute! | train | def reset_attribute!(name)
value = attribute_was(name)
if value
@attributes[name] = value
modifications.delete(name)
end
end | ruby | {
"resource": ""
} |
q1009 | Exchanger.Dirty.accessed | train | def accessed(name, value)
@accessed ||= {}
@accessed[name] = value.dup if (value.is_a?(Array) || value.is_a?(Hash)) && !@accessed.has_key?(name)
value
end | ruby | {
"resource": ""
} |
q1010 | Exchanger.Dirty.modifications | train | def modifications
@accessed.each_pair do |field, value|
current = @attributes[field]
if current != value || (current.is_a?(Array) &&
current.any? { |v| v.respond_to?(:changed?) && v.changed? })
@modifications[field] = [ value, current ]
end
end
@accessed.clear
@modifications
end | ruby | {
"resource": ""
} |
q1011 | Exchanger.Dirty.modify | train | def modify(name, old_value, new_value)
@attributes[name] = new_value
if @modifications && (old_value != new_value)
original = @modifications[name].first if @modifications[name]
@modifications[name] = [ (original || old_value), new_value ]
end
end | ruby | {
"resource": ""
} |
q1012 | Exchanger.Attributes.method_missing | train | def method_missing(name, *args)
attr = name.to_s.sub("=", "")
return super unless attributes.has_key?(attr)
if name.to_s.ends_with?("=")
write_attribute(attr, *args)
else
read_attribute(attr)
end
end | ruby | {
"resource": ""
} |
q1013 | Exchanger.Client.request | train | def request(post_body, headers)
response = @client.post(endpoint, post_body, headers)
return { :status => response.status, :body => response.content, :content_type => response.contenttype }
end | ruby | {
"resource": ""
} |
q1014 | Adauth.Connection.bind | train | def bind
conn = Net::LDAP.new :host => @config[:server],
:port => @config[:port],
:base => @config[:base]
if @config[:encryption]
conn.encryption @config[:encryption]
end
raise "Anonymous Bind is disabled" if @config[:password] == "" && !(@config[:anonymous_bind])
conn.auth "#{@config[:username]}@#{@config[:domain]}", @config[:password]
begin
Timeout::timeout(10){
if conn.bind
return conn
else
raise 'Query User Rejected'
end
}
rescue Timeout::Error
raise 'Unable to connect to LDAP Server'
rescue Errno::ECONNRESET
if @config[:allow_fallback]
@config[:port] = @config[:allow_fallback]
@config[:encryption] = false
return Adauth::Connection.new(@config).bind
end
end
end | ruby | {
"resource": ""
} |
q1015 | Nextcloud.Api.request | train | def request(method, path, params = nil, body = nil, depth = nil, destination = nil, raw = false)
response = Net::HTTP.start(@url.host, @url.port,
use_ssl: @url.scheme == "https") do |http|
req = Kernel.const_get("Net::HTTP::#{method.capitalize}").new(@url.request_uri + path)
req["OCS-APIRequest"] = true
req.basic_auth @username, @password
req["Content-Type"] = "application/x-www-form-urlencoded"
req["Depth"] = 0 if depth
req["Destination"] = destination if destination
req.set_form_data(params) if params
req.body = body if body
http.request(req)
end
# if ![201, 204, 207].include? response.code
# raise Errors::Error.new("Nextcloud received invalid status code")
# end
raw ? response.body : Nokogiri::XML.parse(response.body)
end | ruby | {
"resource": ""
} |
q1016 | Nextcloud.Helpers.parse_with_meta | train | def parse_with_meta(doc, xpath)
groups = []
doc.xpath(xpath).each do |prop|
groups << prop.text
end
meta = get_meta(doc)
groups.send(:define_singleton_method, :meta) do
meta
end
groups
end | ruby | {
"resource": ""
} |
q1017 | Nextcloud.Helpers.get_meta | train | def get_meta(doc)
meta = doc.xpath("//meta/*").each_with_object({}) do |node, meta|
meta[node.name] = node.text
end
end | ruby | {
"resource": ""
} |
q1018 | Nextcloud.Helpers.doc_to_hash | train | def doc_to_hash(doc, xpath = "/")
h = Hash.from_xml(doc.xpath(xpath).to_xml)
h
end | ruby | {
"resource": ""
} |
q1019 | Nextcloud.Helpers.add_meta | train | def add_meta(doc, obj)
meta = get_meta(doc)
obj.define_singleton_method(:meta) { meta } && obj
end | ruby | {
"resource": ""
} |
q1020 | Nextcloud.Helpers.parse_dav_response | train | def parse_dav_response(doc)
doc.remove_namespaces!
if doc.at_xpath("//error")
{
exception: doc.xpath("//exception").text,
message: doc.xpath("//message").text
}
elsif doc.at_xpath("//status")
{
status: doc.xpath("//status").text
}
else
{
status: "ok"
}
end
end | ruby | {
"resource": ""
} |
q1021 | Nextcloud.Helpers.has_dav_errors | train | def has_dav_errors(doc)
doc.remove_namespaces!
if doc.at_xpath("//error")
{
exception: doc.xpath("//exception").text,
message: doc.xpath("//message").text
}
else
false
end
end | ruby | {
"resource": ""
} |
q1022 | Adauth.AdObject.handle_field | train | def handle_field(field)
case field
when Symbol then return return_symbol_value(field)
when Array then return @ldap_object.try(field.first).try(:collect, &field.last)
end
end | ruby | {
"resource": ""
} |
q1023 | Adauth.AdObject.cn_groups_nested | train | def cn_groups_nested
@cn_groups_nested = cn_groups
cn_groups.each do |group|
ado = Adauth::AdObjects::Group.where('name', group).first
if ado
groups = convert_to_objects ado.cn_groups
groups.each do |g|
@cn_groups_nested.push g if !(@cn_groups_nested.include?(g))
end
end
end
return @cn_groups_nested
end | ruby | {
"resource": ""
} |
q1024 | Adauth.AdObject.ous | train | def ous
unless @ous
@ous = []
@ldap_object.dn.split(/,/).each do |entry|
@ous.push Adauth::AdObjects::OU.where('name', entry.gsub(/OU=/, '')).first if entry =~ /OU=/
end
end
@ous
end | ruby | {
"resource": ""
} |
q1025 | Adauth.AdObject.modify | train | def modify(operations)
Adauth.logger.info(self.class.inspect) { "Attempting modify operation" }
unless Adauth.connection.modify :dn => @ldap_object.dn, :operations => operations
Adauth.logger.fatal(self.class.inspect) { "Modify Operation Failed! Code: #{Adauth.connection.get_operation_result.code} Message: #{Adauth.connection.get_operation_result.message}" }
raise 'Modify Operation Failed (see log for details)'
end
end | ruby | {
"resource": ""
} |
q1026 | Adauth.AdObject.members | train | def members
unless @members
@members = []
[Adauth::AdObjects::Computer, Adauth::AdObjects::OU, Adauth::AdObjects::User, Adauth::AdObjects::Group].each do |object|
object.all.each do |entity|
@members.push entity if entity.is_a_member?(self)
end
end
end
@members
end | ruby | {
"resource": ""
} |
q1027 | WDM.SpecSupport.run_and_collect_multiple_changes | train | def run_and_collect_multiple_changes(monitor, times, directory, *flags, &block)
watch_and_run(monitor, times, false, directory, *flags, &block)
end | ruby | {
"resource": ""
} |
q1028 | WDM.SpecSupport.run | train | def run(monitor, directory, *flags, &block)
result = watch_and_run(monitor, 1, false, directory, *flags, &block)
result.changes[0].directory = result.directory
result.changes[0]
end | ruby | {
"resource": ""
} |
q1029 | WDM.SpecSupport.run_with_fixture | train | def run_with_fixture(monitor, *flags, &block)
fixture do |f|
run(monitor, f, *flags, &block)
end
end | ruby | {
"resource": ""
} |
q1030 | WDM.SpecSupport.run_recursively_and_collect_multiple_changes | train | def run_recursively_and_collect_multiple_changes(monitor, times, directory, *flags, &block)
watch_and_run(monitor, times, true, directory, *flags, &block)
end | ruby | {
"resource": ""
} |
q1031 | WDM.SpecSupport.run_recursively | train | def run_recursively(monitor, directory, *flags, &block)
result = watch_and_run(monitor, 1, true, directory, *flags, &block)
result.changes[0].directory = result.directory
result.changes[0]
end | ruby | {
"resource": ""
} |
q1032 | WDM.SpecSupport.run_recursively_with_fixture | train | def run_recursively_with_fixture(monitor, *flags, &block)
fixture do |f|
run_recursively(monitor, f, *flags, &block)
end
end | ruby | {
"resource": ""
} |
q1033 | WDM.SpecSupport.watch_and_run | train | def watch_and_run(monitor, times, recursively, directory, *flags)
result = OpenStruct.new(directory: directory, changes: [])
i = 0
result.changes[i] = OpenStruct.new(called: false)
can_return = false
callback = Proc.new do |change|
next if can_return
result.changes[i].called = true;
result.changes[i].change = change
i += 1
if i < times
result.changes[i] = OpenStruct.new(called: false)
else
can_return = true
end
end
if recursively
monitor.watch_recursively(directory, *flags, &callback)
else
monitor.watch(directory, *flags, &callback)
end
thread = Thread.new(monitor) { |m| m.run! }
sleep(0.2) # give time for the monitor to bootup
yield # So much boilerplate code to get here :S
sleep(0.2) # allow the monitor to run the callbacks
# Nothing can change after the callback if there is only one of them,
# so never wait for one callback
if times > 1
until can_return
sleep(0.1)
end
end
return result
ensure
monitor.stop
thread.join if thread
end | ruby | {
"resource": ""
} |
q1034 | WDM.SpecSupport.fixture | train | def fixture
pwd = FileUtils.pwd
path = File.expand_path(File.join(pwd, "spec/.fixtures/#{rand(99999)}"))
FileUtils.mkdir_p(path)
FileUtils.cd(path)
yield(path)
ensure
FileUtils.cd pwd
FileUtils.rm_rf(path) if File.exists?(path)
end | ruby | {
"resource": ""
} |
q1035 | PryTheme.RGB.to_term | train | def to_term(color_model = 256)
term = case color_model
when 256 then PryTheme::RGB::TABLE.index(@value)
when 16 then PryTheme::RGB::SYSTEM.index(@value)
when 8 then PryTheme::RGB::LINUX.index(@value)
else raise ArgumentError,
"invalid value for PryTheme::HEX#to_term(): #{ @value }"
end
term = find_among_term_colors(term, color_model) if term.nil?
PryTheme::TERM.new(term, color_model)
end | ruby | {
"resource": ""
} |
q1036 | PryTheme.RGB.validate_array | train | def validate_array(ary)
correct_size = ary.size.equal?(3)
correct_vals = ary.all?{ |val| val.is_a?(Integer) && val.between?(0, 255) }
return true if correct_size && correct_vals
raise ArgumentError,
%|invalid value for PryTheme::RGB#validate_array(): "#{ ary }"|
end | ruby | {
"resource": ""
} |
q1037 | PryTheme.RGB.nearest_term_256 | train | def nearest_term_256(byte)
for i in 0..4
lower, upper = BYTEPOINTS_256[i], BYTEPOINTS_256[i + 1]
next unless byte.between?(lower, upper)
distance_from_lower = (lower - byte).abs
distance_from_upper = (upper - byte).abs
closest = distance_from_lower < distance_from_upper ? lower : upper
end
closest
end | ruby | {
"resource": ""
} |
q1038 | PryTheme.RGB.find_among_term_colors | train | def find_among_term_colors(term, color_model)
rgb = @value.map { |byte| nearest_term_256(byte) }
term = PryTheme::RGB::TABLE.index(rgb)
approximate(term, color_model)
end | ruby | {
"resource": ""
} |
q1039 | PryTheme.RGB.approximate | train | def approximate(term, color_model)
needs_approximation = (term > color_model - 1)
if needs_approximation
case color_model
when 16 then nearest_term_16(term)
when 8 then nearest_term_8(term)
end
else
term
end
end | ruby | {
"resource": ""
} |
q1040 | Sinatra.SwaggerExposer.endpoint_parameter | train | def endpoint_parameter(name, description, how_to_pass, required, type, params = {})
parameters = settings.swagger_current_endpoint_parameters
check_if_not_duplicate(name, parameters, 'Parameter')
parameters[name] = Sinatra::SwaggerExposer::Configuration::SwaggerEndpointParameter.new(
name,
description,
how_to_pass,
required,
type,
params,
settings.swagger_types.types_names)
end | ruby | {
"resource": ""
} |
q1041 | Sinatra.SwaggerExposer.endpoint | train | def endpoint(params)
params.each_pair do |param_name, param_value|
case param_name
when :summary
endpoint_summary param_value
when :description
endpoint_description param_value
when :tags
endpoint_tags *param_value
when :produces
endpoint_produces *param_value
when :path
endpoint_path param_value
when :parameters
param_value.each do |param, args_param|
endpoint_parameter param, *args_param
end
when :responses
param_value.each do |code, args_response|
endpoint_response code, *args_response
end
else
raise SwaggerInvalidException.new("Invalid endpoint parameter [#{param_name}]")
end
end
end | ruby | {
"resource": ""
} |
q1042 | Sinatra.SwaggerExposer.response_header | train | def response_header(name, type, description)
settings.swagger_response_headers.add_response_header(name, type, description)
end | ruby | {
"resource": ""
} |
q1043 | Sinatra.SwaggerExposer.endpoint_response | train | def endpoint_response(code, type = nil, description = nil, headers = [])
responses = settings.swagger_current_endpoint_responses
check_if_not_duplicate(code, responses, 'Response')
responses[code] = Sinatra::SwaggerExposer::Configuration::SwaggerEndpointResponse.new(
type,
description,
settings.swagger_types.types_names,
headers,
settings.swagger_response_headers
)
end | ruby | {
"resource": ""
} |
q1044 | Sinatra.SwaggerExposer.route | train | def route(verb, path, options = {}, &block)
no_swagger = options[:no_swagger]
options.delete(:no_swagger)
if (verb == 'HEAD') || no_swagger
super(verb, path, options, &block)
else
request_processor = create_request_processor(verb.downcase, path, options)
super(verb, path, options) do |*params|
response = catch(:halt) do
request_processor.run(self, params, &block)
end
if settings.result_validation
begin
# Inspired from Sinatra#invoke
if (Fixnum === response) or (String === response)
response = [response]
end
if (Array === response) and (Fixnum === response.first)
response_for_validation = response.dup
response_status = response_for_validation.shift
response_body = response_for_validation.pop
response_headers = (response_for_validation.pop || {}).merge(self.response.header)
response_content_type = response_headers['Content-Type']
request_processor.validate_response(response_body, response_content_type, response_status)
elsif response.respond_to? :each
request_processor.validate_response(response.first.dup, self.response.header['Content-Type'], 200)
end
rescue Sinatra::SwaggerExposer::SwaggerInvalidException => e
content_type :json
throw :halt, [400, {:code => 400, :message => e.message}.to_json]
end
end
throw :halt, response
end
end
end | ruby | {
"resource": ""
} |
q1045 | Sinatra.SwaggerExposer.create_request_processor | train | def create_request_processor(type, path, opts)
current_endpoint_info = settings.swagger_current_endpoint_info
current_endpoint_parameters = settings.swagger_current_endpoint_parameters
current_endpoint_responses = settings.swagger_current_endpoint_responses
endpoint = Sinatra::SwaggerExposer::Configuration::SwaggerEndpoint.new(
type,
path,
current_endpoint_parameters.values,
current_endpoint_responses.clone,
current_endpoint_info[:summary],
current_endpoint_info[:description],
current_endpoint_info[:tags],
current_endpoint_info[:path],
current_endpoint_info[:produces])
settings.swagger_endpoints << endpoint
current_endpoint_info.clear
current_endpoint_parameters.clear
current_endpoint_responses.clear
settings.swagger_processor_creator.create_request_processor(endpoint)
end | ruby | {
"resource": ""
} |
q1046 | Sinatra.SwaggerExposer.check_if_not_duplicate | train | def check_if_not_duplicate(key, values, name)
if values.key? key
raise SwaggerInvalidException.new("#{name} already exist for #{key} with value [#{values[key]}]")
end
end | ruby | {
"resource": ""
} |
q1047 | PryTheme.HEX.validate_value | train | def validate_value(value)
unless value.is_a?(String)
raise TypeError, "can't convert #{ value.class } into PryTheme::HEX"
end
if value !~ PryTheme::HEX::PATTERN
fail ArgumentError, %|invalid value for PryTheme::HEX#new(): "#{value}"|
end
true
end | ruby | {
"resource": ""
} |
q1048 | PryTheme.WhenStartedHook.recreate_user_themes_from_default_ones | train | def recreate_user_themes_from_default_ones
FileUtils.mkdir_p(USER_THEMES_DIR) unless File.exist?(USER_THEMES_DIR)
default_themes = Dir.entries(DEF_THEMES_DIR) - %w(. ..)
default_themes.each do |theme|
user_theme_path = File.join(USER_THEMES_DIR, theme)
next if File.exist?(user_theme_path)
def_theme_path = File.join(DEF_THEMES_DIR, theme)
FileUtils.cp(def_theme_path, USER_THEMES_DIR)
end
end | ruby | {
"resource": ""
} |
q1049 | Bond.Rc.files | train | def files(input)
(::Readline::FILENAME_COMPLETION_PROC.call(input) || []).map {|f|
f =~ /^~/ ? File.expand_path(f) : f
}
end | ruby | {
"resource": ""
} |
q1050 | Bond.Rc.objects_of | train | def objects_of(klass)
object = []
ObjectSpace.each_object(klass) {|e| object.push(e) }
object
end | ruby | {
"resource": ""
} |
q1051 | Bond.Mission.call_search | train | def call_search(search, input, list)
Rc.send("#{search}_search", input || '', list)
rescue
message = $!.is_a?(NoMethodError) && !Rc.respond_to?("#{search}_search") ?
"Completion search '#{search}' doesn't exist." :
"Failed during completion search with '#{$!.message}'."
raise FailedMissionError.new(self), message
end | ruby | {
"resource": ""
} |
q1052 | Bond.Mission.call_action | train | def call_action(input)
@action.respond_to?(:call) ? @action.call(input) : Rc.send(@action, input)
rescue StandardError, SyntaxError
message = $!.is_a?(NoMethodError) && !@action.respond_to?(:call) &&
!Rc.respond_to?(@action) ? "Completion action '#{@action}' doesn't exist." :
"Failed during completion action '#{name}' with '#{$!.message}'."
raise FailedMissionError.new(self), message
end | ruby | {
"resource": ""
} |
q1053 | MagicCloud.Spriter.ensure_position | train | def ensure_position(rect)
# no place in current row -> go to next row
if cur_x + rect.width > canvas.width
@cur_x = 0
@cur_y += row_height
@row_height = 0
end
# no place in current canvas -> restart canvas
restart_canvas! if cur_y + rect.height > canvas.height
end | ruby | {
"resource": ""
} |
q1054 | NBayes.Data.remove_token_from_category | train | def remove_token_from_category(category, token)
cat_data(category)[:tokens][token] -= 1
delete_token_from_category(category, token) if cat_data(category)[:tokens][token] < 1
cat_data(category)[:total_tokens] -= 1
delete_category(category) if cat_data(category)[:total_tokens] < 1
end | ruby | {
"resource": ""
} |
q1055 | NBayes.Base.load | train | def load(yml)
if yml.nil?
nbayes = NBayes::Base.new
elsif yml[0..2] == "---"
nbayes = self.class.from_yml(yml)
else
nbayes = self.class.from(yml)
end
nbayes
end | ruby | {
"resource": ""
} |
q1056 | Bond.Agent.complete | train | def complete(options={}, &block)
if (mission = create_mission(options, &block)).is_a?(Mission)
mission.place.is_a?(Integer) ? @missions.insert(mission.place - 1, mission).compact! : @missions << mission
sort_last_missions
end
mission
end | ruby | {
"resource": ""
} |
q1057 | Bond.Agent.recomplete | train | def recomplete(options={}, &block)
if (mission = create_mission(options, &block)).is_a?(Mission)
if (existing_mission = @missions.find {|e| e.name == mission.name })
@missions[@missions.index(existing_mission)] = mission
sort_last_missions
else
return "No existing mission found to recomplete."
end
end
mission
end | ruby | {
"resource": ""
} |
q1058 | Bond.Agent.spy | train | def spy(input)
if (mission = find_mission(input))
puts mission.match_message, "Possible completions: #{mission.execute.inspect}",
"Matches for #{mission.condition.inspect} are #{mission.matched.to_a.inspect}"
else
puts "Doesn't match a completion."
end
rescue FailedMissionError => e
puts e.mission.match_message, e.message,
"Matches for #{e.mission.condition.inspect} are #{e.mission.matched.to_a.inspect}"
end | ruby | {
"resource": ""
} |
q1059 | Bond.M.debrief | train | def debrief(options={})
config.merge! options
config[:readline] ||= default_readline
if !config[:readline].is_a?(Module) &&
Bond.const_defined?(config[:readline].to_s.capitalize)
config[:readline] = Bond.const_get(config[:readline].to_s.capitalize)
end
unless %w{setup line_buffer}.all? {|e| config[:readline].respond_to?(e) }
$stderr.puts "Bond Error: Invalid readline plugin '#{config[:readline]}'."
end
end | ruby | {
"resource": ""
} |
q1060 | Bond.M.find_gem_file | train | def find_gem_file(rubygem, file)
begin gem(rubygem); rescue Exception; end
(dir = $:.find {|e| File.exist?(File.join(e, file)) }) && File.join(dir, file)
end | ruby | {
"resource": ""
} |
q1061 | Bond.M.load_file | train | def load_file(file)
Rc.module_eval File.read(file)
rescue Exception => e
$stderr.puts "Bond Error: Completion file '#{file}' failed to load with:", e.message
end | ruby | {
"resource": ""
} |
q1062 | Bond.M.load_dir | train | def load_dir(base_dir)
if File.exist?(dir = File.join(base_dir, 'completions'))
Dir[dir + '/*.rb'].each {|file| load_file(file) }
true
end
end | ruby | {
"resource": ""
} |
q1063 | Bond.M.home | train | def home
['HOME', 'USERPROFILE'].each {|e| return ENV[e] if ENV[e] }
return "#{ENV['HOMEDRIVE']}#{ENV['HOMEPATH']}" if ENV['HOMEDRIVE'] && ENV['HOMEPATH']
File.expand_path("~")
rescue
File::ALT_SEPARATOR ? "C:/" : "/"
end | ruby | {
"resource": ""
} |
q1064 | NessusREST.Client.user_add | train | def user_add(username, password, permissions, type)
payload = {
:username => username,
:password => password,
:permissions => permissions,
:type => type,
:json => 1
}
http_post(:uri=>"/users", :fields=>x_cookie, :data=>payload)
end | ruby | {
"resource": ""
} |
q1065 | NessusREST.Client.user_chpasswd | train | def user_chpasswd(user_id, password)
payload = {
:password => password,
:json => 1
}
res = http_put(:uri=>"/users/#{user_id}/chpasswd", :data=>payload, :fields=>x_cookie)
return res.code
end | ruby | {
"resource": ""
} |
q1066 | NessusREST.Client.http_delete | train | def http_delete(opts={})
ret=http_delete_low(opts)
if ret.is_a?(Hash) and ret.has_key?('error') and ret['error']=='Invalid Credentials' then
authdefault
ret=http_delete_low(opts)
return ret
else
return ret
end
end | ruby | {
"resource": ""
} |
q1067 | NessusREST.Client.http_get | train | def http_get(opts={})
raw_content = opts[:raw_content] || false
ret=http_get_low(opts)
if !raw_content then
if ret.is_a?(Hash) and ret.has_key?('error') and ret['error']=='Invalid Credentials' then
authdefault
ret=http_get_low(opts)
return ret
else
return ret
end
else
return ret
end
end | ruby | {
"resource": ""
} |
q1068 | NessusREST.Client.http_post | train | def http_post(opts={})
if opts.has_key?(:authenticationmethod) then
# i know authzmethod = opts.delete(:authorizationmethod) is short, but not readable
authzmethod = opts[:authenticationmethod]
opts.delete(:authenticationmethod)
end
ret=http_post_low(opts)
if ret.is_a?(Hash) and ret.has_key?('error') and ret['error']=='Invalid Credentials' then
if not authzmethod
authdefault
ret=http_post_low(opts)
return ret
end
else
return ret
end
end | ruby | {
"resource": ""
} |
q1069 | NessusREST.Client.parse_json | train | def parse_json(body)
buf = {}
begin
buf = JSON.parse(body)
rescue JSON::ParserError
end
buf
end | ruby | {
"resource": ""
} |
q1070 | OAuth2Client.UrlHelper.build_url | train | def build_url(uri, opts={})
path = opts[:path] || ''
query = opts[:params] || {}
fragment = opts[:fragment] || {}
url = Addressable::URI.parse uri
url.path = path
url.query_values = query unless query.empty?
url.fragment = Addressable::URI.form_encode(fragment) unless fragment.empty?
url.to_s
end | ruby | {
"resource": ""
} |
q1071 | OAuth2Client.UrlHelper.generate_urlsafe_key | train | def generate_urlsafe_key(size=48)
seed = Time.now.to_i
size = size - seed.to_s.length
Base64.encode64("#{ OpenSSL::Random.random_bytes(size) }#{ seed }").gsub(/\W/, '')
end | ruby | {
"resource": ""
} |
q1072 | OAuth2Client.UrlHelper.to_query | train | def to_query(params)
unless params.is_a?(Hash)
raise "Expected Hash but got #{params.class.name}"
end
Addressable::URI.form_encode(params)
end | ruby | {
"resource": ""
} |
q1073 | OData.Entity.[] | train | def [](property_name)
if get_property(property_name).is_a?(::OData::ComplexType)
get_property(property_name)
else
get_property(property_name).value
end
rescue NoMethodError
raise ArgumentError, "Unknown property: #{property_name}"
end | ruby | {
"resource": ""
} |
q1074 | OData.Entity.[]= | train | def []=(property_name, value)
properties[property_name.to_s].value = value
rescue NoMethodError
raise ArgumentError, "Unknown property: #{property_name}"
end | ruby | {
"resource": ""
} |
q1075 | OData.Entity.to_xml | train | def to_xml
builder = Nokogiri::XML::Builder.new do |xml|
xml.entry('xmlns' => 'http://www.w3.org/2005/Atom',
'xmlns:data' => 'http://schemas.microsoft.com/ado/2007/08/dataservices',
'xmlns:metadata' => 'http://schemas.microsoft.com/ado/2007/08/dataservices/metadata',
'xmlns:georss' => 'http://www.georss.org/georss',
'xmlns:gml' => 'http://www.opengis.net/gml',
'xml:base' => 'http://services.odata.org/OData/OData.svc/') do
xml.category(term: "#{namespace}.#{type}",
scheme: 'http://schemas.microsoft.com/ado/2007/08/dataservices/scheme')
xml.author { xml.name }
xml.content(type: 'application/xml') do
xml['metadata'].properties do
properties.keys.each do |name|
next if name == primary_key
get_property(name).to_xml(xml)
end
end
end
end
end
builder.to_xml
end | ruby | {
"resource": ""
} |
q1076 | OData.ServiceRegistry.add | train | def add(service)
initialize_instance_variables
@services << service if service.is_a?(OData::Service) && !@services.include?(service)
@services_by_name[service.name] = @services.find_index(service)
@services_by_url[service.service_url] = @services.find_index(service)
end | ruby | {
"resource": ""
} |
q1077 | OData.Service.entity_sets | train | def entity_sets
@entity_sets ||= Hash[metadata.xpath('//EntityContainer/EntitySet').collect {|entity|
[
entity.attributes['EntityType'].value.gsub("#{namespace}.", ''),
entity.attributes['Name'].value
]
}]
end | ruby | {
"resource": ""
} |
q1078 | OData.Service.associations | train | def associations
@associations ||= Hash[metadata.xpath('//Association').collect do |association_definition|
[
association_definition.attributes['Name'].value,
build_association(association_definition)
]
end]
end | ruby | {
"resource": ""
} |
q1079 | OData.Service.execute | train | def execute(url_chunk, additional_options = {})
request = ::Typhoeus::Request.new(
URI.escape("#{service_url}/#{url_chunk}"),
options[:typhoeus].merge({ method: :get
})
.merge(additional_options)
)
request.run
response = request.response
validate_response(response)
response
end | ruby | {
"resource": ""
} |
q1080 | OData.Service.find_node | train | def find_node(results, node_name)
document = ::Nokogiri::XML(results.body)
document.remove_namespaces!
document.xpath("//#{node_name}").first
end | ruby | {
"resource": ""
} |
q1081 | OData.Service.find_entities | train | def find_entities(results)
document = ::Nokogiri::XML(results.body)
document.remove_namespaces!
document.xpath('//entry')
end | ruby | {
"resource": ""
} |
q1082 | OData.Service.get_title_property_name | train | def get_title_property_name(entity_name)
node = metadata.xpath("//EntityType[@Name='#{entity_name}']/Property[@FC_TargetPath='SyndicationTitle']").first
node.nil? ? nil : node.attributes['Name'].value
end | ruby | {
"resource": ""
} |
q1083 | OData.Service.properties_for_entity | train | def properties_for_entity(entity_name)
type_definition = metadata.xpath("//EntityType[@Name='#{entity_name}']").first
raise ArgumentError, "Unknown EntityType: #{entity_name}" if type_definition.nil?
properties_to_return = {}
type_definition.xpath('./Property').each do |property_xml|
property_name, property = process_property_from_xml(property_xml)
properties_to_return[property_name] = property
end
properties_to_return
end | ruby | {
"resource": ""
} |
q1084 | OData.Service.properties_for_complex_type | train | def properties_for_complex_type(type_name)
type_definition = metadata.xpath("//ComplexType[@Name='#{type_name}']").first
raise ArgumentError, "Unknown ComplexType: #{type_name}" if type_definition.nil?
properties_to_return = {}
type_definition.xpath('./Property').each do |property_xml|
property_name, property = process_property_from_xml(property_xml)
properties_to_return[property_name] = property
end
properties_to_return
end | ruby | {
"resource": ""
} |
q1085 | OData.EntitySet.each | train | def each(&block)
per_page = @each_batch_size
page = 0
loop do
entities = get_paginated_entities(per_page, page)
break if entities.empty?
entities.each do |entity|
block_given? ? block.call(entity) : yield(entity)
end
page += 1
end
end | ruby | {
"resource": ""
} |
q1086 | OData.EntitySet.first | train | def first(count = 1)
query = OData::Query.new(self).limit(count)
result = service.execute(query)
entities = service.find_entities(result)
res = count == 1 ? single_entity_from_xml(entities) : multiple_entities_from_xml(entities)
res
end | ruby | {
"resource": ""
} |
q1087 | OData.EntitySet.[] | train | def [](key)
entity = new_entity
key_property = entity.get_property(entity.primary_key)
key_property.value = key
result = service.execute("#{name}(#{key_property.url_value})")
entities = service.find_entities(result)
single_entity_from_xml(entities)
end | ruby | {
"resource": ""
} |
q1088 | NumbersInWords.NumberGroup.groups | train | def groups size
#1234567 => %w(765 432 1)
@array = in_groups_of(@number.to_s.reverse.split(""), size)
#%w(765 432 1) => %w(1 432 765)
@array.reverse!
#%w(1 432 765) => [1, 234, 567]
@array.map! {|group| group.reverse.join("").to_i}
@array.reverse! # put in ascending order of power of ten
power = 0
#[1, 234, 567] => {6 => 1, 3 => 234, 0 => 567}
@array.inject({}) do |o, digits|
o[power] = digits
power += size
o
end
end | ruby | {
"resource": ""
} |
q1089 | OData.Query.[] | train | def [](property)
property_instance = @entity_set.new_entity.get_property(property)
property_instance = property if property_instance.nil?
OData::Query::Criteria.new(property: property_instance)
end | ruby | {
"resource": ""
} |
q1090 | OData.Query.execute | train | def execute
response = entity_set.service.execute(self.to_s)
OData::Query::Result.new(self, response)
end | ruby | {
"resource": ""
} |
q1091 | Retrospec::Puppet::Generators.ProviderGenerator.template_dir | train | def template_dir
external_templates = File.expand_path(File.join(config_data[:template_dir], 'providers', 'provider_template.rb.retrospec.erb'))
if File.exist?(external_templates)
File.join(config_data[:template_dir], 'providers')
else
File.expand_path(File.join(File.dirname(File.dirname(__FILE__)), 'templates', 'providers'))
end
end | ruby | {
"resource": ""
} |
q1092 | Retrospec::Puppet::Generators.ProviderGenerator.type_file | train | def type_file(p_type = provider_type)
if TypeGenerator::CORE_TYPES.include?(p_type)
type_file = "puppet/type/#{p_type}.rb"
else
type_file = File.join(type_dir, "#{p_type}.rb")
end
type_file
end | ruby | {
"resource": ""
} |
q1093 | Utilities.PuppetModule.create_tmp_module_path | train | def create_tmp_module_path(module_path)
fail 'ModulePathNotFound' unless module_path
path = File.join(tmp_modules_dir, module_dir_name)
unless File.exist?(path) # only create if it doesn't already exist
# create a link where source is the current repo and dest is /tmp/modules/module_name
FileUtils.ln_s(module_path, path)
end
path
end | ruby | {
"resource": ""
} |
q1094 | Utilities.PuppetModule.tmp_modules_dir | train | def tmp_modules_dir
if @tmp_modules_dir.nil? || !File.exist?(@tmp_modules_dir)
tmp_path = File.expand_path(File.join(temporary_environment_path, 'modules'))
FileUtils.mkdir_p(tmp_path)
@tmp_modules_dir = tmp_path
end
@tmp_modules_dir
end | ruby | {
"resource": ""
} |
q1095 | Utilities.PuppetModule.request | train | def request(key, method)
instance = ::Puppet::Indirector::Indirection.instance(:resource_type)
indirection_name = 'test'
@request = ::Puppet::Indirector::Request.new(indirection_name, method, key, instance)
@request.environment = puppet_environment
@request
end | ruby | {
"resource": ""
} |
q1096 | Stemcell.Launcher.render_template | train | def render_template(opts={})
template_file_path = File.expand_path(TEMPLATE_PATH, __FILE__)
template_file = File.read(template_file_path)
erb_template = ERB.new(template_file)
last_bootstrap_line = LAST_BOOTSTRAP_LINE
generated_template = erb_template.result(binding)
@log.debug "genereated template is #{generated_template}"
return generated_template
end | ruby | {
"resource": ""
} |
q1097 | Stemcell.Launcher.get_vpc_security_group_ids | train | def get_vpc_security_group_ids(vpc_id, group_names)
group_map = {}
@log.info "resolving security groups #{group_names} in #{vpc_id}"
vpc = AWS::EC2::VPC.new(vpc_id, :ec2_endpoint => "ec2.#{@region}.amazonaws.com")
vpc.security_groups.each do |sg|
next if sg.vpc_id != vpc_id
group_map[sg.name] = sg.group_id
end
group_ids = []
group_names.each do |sg_name|
raise "Couldn't find security group #{sg_name} in #{vpc_id}" unless group_map.has_key?(sg_name)
group_ids << group_map[sg_name]
end
group_ids
end | ruby | {
"resource": ""
} |
q1098 | Rubyipmi.BaseCommand.runcmd | train | def runcmd
@success = false
@success = run
logger.debug(@lastcall.inspect) unless @lastcall.nil? if logger
logger.debug(@result) unless @result.nil? if logger
@success
end | ruby | {
"resource": ""
} |
q1099 | Rubyipmi.BaseCommand.find_fix | train | def find_fix(result)
return unless result
# The errorcode code hash contains the fix
begin
fix = ErrorCodes.search(result)
@options.merge_notify!(fix)
rescue
Rubyipmi.logger.debug("Could not find fix for error code: \n#{result}") if logger
raise "Could not find fix for error code: \n#{result}"
end
end | ruby | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.