_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3
values | text stringlengths 66 10.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q4600 | GeoKit.LatLng.wgs84_to_google | train | def wgs84_to_google
ActiveSupport::Deprecation.warn "use Point geometry which supports srid"
self.class.from_pro4j Proj4::Projection.wgs84.transform Proj4::Projection.google, self.proj4_point(Math::PI / 180).x, self.proj4_point(Math::PI / 180).y
end | ruby | {
"resource": ""
} |
q4601 | Unipept.ServerMessage.print | train | def print
return unless $stdout.tty?
return if recently_fetched?
resp = fetch_server_message
update_fetched
puts resp unless resp.empty?
end | ruby | {
"resource": ""
} |
q4602 | RailsPaginate::Renderers.HtmlDefault.render | train | def render
content_tag(:ul) do
html = "\n"
if show_first_page?
html += content_tag(:li, :class => "first_page") do
link_to_page collection.first_page, 'paginate.first_page_label'
end
html += "\n"
end
if show_previous_page?
html ... | ruby | {
"resource": ""
} |
q4603 | Squire.Configuration.namespace | train | def namespace(namespace = nil, options = {})
return @namespace unless namespace
@namespace = namespace.to_sym if namespace
@base_namespace = options[:base].to_sym if options[:base]
end | ruby | {
"resource": ""
} |
q4604 | Squire.Configuration.source | train | def source(source = nil, options = {})
return @source unless source
@source = source
@parser = options[:parser]
@type = options[:type]
@type ||= source.is_a?(Hash) ? :hash : File.extname(@source)[1..-1].to_sym
end | ruby | {
"resource": ""
} |
q4605 | Squire.Configuration.settings | train | def settings(&block)
@settings ||= setup
settings = instance_variable_defined?(:@namespace) ? @settings.get_value(@namespace) : @settings
if block_given?
block.arity == 0 ? settings.instance_eval(&block) : block.call(settings)
end
settings
end | ruby | {
"resource": ""
} |
q4606 | Squire.Configuration.setup | train | def setup
return Squire::Settings.new unless @source
parser = Squire::Parser.of(@type)
hash = parser.parse(source).with_indifferent_access
if base_namespace
hash.except(base_namespace).each do |key, values|
# favours value from namespace over value from defaults
ha... | ruby | {
"resource": ""
} |
q4607 | Mercurial.CommitFactory.count_range | train | def count_range(hash_a, hash_b, cmd_options={})
hg_to_array([%Q[log -r ?:? --template "{node}\n"], hash_a, hash_b], {}, cmd_options) do |line|
line
end.size
end | ruby | {
"resource": ""
} |
q4608 | Adfly.API.create_link | train | def create_link data
body = http_get URL_API, {key: @key, uid: @uid}.merge(data)
raise ArgumentError if body.nil? || body.empty?
body
end | ruby | {
"resource": ""
} |
q4609 | Mongoid::Globalize.FieldsBuilder.field | train | def field(name, *params)
@model.translated_attribute_names.push name.to_sym
@model.translated_attr_accessor(name)
@model.translation_class.field name, *params
end | ruby | {
"resource": ""
} |
q4610 | Danger.DangerSimpleCovJson.report | train | def report(coverage_path, sticky: true)
if File.exist? coverage_path
coverage_json = JSON.parse(File.read(coverage_path), symbolize_names: true)
metrics = coverage_json[:metrics]
percentage = metrics[:covered_percent]
lines = metrics[:covered_lines]
total_lines = metrics[:t... | ruby | {
"resource": ""
} |
q4611 | Danger.DangerSimpleCovJson.individual_coverage_message | train | def individual_coverage_message(covered_files)
require 'terminal-table'
message = "### Code Coverage\n\n"
table = Terminal::Table.new(
headings: %w(File Coverage),
style: { border_i: '|' },
rows: covered_files.map do |file|
[file[:filename], "#{format('%.02f', file[:... | ruby | {
"resource": ""
} |
q4612 | KnifeCommunity.CommunityRelease.validate_args | train | def validate_args
if name_args.size < 1
ui.error('No cookbook has been specified')
show_usage
exit 1
end
if name_args.size > 2
ui.error('Too many arguments are being passed. Please verify.')
show_usage
exit 1
end
end | ruby | {
"resource": ""
} |
q4613 | KnifeCommunity.CommunityRelease.validate_repo_clean | train | def validate_repo_clean
@gitrepo = Grit::Repo.new(@repo_root)
status = @gitrepo.status
if !status.changed.nil? || status.changed.size != 0 # This has to be a convoluted way to determine a non-empty...
# Test each for the magic sha_index. Ref: https://github.com/mojombo/grit/issues/142
... | ruby | {
"resource": ""
} |
q4614 | KnifeCommunity.CommunityRelease.validate_no_existing_tag | train | def validate_no_existing_tag(tag_string)
existing_tags = []
@gitrepo.tags.each { |tag| existing_tags << tag.name }
if existing_tags.include?(tag_string)
ui.error 'This version tag has already been committed to the repo.'
ui.error "Are you sure you haven't released this already?"
... | ruby | {
"resource": ""
} |
q4615 | KnifeCommunity.CommunityRelease.validate_target_remote_branch | train | def validate_target_remote_branch
remote_path = File.join(config[:remote], config[:branch])
remotes = []
@gitrepo.remotes.each { |remote| remotes << remote.name }
unless remotes.include?(remote_path)
ui.error 'The remote/branch specified does not seem to exist.'
exit 7
end... | ruby | {
"resource": ""
} |
q4616 | Munin.Node.nodes | train | def nodes
nodes = []
cache 'nodes' do
connection.send_data("nodes")
while ( ( line = connection.read_line ) != "." )
nodes << line
end
nodes
end
end | ruby | {
"resource": ""
} |
q4617 | Munin.Node.list | train | def list(node = "")
cache "list_#{node.empty? ? 'default' : node}" do
connection.send_data("list #{node}")
if ( line = connection.read_line ) != "."
line.split
else
connection.read_line.split
end
end
end | ruby | {
"resource": ""
} |
q4618 | Munin.Node.config | train | def config(services, raw=false)
unless [String, Array].include?(services.class)
raise ArgumentError, "Service(s) argument required"
end
results = {}
names = [services].flatten.uniq
if names.empty?
raise ArgumentError, "Service(s) argument require... | ruby | {
"resource": ""
} |
q4619 | Munin.Node.fetch | train | def fetch(services)
unless [String, Array].include?(services.class)
raise ArgumentError, "Service(s) argument required"
end
results = {}
names = [services].flatten
if names.empty?
raise ArgumentError, "Service(s) argument required"
end
nam... | ruby | {
"resource": ""
} |
q4620 | Squire.Settings.get_value | train | def get_value(key, &block)
key = key.to_sym
value = @table[key]
if block_given?
block.arity == 0 ? value.instance_eval(&block) : block.call(value)
end
value
end | ruby | {
"resource": ""
} |
q4621 | Squire.Settings.to_hash | train | def to_hash
result = ::Hash.new
@table.each do |key, value|
if value.is_a? Settings
value = value.to_hash
end
result[key] = value
end
result
end | ruby | {
"resource": ""
} |
q4622 | QuestionproRails.Question.choices | train | def choices
extracted_choices = []
unless self.qp_answers.nil?
self.qp_answers.each do |choice|
extracted_choices.push(Choice.new(choice))
end
end
return extracted_choices
end | ruby | {
"resource": ""
} |
q4623 | Rtasklib.Helpers.filter | train | def filter ids: nil, tags: nil, dom: nil
id_s = tag_s = dom_s = ""
id_s = process_ids(ids) unless ids.nil?
tag_s = process_tags(tags) unless tags.nil?
dom_s = process_dom(dom) unless dom.nil?
return "#{id_s} #{tag_s} #{dom_s}".strip
end | ruby | {
"resource": ""
} |
q4624 | Rtasklib.Helpers.process_ids | train | def process_ids ids
case ids
when Range
return id_range_to_s(ids)
when Array
return id_a_to_s(ids)
when String
return ids.delete(" ")
when Fixnum
return ids
end
end | ruby | {
"resource": ""
} |
q4625 | Rtasklib.Helpers.process_tags | train | def process_tags tags
case tags
when String
tags.split(" ").map { |t| process_tag t }.join(" ")
when Array
tags.map { |t| process_tags t }.join(" ")
end
end | ruby | {
"resource": ""
} |
q4626 | Rtasklib.Helpers.json? | train | def json? value
begin
return false unless value.is_a? String
MultiJson.load(value)
true
rescue MultiJson::ParseError
false
end
end | ruby | {
"resource": ""
} |
q4627 | CouchRest.Property.cast_value | train | def cast_value(parent, value)
raise "An array inside an array cannot be casted, use CastedModel" if value.is_a?(Array)
value = typecast_value(value, self)
associate_casted_value_to_parent(parent, value)
end | ruby | {
"resource": ""
} |
q4628 | CouchRest.Property.type_class | train | def type_class
return String unless casted # This is rubbish, to handle validations
return @type_class unless @type_class.nil?
base = @type.is_a?(Array) ? @type.first : @type
base = String if base.nil?
base = TrueClass if base.is_a?(String) && base.downcase == 'boolean'
@type_class =... | ruby | {
"resource": ""
} |
q4629 | Unipept.BatchIterator.fasta_iterator | train | def fasta_iterator(first_line, next_lines)
current_fasta_header = first_line.chomp
next_lines.each_slice(batch_size).with_index do |slice, i|
fasta_mapper = []
input_set = Set.new
slice.each do |line|
line.chomp!
if fasta? line
current_fasta_header = ... | ruby | {
"resource": ""
} |
q4630 | AdbSdkLib.Device.properties | train | def properties
convert_map_to_hash(@device.getProperties) do |hash, key, value|
hash[key.toString] = value.toString
end
end | ruby | {
"resource": ""
} |
q4631 | AdbSdkLib.Device.shell | train | def shell(command, &block)
capture = CommandCapture.new(block_given? ? block : nil)
receiver = Rjb::bind(capture, 'com.android.ddmlib.IShellOutputReceiver')
@device.executeShellCommand(command.to_s, receiver)
block_given? ? self : capture.to_s
end | ruby | {
"resource": ""
} |
q4632 | AdbSdkLib.Device.push | train | def push(localfile, remotefile)
raise ArgumentError, "Not found #{localfile}" unless File.exist?(localfile)
if remotefile.end_with?('/')
remotefile = "#{remotefile}#{File.basename(localfile)}"
end
@device.pushFile(localfile, remotefile)
self
end | ruby | {
"resource": ""
} |
q4633 | AdbSdkLib.Device.pull | train | def pull(remotefile, localfile)
if localfile.end_with?('/') || File.directory?(localfile)
localdir = localfile.chomp('/')
localfilename = nil
else
localdir = File.dirname(localfile)
localfilename = File.basename(localfile)
end
unless File.exist?(localdir)
... | ruby | {
"resource": ""
} |
q4634 | GeoWorks.RasterFileBehavior.raster_work | train | def raster_work
parents.select do |parent|
parent.class.included_modules.include?(::GeoWorks::RasterWorkBehavior)
end.to_a
end | ruby | {
"resource": ""
} |
q4635 | AdbSdkLib.RawImage.pixel | train | def pixel(x,y)
Pixel.new(x,y,@image.getARGB(point_to_index(x,y)))
end | ruby | {
"resource": ""
} |
q4636 | AdbSdkLib.RawImage.each_pixel | train | def each_pixel()
return to_enum :each_pixel unless block_given?
@image.height.times do |y|
@image.width.times do |x|
yield pixel(x,y)
end
end
self
end | ruby | {
"resource": ""
} |
q4637 | QuestionproRails.ApiRequest.options | train | def options
{id: self.survey_id, surveyID: self.survey_id, responseID: self.response_id,
resultMode: self.result_mode, startDate: self.start_date, userID: self.user_id,
endDate: self.end_date, startingResponseCounter: self.starting_response_counter,
emailGroupID: self.email_group_id, templ... | ruby | {
"resource": ""
} |
q4638 | QuestionproRails.ApiRequest.list_surveys | train | def list_surveys
url = ApiRequest.base_path("questionpro.survey.getAllSurveys")
result = self.class.get(url, body: self.options)
self.full_response = result
self.status = result['status']
surveys = []
result_surveys = result['response']['surveys']
result_surveys.e... | ruby | {
"resource": ""
} |
q4639 | QuestionproRails.ApiRequest.get_survey | train | def get_survey
url = ApiRequest.base_path("questionpro.survey.getSurvey")
result = self.class.get(url, body: self.options)
self.full_response = result
self.status = result['status']
survey = Survey.new(result['response'])
return survey
end | ruby | {
"resource": ""
} |
q4640 | QuestionproRails.ApiRequest.get_survey_responses | train | def get_survey_responses
url = ApiRequest.base_path("questionpro.survey.surveyResponses")
result = self.class.get(url, body: self.options)
self.full_response = result
self.status = result['status']
survey_responses = []
result_responses = result['response']['responses']
... | ruby | {
"resource": ""
} |
q4641 | QuestionproRails.ApiRequest.get_survey_reponse | train | def get_survey_reponse
url = ApiRequest.base_path("questionpro.survey.surveyResponse")
result = self.class.get(url, body: self.options)
self.full_response = result
self.status = result['status']
response = SurveyResponse.new(result['response']['surveyResponse'])
return respo... | ruby | {
"resource": ""
} |
q4642 | QuestionproRails.ApiRequest.get_survey_response_count | train | def get_survey_response_count
url = ApiRequest.base_path("questionpro.survey.responseCount")
result = self.class.get(url, body: self.options)
self.full_response = result
self.status = result['status']
response_count = SurveyResponseCount.new(result['response'])
return respon... | ruby | {
"resource": ""
} |
q4643 | QuestionproRails.ApiRequest.delete_response | train | def delete_response
url = ApiRequest.base_path("questionpro.survey.deleteResponse")
result = self.class.get(url, body: self.options)
self.full_response = result
self.status = result['status']
self.success = result['response']['success']
return self
end | ruby | {
"resource": ""
} |
q4644 | QuestionproRails.ApiRequest.get_email_lists | train | def get_email_lists
url = ApiRequest.base_path("questionpro.survey.getEmailLists")
result = self.class.get(url, body: self.options)
self.full_response = result
self.status = result['status']
email_lists = []
result_email_lists = result['response']['emailLists']
result_e... | ruby | {
"resource": ""
} |
q4645 | QuestionproRails.ApiRequest.get_email_list | train | def get_email_list
url = ApiRequest.base_path("questionpro.survey.getEmailList")
result = self.class.get(url, body: self.options)
self.full_response = result
self.status = result['status']
email_list = EmailList.new(result['response']['emailList'])
return email_list
... | ruby | {
"resource": ""
} |
q4646 | QuestionproRails.ApiRequest.get_email_templates | train | def get_email_templates
url = ApiRequest.base_path("questionpro.survey.getEmailTemplates")
result = self.class.get(url, body: self.options)
self.full_response = result
self.status = result['status']
email_templates = []
result_email_templates = result['response']['emailTempla... | ruby | {
"resource": ""
} |
q4647 | QuestionproRails.ApiRequest.get_email_template | train | def get_email_template
url = ApiRequest.base_path("questionpro.survey.getEmailTemplate")
result = self.class.get(url, body: self.options)
self.full_response = result
self.status = result['status']
email_template = EmailTemplate.new(result['response']['emailTemplate'])
... | ruby | {
"resource": ""
} |
q4648 | QuestionproRails.ApiRequest.get_all_accounts | train | def get_all_accounts
url = ApiRequest.base_path("questionpro.survey.getAllAccounts")
result = self.class.get(url, body: self.options)
self.full_response = result
self.status = result['status']
accounts = []
result_accounts = result['response']['accounts']
result_account... | ruby | {
"resource": ""
} |
q4649 | QuestionproRails.ApiRequest.get_account | train | def get_account
url = ApiRequest.base_path("questionpro.survey.getAccount")
result = self.class.get(url, body: self.options)
self.full_response = result
self.status = result['status']
account = Account.new(result['response']['account'])
return account
end | ruby | {
"resource": ""
} |
q4650 | QuestionproRails.ApiRequest.get_unsubscribers | train | def get_unsubscribers
url = ApiRequest.base_path("questionpro.survey.getUnsubscribedEmailAddresses")
result = self.class.get(url, body: self.options)
self.full_response = result
self.status = result['status']
unsubscribers = []
result_unsubscribers = result['response']['respo... | ruby | {
"resource": ""
} |
q4651 | QuestionproRails.ApiRequest.get_survey_meta | train | def get_survey_meta
url = ApiRequest.base_path("questionpro.survey.sendSurveyMetaData")
result = self.class.get(url, body: self.options)
self.full_response = result
self.status = result['status']
survey_meta = SurveyMeta.new(result['response'])
return survey_meta ... | ruby | {
"resource": ""
} |
q4652 | QuestionproRails.ApiRequest.send_survey | train | def send_survey(mode = 1, emails = nil, template_id = nil)
url = ApiRequest.base_path("questionpro.survey.sendSurvey")
result = self.class.get(url, body: {surveyID: self.survey_id, mode: mode,
emailGroupID: self.email_group_id, emails: emails,
... | ruby | {
"resource": ""
} |
q4653 | QuestionproRails.ApiRequest.get_send_history | train | def get_send_history
url = ApiRequest.base_path("questionpro.survey.emailBatchStatistics")
result = self.class.get(url, body: self.options)
self.full_response = result
self.status = result['status']
email_batches = []
result_email_batches = result['response']['emailBatches']
... | ruby | {
"resource": ""
} |
q4654 | QuestionproRails.ApiRequest.send_reminders | train | def send_reminders
url = ApiRequest.base_path("questionpro.survey.sendReminder")
result = self.class.get(url, body: self.options)
self.full_response = result
self.status = result['status']
self.message = result['response']['result']
end | ruby | {
"resource": ""
} |
q4655 | QuestionproRails.ApiRequest.create_email_list | train | def create_email_list (emails = [], email_group_name = nil)
url = ApiRequest.base_path("questionpro.survey.createEmailGroup")
result = self.class.get(url, body: {id: self.survey_id, emails: emails,
emailGroupName: email_group_name}.compact.to_json)
self.full... | ruby | {
"resource": ""
} |
q4656 | QuestionproRails.Section.questions | train | def questions
extracted_questions = []
unless self.qp_questions.nil?
self.qp_questions.each do |question|
extracted_questions.push(Question.new(question))
end
end
return extracted_questions
end | ruby | {
"resource": ""
} |
q4657 | Xcop.Document.ldiff | train | def ldiff(license)
xml = Nokogiri::XML(File.open(@path), &:noblanks)
comment = xml.xpath('/comment()')[0]
now = comment.nil? ? '' : comment.text.to_s.strip
ideal = license.strip
differ(ideal, now)
end | ruby | {
"resource": ""
} |
q4658 | Xcop.Document.fix | train | def fix(license = '')
xml = Nokogiri::XML(File.open(@path), &:noblanks)
unless license.empty?
xml.xpath('/comment()').remove
xml.children.before(
Nokogiri::XML::Comment.new(xml, "\n#{license.strip}\n")
)
end
ideal = xml.to_xml(indent: 2)
File.write(@path, ... | ruby | {
"resource": ""
} |
q4659 | XO.Init.start | train | def start(turn)
game_context.check_turn(turn)
game_context.set_turn_and_clear_grid(turn)
engine.transition_to_state_and_send_event(Playing, :game_started)
end | ruby | {
"resource": ""
} |
q4660 | QuestionproRails.Survey.sections | train | def sections
extracted_sections = []
unless self.qp_sections.nil?
self.qp_sections.each do |section|
extracted_sections.push(Section.new(section))
end
end
return extracted_sections
end | ruby | {
"resource": ""
} |
q4661 | Mercurial.Commit.stats | train | def stats(cmd_options={})
raw = hg(["log -r ? --stat --template '{node}\n'", hash_id], cmd_options)
result = raw.scan(/(\d+) files changed, (\d+) insertions\(\+\), (\d+) deletions\(\-\)$/).flatten.map{|r| r.to_i}
return {} if result.empty? # that commit has no stats
{
'files' => resu... | ruby | {
"resource": ""
} |
q4662 | HoneyFormat.RowBuilder.build | train | def build(row)
build_row!(row)
rescue ArgumentError => e
raise unless e.message == 'struct size differs'
raise_invalid_row_length!(e, row)
end | ruby | {
"resource": ""
} |
q4663 | Mercurial.ConfigFile.find_header | train | def find_header(header)
{}.tap do |returning|
contents.scan(header_with_content_regexp(header)).flatten.first.split("\n").each do |setting|
name, value = *setting.split('=').map(&:strip)
returning[name] = value
end
end
end | ruby | {
"resource": ""
} |
q4664 | Mercurial.ConfigFile.find_setting | train | def find_setting(header, setting) #:nodoc:
return nil if contents.nil?
contents.scan(setting_regexp(header, setting)).flatten.first
end | ruby | {
"resource": ""
} |
q4665 | Mercurial.HookFactory.add | train | def add(name, value)
build(name, value).tap do |hook|
hook.save
end
end | ruby | {
"resource": ""
} |
q4666 | CouchRest.ExtendedDocument.create_without_callbacks | train | def create_without_callbacks(bulk =false)
raise ArgumentError, "a document requires a database to be created to (The document or the #{self.class} default database were not set)" unless database
set_unique_id if new? && self.respond_to?(:set_unique_id)
result = database.save_doc(self, bulk)
(res... | ruby | {
"resource": ""
} |
q4667 | Doorkeeper.AccessToken.save | train | def save(**options)
if use_refresh_token?
options[:ttl] = self.created_at + 6.months
else
options[:ttl] = self.created_at + self.expires_in + 30
end
super(**options)
end | ruby | {
"resource": ""
} |
q4668 | HoneyFormat.Row.to_csv | train | def to_csv(columns: nil)
attributes = members
attributes = columns & attributes if columns
row = attributes.map! { |column| to_csv_value(column) }
::CSV.generate_line(row)
end | ruby | {
"resource": ""
} |
q4669 | HoneyFormat.Row.inspect | train | def inspect
attributes = members.map do |field|
value = self[field]
value = "\"#{value}\"" if value.is_a?(String)
[field, value].join('=')
end.join(', ')
"#<Row #{attributes}>"
end | ruby | {
"resource": ""
} |
q4670 | HoneyFormat.Row.to_csv_value | train | def to_csv_value(column)
value = public_send(column)
return if value.nil?
return value.to_csv if value.respond_to?(:to_csv)
value.to_s
end | ruby | {
"resource": ""
} |
q4671 | Mercurial.FileIndex.update | train | def update(oldrev=nil, newrev=nil)
if index_file_exists? && oldrev != "0"*40
hg([
"log --debug -r ?:? --style ? >> ?",
oldrev, newrev, Style.file_index, path
])
else
hg(["log --debug -r : --style ? > ?", Style.file_index, path])
end
end | ruby | {
"resource": ""
} |
q4672 | Mercurial.FileIndex.commits_from | train | def commits_from(commit_sha)
raise UnsupportedRef if commit_sha.is_a? Array
read_if_needed
already = {}
final = []
left_to_do = [commit_sha]
while commit_sha = left_to_do.shift
next if already[commit_sha]
final << commit_sha
already[commit_sha] = true
... | ruby | {
"resource": ""
} |
q4673 | CouchRest.CastedModel.update_attributes_without_saving | train | def update_attributes_without_saving(hash)
hash.each do |k, v|
raise NoMethodError, "#{k}= method not available, use property :#{k}" unless self.respond_to?("#{k}=")
end
hash.each do |k, v|
self.send("#{k}=",v)
end
end | ruby | {
"resource": ""
} |
q4674 | OboParser.OboParser.term_hash | train | def term_hash
@terms.inject({}) {|sum, t| sum.update(t.name.value => t.id.value)}
end | ruby | {
"resource": ""
} |
q4675 | QuestionproRails.ResponseSet.answers | train | def answers
extracted_answers = []
unless self.qp_values.nil?
self.qp_values.each do |answer|
extracted_answers.push(ResponseAnswer.new(answer))
end
end
return extracted_answers
end | ruby | {
"resource": ""
} |
q4676 | ActsAsApprovable.Model.acts_as_approvable | train | def acts_as_approvable(options = {})
extend ClassMethods
include InstanceMethods
cattr_accessor :approvable_on
self.approvable_on = Array.wrap(options.delete(:on) { [:create, :update, :destroy] })
cattr_accessor :approvable_field
self.approvable_field = options.delete(:state_field)... | ruby | {
"resource": ""
} |
q4677 | Traject.HorizonReader.require_jars! | train | def require_jars!
require 'jruby'
# ask marc-marc4j gem to load the marc4j jars
MARC::MARC4J.new(:jardir => settings['marc4j_reader.jar_dir'])
# For some reason we seem to need to java_import it, and use
# a string like this. can't just refer to it by full
# qualified n... | ruby | {
"resource": ""
} |
q4678 | Traject.HorizonReader.convert_text! | train | def convert_text!(text, error_handler)
text = AnselToUnicode.new(error_handler, true).convert(text) if convert_marc8_to_utf8?
# Turn Horizon's weird escaping into UTF8: <U+nnnn> where nnnn is a hex unicode
# codepoint, turn it UTF8 for that codepoint
if settings["horizon.destination_encoding"] ... | ruby | {
"resource": ""
} |
q4679 | Traject.HorizonReader.fix_leader! | train | def fix_leader!(leader)
if leader.length < 24
# pad it to 24 bytes, leader is supposed to be 24 bytes
leader.replace( leader.ljust(24, ' ') )
elsif leader.length > 24
# Also a problem, slice it
leader.replace( leader.byteslice(0, 24))
end
# http://www.loc.gov/m... | ruby | {
"resource": ""
} |
q4680 | Smalltext.Classifier.softmax | train | def softmax(w)
e = Numo::NMath.exp(w - (w.max))
dist = e / (e.sum)
return dist
end | ruby | {
"resource": ""
} |
q4681 | Gitolite.Config.normalize_name | train | def normalize_name(context, constant = nil)
case context
when constant
context.name
when Symbol
context.to_s
else
context
end
end | ruby | {
"resource": ""
} |
q4682 | Cborb::Decoding.State.<< | train | def <<(cbor)
@buffer.write(cbor)
@decoding_fiber.resume
rescue FiberError => e
msg = e.message
# umm...
if msg.include?("dead")
raise Cborb::InvalidByteSequenceError
elsif msg.include?("threads")
raise Cborb::DecodingError, "Can't decode across threads"
el... | ruby | {
"resource": ""
} |
q4683 | Cborb::Decoding.State.consume | train | def consume(size)
data = @buffer.read(size).to_s
# If buffered data is not enought, yield fiber until new data will be buffered.
if data.size < size
@buffer.reset!
while data.size != size
Fiber.yield
data += @buffer.read(size - data.size)
end
end
... | ruby | {
"resource": ""
} |
q4684 | QuestionproRails.SurveyMeta.email_groups | train | def email_groups
extracted_groups = []
unless self.email_groups_list.nil?
self.email_groups_list.each do |email_group|
extracted_groups.push(EmailGroup.new(email_group))
end
end
return extracted_groups
end | ruby | {
"resource": ""
} |
q4685 | QuestionproRails.SurveyMeta.templates | train | def templates
extracted_templates = []
unless self.templates_list.nil?
self.templates_list.each do |template|
extracted_templates.push(Template.new(template))
end
end
return extracted_templates
end | ruby | {
"resource": ""
} |
q4686 | Stagehand.Production.matching | train | def matching(staging_record, table_name = nil)
table_name, id = Stagehand::Key.generate(staging_record, :table_name => table_name)
prepare_to_modify(table_name)
return Record.where(:id => id)
end | ruby | {
"resource": ""
} |
q4687 | Rydux.Store.subscribe | train | def subscribe(caller = nil, &block)
if block_given?
notify_when = block.call(state)
@listeners << { obj: block.binding.receiver, notify_when: notify_when }
else
@listeners << { obj: caller }
end
end | ruby | {
"resource": ""
} |
q4688 | Rydux.Store.strap_reducers | train | def strap_reducers(reducers)
reducers.each {|k, reducer| set_state *[k, reducer.map_state(type: nil)]}
reducers
end | ruby | {
"resource": ""
} |
q4689 | Silo.Repository.add | train | def add(path, prefix = nil)
path = File.expand_path path
prefix ||= '/'
in_work_tree File.dirname(path) do
index = @git.index
index.read_tree 'HEAD'
add = lambda do |f, p|
file = File.basename f
pre = (p == '/') ? file : File.join(p, file)
dir ... | ruby | {
"resource": ""
} |
q4690 | Silo.Repository.add_remote | train | def add_remote(name, url)
@remotes[name] = Remote::Git.new(self, name, url)
@remotes[name].add
end | ruby | {
"resource": ""
} |
q4691 | Silo.Repository.contents | train | def contents(path = nil)
contents = []
object = find_object(path || '/')
contents << path unless path.nil? || object.nil?
if object.is_a? Grit::Tree
(object.blobs + object.trees).each do |obj|
contents += contents(path.nil? ? obj.basename : File.join(path, obj.basename))
... | ruby | {
"resource": ""
} |
q4692 | Silo.Repository.git_remotes | train | def git_remotes
remotes = {}
@git.git.remote.split.each do |remote|
url = @git.git.config({}, '--get', "remote.#{remote}.url").strip
remotes[remote] = Remote::Git.new(self, remote, url)
end
remotes
end | ruby | {
"resource": ""
} |
q4693 | Silo.Repository.history | train | def history(path = nil)
params = ['--format=raw']
params += ['--', path] unless path.nil?
output = @git.git.log({}, *params)
Grit::Commit.list_from_string @git, output
end | ruby | {
"resource": ""
} |
q4694 | Silo.Repository.info | train | def info(path)
info = {}
object = object! path
info[:history] = history path
info[:mode] = object.mode
info[:name] = object.name
info[:path] = path
info[:sha] = object.id
info[:created] = info[:history].last.committed_date
info[:modified] = info[:h... | ruby | {
"resource": ""
} |
q4695 | Silo.Repository.prepare | train | def prepare
raise AlreadyPreparedError.new(@path) if prepared?
in_work_tree :tmp do
FileUtils.touch '.silo'
@git.add '.silo'
@git.commit_index 'Enabled Silo for this repository'
end
end | ruby | {
"resource": ""
} |
q4696 | Silo.Repository.purge | train | def purge(path, prune = true)
object = object! path
if object.is_a? Grit::Tree
(object.blobs + object.trees).each do |blob|
purge File.join(path, blob.basename), prune
end
else
params = ['-f', '--index-filter',
"git rm --cached --ignore-unmatch #{pat... | ruby | {
"resource": ""
} |
q4697 | Silo.Repository.remove | train | def remove(path)
object = object! path
path += '/' if object.is_a?(Grit::Tree) && path[-1].chr != '/'
index = @git.index
index.read_tree 'HEAD'
index.delete path
type = object.is_a?(Grit::Tree) ? 'directory' : 'file'
commit_msg = "Removed #{type} #{path}"
index.commit com... | ruby | {
"resource": ""
} |
q4698 | Silo.Repository.remove_remote | train | def remove_remote(name)
remote = @remotes[name]
raise UndefinedRemoteError.new(name) if remote.nil?
remote.remove
@remotes[name] = nil
end | ruby | {
"resource": ""
} |
q4699 | Silo.Repository.restore | train | def restore(path, prefix = '.')
object = object! path
prefix = File.expand_path prefix
FileUtils.mkdir_p prefix unless File.exists? prefix
file_path = File.join prefix, File.basename(path)
if object.is_a? Grit::Tree
FileUtils.mkdir file_path unless File.directory? file_path
... | ruby | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.