_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3 values | text stringlengths 66 10.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q4800 | GeoWorks.ImageFileBehavior.image_work | train | def image_work
parents.select do |parent|
parent.class.included_modules.include?(::GeoWorks::ImageWorkBehavior)
end.to_a
end | ruby | {
"resource": ""
} |
q4801 | RailsPaginate::Pagers.Slider.visible_pages | train | def visible_pages
visible = []
last_inserted = 0
splited = false
(1..pages).each do |page|
# insert
if visible? page
visible << page
last_inserted = page
splited = false
else
# need splitter
if not splited and outer > 0 and last_inserted < page
visible << nil
splited = true
end
end
end
visible
end | ruby | {
"resource": ""
} |
q4802 | RailsPaginate::Pagers.Slider.visible? | train | def visible?(page)
# outer
if outer > 0
return true if outer >= page
return true if (pages - outer) < page
end
# current page
return true if current_page == page
# inner
return true if inner_range.include? page
false
end | ruby | {
"resource": ""
} |
q4803 | Mongoid::Globalize.ClassMethods.required_attributes | train | def required_attributes
validators.map{ |v| v.attributes if v.is_a?(Mongoid::Validations::PresenceValidator) }.flatten.compact
end | ruby | {
"resource": ""
} |
q4804 | Mongoid::Globalize.Methods.translated_attributes | train | def translated_attributes
@translated_attributes ||= translated_attribute_names.inject({}) do |attrs, name|
attrs.merge(name.to_s => translation.send(name))
end
end | ruby | {
"resource": ""
} |
q4805 | Mongoid::Globalize.Methods.translation_for | train | def translation_for(locale)
@translation_caches ||= {}
# Need to temporary switch of merging, because #translations uses
# #attributes method too, to avoid stack level too deep error.
@stop_merging_translated_attributes = true
unless @translation_caches[locale]
_translation = translations.find_by_locale(locale)
_translation ||= translations.build(:locale => locale)
@translation_caches[locale] = _translation
end
@stop_merging_translated_attributes = false
@translation_caches[locale]
end | ruby | {
"resource": ""
} |
q4806 | Mongoid::Globalize.Methods.used_locales | train | def used_locales
locales = globalize.stash.keys.concat(globalize.stash.keys).concat(translations.translated_locales)
locales.uniq!
locales
end | ruby | {
"resource": ""
} |
q4807 | Mongoid::Globalize.Methods.prepare_translations! | train | def prepare_translations!
@stop_merging_translated_attributes = true
translated_attribute_names.each do |name|
@attributes.delete name.to_s
@changed_attributes.delete name.to_s if @changed_attributes
end
globalize.prepare_translations!
end | ruby | {
"resource": ""
} |
q4808 | IcalImporter.SingleEventBuilder.build | train | def build
# handle recuring events
@local_event.tap do |le|
if @event.rrule.present?
@rrule = @event.rrule.first # only support recurrence on one schedule
# set out new event's basic rucurring properties
le.attributes = recurrence_attributes
set_date_exclusion
frequency_set
else # make sure we remove this if it changed
le.attributes = non_recurrence_attributes
end
end
end | ruby | {
"resource": ""
} |
q4809 | Jsonism.Definer.define_methods_into | train | def define_methods_into(client)
links.each do |link|
@client.define_singleton_method(link.method_signature) do |params = {}, headers = {}|
Request.call(client: client, headers: headers, link: link, params: params)
end
end
end | ruby | {
"resource": ""
} |
q4810 | GeoWorks.BoundingBoxHelper.bbox | train | def bbox(property)
markup = ''
markup << %(<div id='bbox'></div>)
markup << bbox_display_inputs
markup << bbox_script_tag(property)
markup.html_safe
end | ruby | {
"resource": ""
} |
q4811 | Grantinee.CLI.process_database_param | train | def process_database_param
unless @options[:config] || Grantinee.configuration.configured?
Grantinee::Engine.detect_active_record_connection!
unless Grantinee.configuration.configured?
raise "No configuration file found. Please use the -c option"\
" to pass a configuration file."
end
end
require options[:config]
rescue StandardError, LoadError => error
puts error
exit
end | ruby | {
"resource": ""
} |
q4812 | Grantinee.CLI.process_verbosity_param | train | def process_verbosity_param
return unless @options[:verbose]
log_levels = %w[debug info warn error fatal unknown]
@logger.level = log_levels.index(@options[:verbose])
end | ruby | {
"resource": ""
} |
q4813 | Danger.DangerShellcheck.report | train | def report(file_path)
raise 'ShellCheck summary file not found' unless File.file?(file_path)
shellcheck_summary = JSON.parse(File.read(file_path), symbolize_names: true)
run_summary(shellcheck_summary)
end | ruby | {
"resource": ""
} |
q4814 | Danger.DangerShellcheck.parse_files | train | def parse_files(shellcheck_summary)
shellcheck_summary.each do |element|
file = element[:file]
@files.add(file)
level = element[:level]
message = format_violation(file, element)
if level == 'error'
@error_count += 1
fail(message, sticky: false)
else
if level == 'warning'
@warning_count += 1
elsif level == 'info'
@info_count += 1
else
@style_count += 1
end
warn(message, sticky: false)
end
end
end | ruby | {
"resource": ""
} |
q4815 | Features.SessionHelpers.sign_up_with | train | def sign_up_with(email, password)
Capybara.exact = true
visit new_user_registration_path
fill_in 'Email', with: email
fill_in 'Password', with: password
fill_in 'Password confirmation', with: password
click_button 'Sign up'
end | ruby | {
"resource": ""
} |
q4816 | Features.SessionHelpers.sign_in | train | def sign_in(who = :user)
user = if who.instance_of?(User)
who
else
FactoryGirl.build(:user).tap(&:save!)
end
visit new_user_session_path
fill_in 'Email', with: user.email
fill_in 'Password', with: user.password
click_button 'Log in'
expect(page).not_to have_text 'Invalid email or password.'
end | ruby | {
"resource": ""
} |
q4817 | CouchRest.Database.clear_extended_doc_fresh_cache | train | def clear_extended_doc_fresh_cache
::CouchRest::ExtendedDocument.subclasses.each{|klass| klass.req_design_doc_refresh if klass.respond_to?(:req_design_doc_refresh)}
end | ruby | {
"resource": ""
} |
q4818 | ODT2HTML.AnalyzeContent.register_style | train | def register_style( element )
# get namespace prefix for this element
style_name = element.attribute("#{element.prefix}:style-name");
if (style_name != nil) then
style_name = style_name.value.tr_s('.','_')
if (@style_info[style_name] != nil) then
@style_info[style_name].block_used = true
end
end
return style_name
end | ruby | {
"resource": ""
} |
q4819 | Luis.Result.entities_of_type | train | def entities_of_type(type)
@entities.select { |entity| entity['type'] == type }.map { |entity| Entity.new entity }
end | ruby | {
"resource": ""
} |
q4820 | AdbSdkLib.Common.convert_map_to_hash | train | def convert_map_to_hash(object, &block)
hash = Hash.new
i = object.entrySet.iterator
if block_given?
while i.hasNext
entry = i.next
yield hash, entry.getKey, entry.getValue
end
else
while i.hasNext
entry = i.next
hash[entry.getKey] = entry.getValue
end
end
hash
end | ruby | {
"resource": ""
} |
q4821 | CodeModels.Parser.parse_file | train | def parse_file(path,file_encoding=nil)
file_encoding = @internal_encoding unless file_encoding
code = IO.read(path,{ :encoding => file_encoding, :mode => 'rb'})
code = code.encode(@internal_encoding)
artifact = FileArtifact.new(path,code)
parse_artifact(artifact)
end | ruby | {
"resource": ""
} |
q4822 | CodeModels.Parser.parse_string | train | def parse_string(code)
code = code.encode(@internal_encoding)
artifact = StringArtifact.new(code)
parse_artifact(artifact)
end | ruby | {
"resource": ""
} |
q4823 | AdbSdkLib.Adb.devices | train | def devices
devices = @adb.devices.map { |d|
serial = d.serial_number
(@devices.has_key?(serial) && same_jobject?(@devices[serial].jobject, d)) \
? @devices[serial] : Device.new(d)
}
@devices = DeviceList.new(devices)
return @devices
end | ruby | {
"resource": ""
} |
q4824 | VaultedBilling.CreditCard.attributes | train | def attributes
{
:vault_id => vault_id,
:currency => currency,
:card_number => card_number,
:cvv_number => cvv_number,
:expires_on => expires_on,
:first_name => first_name,
:last_name => last_name,
:street_address => street_address,
:locality => locality,
:region => region,
:postal_code => postal_code,
:country => country,
:phone => phone
}
end | ruby | {
"resource": ""
} |
q4825 | RailsPaginate::Helpers.Array.paginate | train | def paginate(*args)
options = args.extract_options!
per_page = options.delete(:per_page)
page = options.delete(:page) || 1
::RailsPaginate::Collection.new(self, args.first || page, per_page)
end | ruby | {
"resource": ""
} |
q4826 | GoogleCheckout.Command.post | train | def post
# Create HTTP(S) POST command and set up Basic Authentication.
uri = URI.parse(url)
request = Net::HTTP::Post.new(uri.path)
request.basic_auth(@merchant_id, @merchant_key)
# Set up the HTTP connection object and the SSL layer.
https = Net::HTTP.new(uri.host, uri.port)
https.use_ssl = true
https.cert_store = self.class.x509_store
https.verify_mode = OpenSSL::SSL::VERIFY_PEER
https.verify_depth = 5
# Send the request to Google.
response = https.request(request, self.to_xml)
# NOTE Because Notification.parse() is used, the content of objects
# will be correctly parsed no matter what the HTTP response code
# is from the server.
case response
when Net::HTTPSuccess, Net::HTTPClientError
notification = Notification.parse(response.body)
if notification.error?
raise APIError, "#{notification.message} [in #{GoogleCheckout.production? ? 'production' : 'sandbox' }]"
end
return notification
when Net::HTTPRedirection, Net::HTTPServerError, Net::HTTPInformation
raise "Unexpected response code (#{response.class}): #{response.code} - #{response.message}"
else
raise "Unknown response code: #{response.code} - #{response.message}"
end
end | ruby | {
"resource": ""
} |
q4827 | GoogleCheckout.SendBuyerMessage.to_xml | train | def to_xml # :nodoc:
xml = Builder::XmlMarkup.new
xml.instruct!
@xml = xml.tag!('send-buyer-message', {
:xmlns => "http://checkout.google.com/schema/2",
"google-order-number" => @google_order_number
}) do
xml.tag!("message", @message)
xml.tag!("send-email", true)
end
@xml
end | ruby | {
"resource": ""
} |
q4828 | Rtasklib.Taskrc.hash_to_model | train | def hash_to_model taskrc_hash
taskrc_hash.each do |attr, value|
add_model_attr(attr, value)
set_model_attr_value(attr, value)
end
config
end | ruby | {
"resource": ""
} |
q4829 | Rtasklib.Taskrc.mappable_to_model | train | def mappable_to_model rc_file
rc_file.map! { |l| line_to_tuple(l) }.compact!
taskrc = Hash[rc_file]
hash_to_model(taskrc)
end | ruby | {
"resource": ""
} |
q4830 | Rtasklib.Taskrc.part_of_model_to_rc | train | def part_of_model_to_rc *attrs
attrs.map do |attr|
value = get_model_attr_value attr
hash_attr = get_rc_attr_from_hash attr.to_s
attr = "rc.#{hash_attr}=#{value}"
end
end | ruby | {
"resource": ""
} |
q4831 | Rtasklib.Taskrc.path_exist? | train | def path_exist? path
if path.is_a? Pathname
return path.exist?
elsif path.is_a? String
return Pathname.new(path).exist?
else
return false
end
end | ruby | {
"resource": ""
} |
q4832 | Jim.Index.find_all | train | def find_all(name, version = nil)
matched = []
find(name, version) {|p| matched << p }
matched
end | ruby | {
"resource": ""
} |
q4833 | HoneyFormat.Header.to_csv | train | def to_csv(columns: nil)
attributes = if columns
self.columns & columns.map(&:to_sym)
else
self.columns
end
::CSV.generate_line(attributes)
end | ruby | {
"resource": ""
} |
q4834 | HoneyFormat.Header.build_columns | train | def build_columns(header)
columns = header.each_with_index.map do |header_column, index|
convert_column(header_column, index).tap do |column|
maybe_raise_missing_column!(column)
end
end
@deduplicator.call(columns)
end | ruby | {
"resource": ""
} |
q4835 | HoneyFormat.Header.convert_column | train | def convert_column(column, index)
value = if converter_arity == 1
@converter.call(column)
else
@converter.call(column, index)
end
value.to_sym
end | ruby | {
"resource": ""
} |
q4836 | Mascot.DAT.goto | train | def goto(key)
if @idx.has_key?(key.to_sym)
@dat_file.pos = @idx[key.to_sym]
else
raise Exception.new "Invalid DAT section \"#{key}\""
end
end | ruby | {
"resource": ""
} |
q4837 | Mascot.DAT.read_section | train | def read_section(key)
self.goto(key.to_sym)
# read past the initial boundary marker
tmp = @dat_file.readline
@dat_file.each do |l|
break if l =~ @boundary
tmp << l
end
tmp
end | ruby | {
"resource": ""
} |
q4838 | Usmu.Configuration.excluded? | train | def excluded?(filename)
exclude.each do |f|
f += '**/*' if f.end_with? '/'
return true if File.fnmatch(f, filename, File::FNM_EXTGLOB | File::FNM_PATHNAME)
end
false
end | ruby | {
"resource": ""
} |
q4839 | Pagination.Template.render | train | def render
if engine.respond_to?(:render)
engine.render(Object.new, :items => items)
else
engine.result(binding)
end
end | ruby | {
"resource": ""
} |
q4840 | Snow.ArraySupport.map! | train | def map!(&block)
return to_enum(:map!) unless block_given?
(0 ... self.length).each {
|index|
store(index, yield(fetch(index)))
}
self
end | ruby | {
"resource": ""
} |
q4841 | PaynetEasy::PaynetEasyApi::Query.QueryFactory.query | train | def query(api_query_name)
query_class = "#{api_query_name.camelize}Query"
query_file = "query/#{api_query_name.gsub('-', '_')}_query"
require query_file
PaynetEasy::PaynetEasyApi::Query.const_get(query_class).new(api_query_name)
end | ruby | {
"resource": ""
} |
q4842 | JumpStart.Base.start | train | def start
puts "\n******************************************************************************************************************************************\n\n"
puts " JumpStarting....\n".purple
check_setup
execute_install_command
run_scripts_from_yaml(:run_after_install_command)
parse_template_dir
create_dirs
populate_files_from_whole_templates
populate_files_from_append_templates
populate_files_from_line_templates
remove_unwanted_files
run_scripts_from_yaml(:run_after_jumpstart)
check_for_strings_to_replace
run_scripts_from_yaml(:run_after_string_replace)
check_local_nginx_configuration
exit_with_success
end | ruby | {
"resource": ""
} |
q4843 | JumpStart.Base.check_install_path | train | def check_install_path
@install_path = JumpStart::LAUNCH_PATH if @install_path.nil? || @install_path.empty?
if File.directory?(FileUtils.join_paths(@install_path, @project_name))
puts "\nThe directory #{FileUtils.join_paths(@install_path, @project_name).red} already exists.\nAs this is the location you have specified for creating your new project jumpstart will now exit to avoid overwriting anything."
exit_normal
end
return true
end | ruby | {
"resource": ""
} |
q4844 | JumpStart.Base.create_template | train | def create_template
if File.directory?(FileUtils.join_paths(JumpStart.templates_path, @template_name))
puts "\nThe directory #{FileUtils.join_paths(JumpStart.templates_path, @template_name).red} already exists. The template will not be created."
exit_normal
else
FileUtils.mkdir_p(FileUtils.join_paths(JumpStart.templates_path, @template_name, "/jumpstart_config"))
yaml = IO.read(FileUtils.join_paths(ROOT_PATH, "/source_templates/template_config.yml"))
File.open(FileUtils.join_paths(JumpStart.templates_path, @template_name, "/jumpstart_config", "#{@template_name}.yml"), 'w') do |file|
file.puts yaml
end
puts "The template #{@template_name.green} has been generated.\n"
end
end | ruby | {
"resource": ""
} |
q4845 | JumpStart.Base.jumpstart_menu | train | def jumpstart_menu
puts "\n\n******************************************************************************************************************************************\n\n"
puts " JUMPSTART MENU\n".purple
puts " Here are your options:\n\n"
puts " 1".yellow + " Create a new project from an existing template.\n"
puts " 2".yellow + " Create a new template.\n"
puts " 3".yellow + " Set the default template.\n"
puts " 4".yellow + " Set the templates directory.\n\n"
puts " x".yellow + " Exit jumpstart.\n\n"
puts "******************************************************************************************************************************************\n\n"
jumpstart_menu_options
end | ruby | {
"resource": ""
} |
q4846 | JumpStart.Base.jumpstart_menu_options | train | def jumpstart_menu_options
input = gets.chomp.strip.downcase
case
when input == "1"
new_project_from_template_menu
when input == "2"
new_template_menu
when input == "3"
set_default_template_menu
when input == "4"
templates_dir_menu
when input == "x"
exit_normal
else
puts "That command hasn't been understood. Try again!".red
jumpstart_menu_options
end
end | ruby | {
"resource": ""
} |
q4847 | JumpStart.Base.new_project_from_template_menu | train | def new_project_from_template_menu
puts "\n\n******************************************************************************************************************************************\n\n"
puts " CREATE A NEW JUMPSTART PROJECT FROM AN EXISTING TEMPLATE\n\n".purple
puts " Type a number for the template that you want.\n\n"
display_existing_templates
puts "\n b".yellow + " Back to main menu."
puts "\n x".yellow + " Exit jumpstart.\n\n"
puts "******************************************************************************************************************************************\n\n"
new_project_from_template_options
end | ruby | {
"resource": ""
} |
q4848 | JumpStart.Base.new_project_from_template_options | train | def new_project_from_template_options
input = gets.chomp.strip.downcase
case
when input.to_i <= JumpStart.existing_templates.count && input.to_i > 0
@template_name = JumpStart.existing_templates[(input.to_i - 1)]
check_project_name
project = JumpStart::Base.new([@project_name, @template_name])
project.check_setup
project.start
when input == "b"
jumpstart_menu
when input == "x"
exit_normal
else
puts "That command hasn't been understood. Try again!".red
new_project_from_template_options
end
end | ruby | {
"resource": ""
} |
q4849 | JumpStart.Base.new_template_menu | train | def new_template_menu
puts "\n\n******************************************************************************************************************************************\n\n"
puts " CREATE A NEW JUMPSTART TEMPLATE\n".purple
puts " Existing templates:\n"
display_existing_templates
puts "\n b".yellow + " Back to main menu."
puts "\n x".yellow + " Exit jumpstart.\n"
new_template_options
end | ruby | {
"resource": ""
} |
q4850 | JumpStart.Base.new_template_options | train | def new_template_options
puts "\n Enter a unique name to create a new template, or enter an existing templates name (or number) to duplicate it.".yellow
input = gets.chomp.strip
case
when input.downcase == "b"
jumpstart_menu
when input.downcase == "x"
exit_normal
when JumpStart.existing_templates.include?(input)
puts "\n You have chosen to duplicate the " + input.green + " template." + "\n Please enter a name for the duplicate.".yellow
duplicate_template(input)
when input.to_i != 0 && input.to_i <= JumpStart.existing_templates.count
puts "\n You have chosen to duplicate the " + JumpStart.existing_templates[(input.to_i - 1)].green + " template." + "\n Please enter a name for the duplicate.".yellow
duplicate_template(JumpStart.existing_templates[(input.to_i - 1)])
when input.length < 3
puts "\n The template name ".red + input.red_bold + " is too short. Please enter a name that is at least 3 characters long.".red
new_template_options
when input.match(/^\W|\W$/)
puts "\n The template name ".red + input.red_bold + " begins or ends with an invalid character. Please enter a name that begins with a letter or a number.".red
new_template_options
else
FileUtils.mkdir_p(FileUtils.join_paths(JumpStart.templates_path, input, "jumpstart_config"))
FileUtils.cp(FileUtils.join_paths(ROOT_PATH, "source_templates/template_config.yml"), FileUtils.join_paths(JumpStart.templates_path, input, "jumpstart_config", "#{input}.yml"))
puts "\n The template ".green + input.green_bold + " has been created in your default jumpstart template directory ".green + JumpStart.templates_path.green_bold + " ready for editing.".green
jumpstart_menu
end
end | ruby | {
"resource": ""
} |
q4851 | JumpStart.Base.set_default_template_menu | train | def set_default_template_menu
puts "\n\n******************************************************************************************************************************************\n\n"
puts " SELECT A DEFAULT JUMPSTART TEMPLATE\n".purple
display_existing_templates
puts "\n b".yellow + " Back to main menu.\n\n"
puts " x".yellow + " Exit jumpstart.\n\n"
puts "******************************************************************************************************************************************\n\n"
set_default_template_options
end | ruby | {
"resource": ""
} |
q4852 | JumpStart.Base.set_default_template_options | train | def set_default_template_options
input = gets.chomp.strip
case
when input.to_i <= JumpStart.existing_templates.count && input.to_i > 0
JumpStart.default_template_name = JumpStart.existing_templates[(input.to_i - 1)]
JumpStart.dump_jumpstart_setup_yaml
puts " The default jumpstart template has been set to: ".green + JumpStart.default_template_name.green_bold
jumpstart_menu
when input.downcase == "b"
jumpstart_menu
when input.downcase == "x"
exit_normal
else
puts "That command hasn't been understood. Try again!".red
set_default_template_options
end
end | ruby | {
"resource": ""
} |
q4853 | JumpStart.Base.templates_dir_menu | train | def templates_dir_menu
puts "\n\n******************************************************************************************************************************************\n\n"
puts " JUMPSTART TEMPLATES DIRECTORY OPTIONS\n".purple
puts " The JumpStart template directory is currently: " + JumpStart.templates_path.green
puts "\n 1".yellow + " Change the templates directory.\n"
puts " 2".yellow + " Reset the templates directory to default.\n\n"
puts " b".yellow + " Back to main menu.\n\n"
puts " x".yellow + " Exit jumpstart.\n\n"
puts "******************************************************************************************************************************************\n\n"
templates_dir_options
end | ruby | {
"resource": ""
} |
q4854 | JumpStart.Base.templates_dir_options | train | def templates_dir_options
input = gets.chomp.strip.downcase
case
when input == "1"
puts " Please enter the absolute path for the directory that you would like to contain your jumpstart templates.".yellow
puts " e.g. /Users/your_name/projects/jumpstart_templates\n\n"
set_templates_dir
when input == "2"
reset_templates_dir_to_default_check
when input == "b"
jumpstart_menu
when input == "x"
exit_normal
else
puts " That command hasn't been understood. Try again!".red
templates_dir_options
end
end | ruby | {
"resource": ""
} |
q4855 | JumpStart.Base.set_templates_dir | train | def set_templates_dir
input = gets.chomp.strip
root_path = input.sub(/\/\w*\/*$/, '')
case
when input.downcase == "b"
jumpstart_menu
when input.downcase == "x"
exit_normal
when File.directory?(input)
puts "\n A directory of that name already exists, would you like to set it as your template directory anyway? (Nothing will be copied or removed.)".yellow
puts " Yes (" + "y".yellow + ") or No (" + "n".yellow + ")?"
set_templates_dir_to_existing_dir(input)
when File.directory?(root_path)
begin
Dir.chdir(root_path)
Dir.mkdir(input)
files_and_dirs = FileUtils.sort_contained_files_and_dirs(JumpStart.templates_path)
puts "\nCopying existing templates to #{input}"
files_and_dirs[:dirs].each {|x| FileUtils.mkdir_p(FileUtils.join_paths(input, x))}
files_and_dirs[:files].each {|x| FileUtils.cp(FileUtils.join_paths(JumpStart.templates_path, x), FileUtils.join_paths(input, x)) }
JumpStart.templates_path = input.to_s
JumpStart.dump_jumpstart_setup_yaml
puts "\n Transfer complete!".green
puts "\n The directory " + input.green + " has been set as the JumpStart templates directory."
jumpstart_menu
rescue
puts " It looks like you do not have the correct permissions to create a directory in #{root_path.red}"
end
else
puts " Couldn't find a directory of that name. Try again.".red
set_templates_dir
end
end | ruby | {
"resource": ""
} |
q4856 | JumpStart.Base.set_templates_dir_to_existing_dir | train | def set_templates_dir_to_existing_dir(dir)
input = gets.chomp.strip.downcase
case
when input == "b"
jumpstart_menu
when input == "x"
exit_normal
when input == "y" || input == "yes"
JumpStart.templates_path = dir
JumpStart.dump_jumpstart_setup_yaml
puts "\n The directory ".green + dir.green_bold + " has been set as the JumpStart templates directory.".green
jumpstart_menu
when input == "n" || input == "no"
puts "\n The JumpStart templates directory has not been altered".yellow
jumpstart_menu
else
puts "\n The command has not been understood, try again!".red
set_templates_dir_to_existing_dir(dir)
end
end | ruby | {
"resource": ""
} |
q4857 | JumpStart.Base.parse_template_dir | train | def parse_template_dir
@dir_list = []
file_list = []
@append_templates = []
@line_templates = []
@whole_templates = []
Find.find(@template_path) do |x|
case
when File.file?(x) && x !~ /\/jumpstart_config/ then
file_list << x.sub!(@template_path, '')
when File.directory?(x) && x !~ /\/jumpstart_config/ then
@dir_list << x.sub!(@template_path, '')
when File.file?(x) && x =~ /\/jumpstart_config\/nginx.local.conf/ then
@nginx_local_template = x
when File.file?(x) && x =~ /\/jumpstart_config\/nginx.remote.conf/ then
@nginx_remote_template = x
end
end
file_list.each do |file|
if file =~ /_([lL]?)\._{1}\w*/
@append_templates << file
elsif file =~ /_(\d+)\._{1}\w*/
@line_templates << file
else
@whole_templates << file
end
end
end | ruby | {
"resource": ""
} |
q4858 | JumpStart.Base.populate_files_from_whole_templates | train | def populate_files_from_whole_templates
@whole_templates.each {|x| FileUtils.cp(FileUtils.join_paths(@template_path, x), FileUtils.join_paths(@install_path, @project_name, x)) } unless @whole_templates.nil?
end | ruby | {
"resource": ""
} |
q4859 | JumpStart.Base.remove_unwanted_files | train | def remove_unwanted_files
file_array = []
root_path = FileUtils.join_paths(@install_path, @project_name)
unless @config_file[:remove_files].nil?
@config_file[:remove_files].each do |file|
file_array << FileUtils.join_paths(root_path, file)
end
FileUtils.remove_files(file_array)
end
end | ruby | {
"resource": ""
} |
q4860 | JumpStart.Base.run_scripts_from_yaml | train | def run_scripts_from_yaml(script_name)
unless @config_file[script_name].nil? || @config_file[script_name].empty?
begin
Dir.chdir(FileUtils.join_paths(@install_path, @project_name))
@config_file[script_name].each do |x|
puts "\nExecuting command: #{x.green}"
system "#{x}"
end
rescue
puts "\nCould not access the directory #{FileUtils.join_paths(@install_path, @project_name).red}.\nIn the interest of safety JumpStart will NOT run any YAML scripts from #{script_name.to_s.red_bold} until it can change into the new projects home directory."
end
end
end | ruby | {
"resource": ""
} |
q4861 | JumpStart.Base.check_for_strings_to_replace | train | def check_for_strings_to_replace
if @replace_strings.nil? || @replace_strings.empty?
return false
else
puts "\nChecking for strings to replace inside files...\n\n"
@replace_strings.each do |file|
if file[:target_path].nil? || file[:symbols].nil?
return false
else
puts "Target file: #{file[:target_path].green}\n"
puts "Strings to replace:\n\n"
check_replace_string_pairs_for_project_name_sub(file[:symbols])
file[:symbols].each do |x,y|
puts "Key: #{x.to_s.green}"
puts "Value: #{y.to_s.green}\n\n"
end
puts "\n"
path = FileUtils.join_paths(@install_path, @project_name, file[:target_path])
FileUtils.replace_strings(path, file[:symbols])
end
end
end
end | ruby | {
"resource": ""
} |
q4862 | JumpStart.Base.exit_with_success | train | def exit_with_success
puts "\n\n Exiting JumpStart...".purple
puts "\n Success! ".green + @project_name.green_bold + " has been created at: ".green + FileUtils.join_paths(@install_path, @project_name).green_bold + "\n\n".green
puts "******************************************************************************************************************************************\n"
JumpStart.dump_jumpstart_setup_yaml
exit
end | ruby | {
"resource": ""
} |
q4863 | Elk.Number.save | train | def save
attributes = {
sms_url: self.sms_url,
voice_start: self.voice_start_url
}
# If new URL, send country, otherwise not
unless self.number_id
attributes[:country] = self.country
end
response = @client.post("/Numbers/#{self.number_id}", attributes)
response.code == 200
end | ruby | {
"resource": ""
} |
q4864 | Elk.Number.deallocate! | train | def deallocate!
response = @client.post("/Numbers/#{self.number_id}", { active: "no" })
self.set_paramaters(Elk::Util.parse_json(response.body))
response.code == 200
end | ruby | {
"resource": ""
} |
q4865 | Edgarj.CommonHelper.datetime_fmt | train | def datetime_fmt(dt)
if dt.blank? then
''
else
I18n.l(dt, format: I18n.t('edgarj.time.format'))
end
end | ruby | {
"resource": ""
} |
q4866 | Edgarj.CommonHelper.get_enum | train | def get_enum(model, col)
col_name = col.name
if model.const_defined?(col_name.camelize, false)
enum = model.const_get(col_name.camelize)
enum.is_a?(Module) ? enum : nil
else
nil
end
end | ruby | {
"resource": ""
} |
q4867 | Magma.Templater.render | train | def render(template)
template.render(config.variables.deep_merge(options[:globals]), strict_variables: true).tap do
if template.errors&.length&.positive?
puts template.errors
raise template.errors.map(&:to_s).join('; ')
end
end
end | ruby | {
"resource": ""
} |
q4868 | Banklink.Common.parse | train | def parse(post)
@raw = post.to_s
for line in @raw.split('&')
key, value = *line.scan( %r{^([A-Za-z0-9_.]+)\=(.*)$} ).flatten
params[key] = CGI.unescape(value)
end
end | ruby | {
"resource": ""
} |
q4869 | Languages.ManagerBasicStructureData.add_conditional | train | def add_conditional(pConditional)
return nil unless pConditional.is_a?(Languages::ConditionalData)
pConditional.level = @currentLevel
@basicStructure.push(pConditional)
end | ruby | {
"resource": ""
} |
q4870 | Languages.ManagerBasicStructureData.add_repetition | train | def add_repetition(pRepetition)
return nil unless pRepetition.is_a?(Languages::RepetitionData)
pRepetition.level = @currentLevel
@basicStructure.push(pRepetition)
end | ruby | {
"resource": ""
} |
q4871 | Languages.ManagerBasicStructureData.add_block | train | def add_block(pBlock)
return nil unless pBlock.is_a?(Languages::BlockData)
pBlock.level = @currentLevel
@basicStructure.push(pBlock)
end | ruby | {
"resource": ""
} |
q4872 | XmlFu.Configuration.symbol_conversion_algorithm= | train | def symbol_conversion_algorithm=(algorithm)
raise(ArgumentError, "Missing symbol conversion algorithm") unless algorithm
if algorithm.respond_to?(:call)
@symbol_conversion_algorithm = algorithm
else
if algorithm == :default
@symbol_conversion_algorithm = ALGORITHMS[:lower_camelcase]
elsif ALGORITHMS.keys.include?(algorithm)
@symbol_conversion_algorithm = ALGORITHMS[algorithm]
else
raise(ArgumentError, "Invalid symbol conversion algorithm")
end
end
end | ruby | {
"resource": ""
} |
q4873 | CricosScrape.CourseImporter.find_course_location | train | def find_course_location
location_ids = []
if location_results_paginated?
for page_number in 1..total_pages
jump_to_page(page_number)
location_ids += fetch_location_ids_from_current_page
end
else
location_ids += fetch_location_ids_from_current_page
end
location_ids
end | ruby | {
"resource": ""
} |
q4874 | GithubGem.RakeTasks.define_rspec_tasks! | train | def define_rspec_tasks!
require 'rspec/core/rake_task'
namespace(:spec) do
desc "Verify all RSpec examples for #{gemspec.name}"
RSpec::Core::RakeTask.new(:basic) do |t|
t.pattern = spec_pattern
end
desc "Verify all RSpec examples for #{gemspec.name} and output specdoc"
RSpec::Core::RakeTask.new(:specdoc) do |t|
t.pattern = spec_pattern
t.rspec_opts = ['--format', 'documentation', '--color']
end
desc "Run RCov on specs for #{gemspec.name}"
RSpec::Core::RakeTask.new(:rcov) do |t|
t.pattern = spec_pattern
t.rcov = true
t.rcov_opts = ['--exclude', '"spec/*,gems/*"', '--rails']
end
end
desc "Verify all RSpec examples for #{gemspec.name} and output specdoc"
task(:spec => ['spec:specdoc'])
end | ruby | {
"resource": ""
} |
q4875 | GithubGem.RakeTasks.define_tasks! | train | def define_tasks!
define_test_tasks! if has_tests?
define_rspec_tasks! if has_specs?
namespace(@task_namespace) do
desc "Updates the filelist in the gemspec file"
task(:manifest) { manifest_task }
desc "Builds the .gem package"
task(:build => :manifest) { build_task }
desc "Sets the version of the gem in the gemspec"
task(:set_version => [:check_version, :check_current_branch]) { version_task }
task(:check_version => :fetch_origin) { check_version_task }
task(:fetch_origin) { fetch_origin_task }
task(:check_current_branch) { check_current_branch_task }
task(:check_clean_status) { check_clean_status_task }
task(:check_not_diverged => :fetch_origin) { check_not_diverged_task }
checks = [:check_current_branch, :check_clean_status, :check_not_diverged, :check_version]
checks.unshift('spec:basic') if has_specs?
checks.unshift('test:basic') if has_tests?
# checks.push << [:check_rubyforge] if gemspec.rubyforge_project
desc "Perform all checks that would occur before a release"
task(:release_checks => checks)
release_tasks = [:release_checks, :set_version, :build, :github_release, :gemcutter_release]
# release_tasks << [:rubyforge_release] if gemspec.rubyforge_project
desc "Release a new version of the gem using the VERSION environment variable"
task(:release => release_tasks) { release_task }
namespace(:release) do
desc "Release the next version of the gem, by incrementing the last version segment by 1"
task(:next => [:next_version] + release_tasks) { release_task }
desc "Release the next version of the gem, using a patch increment (0.0.1)"
task(:patch => [:next_patch_version] + release_tasks) { release_task }
desc "Release the next version of the gem, using a minor increment (0.1.0)"
task(:minor => [:next_minor_version] + release_tasks) { release_task }
desc "Release the next version of the gem, using a major increment (1.0.0)"
task(:major => [:next_major_version] + release_tasks) { release_task }
end
# task(:check_rubyforge) { check_rubyforge_task }
# task(:rubyforge_release) { rubyforge_release_task }
task(:gemcutter_release) { gemcutter_release_task }
task(:github_release => [:commit_modified_files, :tag_version]) { github_release_task }
task(:tag_version) { tag_version_task }
task(:commit_modified_files) { commit_modified_files_task }
task(:next_version) { next_version_task }
task(:next_patch_version) { next_version_task(:patch) }
task(:next_minor_version) { next_version_task(:minor) }
task(:next_major_version) { next_version_task(:major) }
desc "Updates the gem release tasks with the latest version on Github"
task(:update_tasks) { update_tasks_task }
end
end | ruby | {
"resource": ""
} |
q4876 | GithubGem.RakeTasks.version_task | train | def version_task
update_gemspec(:version, ENV['VERSION']) if ENV['VERSION']
update_gemspec(:date, Date.today)
update_version_file(gemspec.version)
update_version_constant(gemspec.version)
end | ruby | {
"resource": ""
} |
q4877 | GithubGem.RakeTasks.update_version_file | train | def update_version_file(version)
if File.exists?('VERSION')
File.open('VERSION', 'w') { |f| f << version.to_s }
modified_files << 'VERSION'
end
end | ruby | {
"resource": ""
} |
q4878 | GithubGem.RakeTasks.update_version_constant | train | def update_version_constant(version)
if main_include && File.exist?(main_include)
file_contents = File.read(main_include)
if file_contents.sub!(/^(\s+VERSION\s*=\s*)[^\s].*$/) { $1 + version.to_s.inspect }
File.open(main_include, 'w') { |f| f << file_contents }
modified_files << main_include
end
end
end | ruby | {
"resource": ""
} |
q4879 | JsonRecord.EmbeddedDocument.attributes= | train | def attributes= (attrs)
attrs.each_pair do |name, value|
field = schema.fields[name.to_s] || FieldDefinition.new(name, :type => value.class)
setter = "#{name}=".to_sym
if respond_to?(setter)
send(setter, value)
else
write_attribute(field, value, self)
end
end
end | ruby | {
"resource": ""
} |
q4880 | JsonRecord.EmbeddedDocument.[]= | train | def []= (name, value)
field = schema.fields[name.to_s] || FieldDefinition.new(name, :type => value.class)
write_attribute(field, value, self)
end | ruby | {
"resource": ""
} |
q4881 | ActiveRepository.Base.reload | train | def reload
object = self.id.present? ?
persistence_class.where(id: self.id).first_or_initialize :
self
serialize! object.attributes
end | ruby | {
"resource": ""
} |
q4882 | ActiveRepository.Base.serialize! | train | def serialize!(attributes)
unless attributes.nil?
attributes.each do |key, value|
key = "id" if key == "_id"
self.send("#{key}=", (value.dup rescue value))
end
end
self.dup
end | ruby | {
"resource": ""
} |
q4883 | ActiveRepository.Base.convert | train | def convert(attribute="id")
klass = persistence_class
object = klass.where(attribute.to_sym => self.send(attribute)).first
object ||= persistence_class.new
attributes = self.attributes.select{ |key, value| self.class.serialized_attributes.include?(key.to_s) }
attributes.delete(:id)
object.attributes = attributes
object.save
self.id = object.id
object
end | ruby | {
"resource": ""
} |
q4884 | ActiveRepository.Base.set_timestamps | train | def set_timestamps
if self.errors.empty?
self.created_at = DateTime.now.utc if self.respond_to?(:created_at=) && self.created_at.nil?
self.updated_at = DateTime.now.utc if self.respond_to?(:updated_at=)
end
end | ruby | {
"resource": ""
} |
q4885 | Atom.Element.set | train | def set(ns, element_name, value="", attributes=nil)
xpath = child_xpath(ns, element_name)
@elem.elements.delete_all(xpath)
add(ns, element_name, value, attributes)
end | ruby | {
"resource": ""
} |
q4886 | Atom.Element.add | train | def add(ns, element_name, value, attributes={})
element = REXML::Element.new(element_name)
if ns.is_a?(Namespace)
unless ns.prefix.nil? || ns.prefix.empty?
element.name = "#{ns.prefix}:#{element_name}"
element.add_namespace ns.prefix, ns.uri unless @ns == ns || @ns == ns.uri
else
element.add_namespace ns.uri unless @ns == ns || @ns == ns.uri
end
else
element.add_namespace ns unless @ns == ns || @ns.to_s == ns
end
if value.is_a?(Element)
value.elem.each_element do |e|
element.add e.deep_clone
end
value.elem.attributes.each_attribute do |a|
unless a.name =~ /^xmlns(?:\:)?/
element.add_attribute a
end
end
#element.text = value.elem.text unless value.elem.text.nil?
text = value.elem.get_text
unless text.nil?
element.text = REXML::Text.new(text.to_s, true, nil, true)
end
else
if value.is_a?(REXML::Element)
element.add_element value.deep_clone
else
element.add_text value.to_s
end
end
element.add_attributes attributes unless attributes.nil?
@elem.add_element element
end | ruby | {
"resource": ""
} |
q4887 | Atom.Element.get_object | train | def get_object(ns, element_name, ext_class)
elements = getlist(ns, element_name)
return nil if elements.empty?
ext_class.new(:namespace => ns, :elem => elements.first)
end | ruby | {
"resource": ""
} |
q4888 | Atom.Element.get_objects | train | def get_objects(ns, element_name, ext_class)
elements = getlist(ns, element_name)
return [] if elements.empty?
elements.collect do |e|
ext_class.new(:namespace => ns, :elem => e)
end
end | ruby | {
"resource": ""
} |
q4889 | Atom.Element.to_s | train | def to_s(*)
doc = REXML::Document.new
decl = REXML::XMLDecl.new("1.0", "utf-8")
doc.add decl
doc.add_element @elem
doc.to_s
end | ruby | {
"resource": ""
} |
q4890 | Atom.Element.child_xpath | train | def child_xpath(ns, element_name, attributes=nil)
ns_uri = ns.is_a?(Namespace) ? ns.uri : ns
unless !attributes.nil? && attributes.is_a?(Hash)
"child::*[local-name()='#{element_name}' and namespace-uri()='#{ns_uri}']"
else
attr_str = attributes.collect{|key, val| "@#{key.to_s}='#{val}'"}.join(' and ')
"child::*[local-name()='#{element_name}' and namespace-uri()='#{ns_uri}' and #{attr_str}]"
end
end | ruby | {
"resource": ""
} |
q4891 | Atompub.Client.get_media | train | def get_media(media_uri)
get_resource(media_uri)
if @rc.instance_of?(Atom::Entry)
raise ResponseError, "Response is not Media Resource"
end
return @rc, @res.content_type
end | ruby | {
"resource": ""
} |
q4892 | Atompub.Client.create_entry | train | def create_entry(post_uri, entry, slug=nil)
unless entry.kind_of?(Atom::Entry)
entry = Atom::Entry.new :stream => entry
end
service = @service_info.get(post_uri)
unless entry.categories.all?{ |c| service.allows_category?(c) }
raise RequestError, "Forbidden Category"
end
create_resource(post_uri, entry.to_s, Atom::MediaType::ENTRY.to_s, slug)
@res['Location']
end | ruby | {
"resource": ""
} |
q4893 | Atompub.Client.create_media | train | def create_media(media_uri, file_path, content_type, slug=nil)
file_path = Pathname.new(file_path) unless file_path.is_a?(Pathname)
stream = file_path.open { |f| f.binmode; f.read }
service = @service_info.get(media_uri)
if service.nil?
raise RequestError, "Service information not found. Get service document before you do create_media."
end
unless service.accepts_media_type?(content_type)
raise RequestError, "Unsupported Media Type: #{content_type}"
end
create_resource(media_uri, stream, content_type, slug)
@res['Location']
end | ruby | {
"resource": ""
} |
q4894 | Atompub.Client.update_media | train | def update_media(media_uri, file_path, content_type)
file_path = Pathname.new(file_path) unless file_path.is_a?(Pathname)
stream = file_path.open { |f| f.binmode; f.read }
update_resource(media_uri, stream, content_type)
end | ruby | {
"resource": ""
} |
q4895 | Atompub.Client.get_contents_except_resources | train | def get_contents_except_resources(uri, &block)
clear
uri = URI.parse(uri)
@req = Net::HTTP::Get.new uri.request_uri
set_common_info(@req)
@http_class.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') do |http|
@res = http.request(@req)
case @res
when Net::HTTPOK
block.call(@res) if block_given?
else
raise RequestError, "Failed to get contents. #{@res.code}"
end
end
end | ruby | {
"resource": ""
} |
q4896 | ROF::Translators.OsfToRof.fetch_from_ttl | train | def fetch_from_ttl(ttl_file)
graph = RDF::Turtle::Reader.open(ttl_file, prefixes: ROF::OsfPrefixList.dup)
JSON::LD::API.fromRdf(graph)
end | ruby | {
"resource": ""
} |
q4897 | ROF::Translators.OsfToRof.apply_previous_archived_version_if_applicable | train | def apply_previous_archived_version_if_applicable(rels_ext)
# If a previously archived pid was passed in, use it to set pav:previousVersion
# If not, check SOLR for one.
pid = previously_archived_pid_finder.call(archive_type, osf_project_identifier)
pid = ROF::Utility.check_solr_for_previous(config, osf_project_identifier) if pid.nil?
rels_ext['pav:previousVersion'] = pid if pid
rels_ext
end | ruby | {
"resource": ""
} |
q4898 | ROF::Translators.OsfToRof.build_archive_record | train | def build_archive_record
this_rof = {}
this_rof['owner'] = project['owner']
this_rof['type'] = 'OsfArchive'
this_rof['rights'] = map_rights
this_rof['rels-ext'] = map_rels_ext
this_rof['metadata'] = map_metadata
this_rof['files'] = [source_slug + '.tar.gz']
this_rof
end | ruby | {
"resource": ""
} |
q4899 | ROF::Translators.OsfToRof.map_creator | train | def map_creator
creator = []
ttl_data[0][@osf_map['hasContributor']].each do |contributor|
# Looping through the primary document and the contributors
ttl_data.each do |item|
next unless item['@id'] == contributor['@id']
if item[@osf_map['isBibliographic']][0]['@value'] == 'true'
creator.push map_user_from_ttl(item[@osf_map['hasUser']][0]['@id'])
end
end
end
creator
end | ruby | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.