_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3
values | text stringlengths 66 10.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q5000 | Edgarj.EdgarjController.update | train | def update
upsert do
# NOTE:
# 1. update ++then++ valid to set new values in @record to draw form.
# 1. user_scoped may have joins so that record could be
# ActiveRecord::ReadOnlyRecord so that's why access again from
# model.
@record = model.find(user_scoped.find(params[:id]).id)
#upsert_files
if !@record.update_attributes(permitted_params(:update))
raise ActiveRecord::RecordInvalid.new(@record)
end
end
end | ruby | {
"resource": ""
} |
q5001 | Edgarj.EdgarjController.search_save | train | def search_save
SavedVcontext.save(current_user, nil,
params[:saved_page_info_name], page_info)
render :update do |page|
page << "Edgarj.SearchSavePopup.close();"
page.replace 'edgarj_load_condition_menu',
:partial=>'edgarj/load_condition_menu'
end
rescue ActiveRecord::ActiveRecordError
app_rescue
render :update do |page|
page.replace_html 'search_save_popup_flash_error', :text=>t('save_fail')
end
end | ruby | {
"resource": ""
} |
q5002 | Edgarj.EdgarjController.csv_download | train | def csv_download
filename = sprintf("%s-%s.csv",
model_name,
Time.now.strftime("%Y%m%d-%H%M%S"))
file = Tempfile.new(filename, Settings.edgarj.csv_dir)
csv_visitor = EdgarjHelper::CsvVisitor.new(view_context)
file.write CSV.generate_line(model.columns.map{|c| c.name})
for rec in user_scoped.where(page_info.record.conditions).
order(
page_info.order_by.blank? ?
nil :
page_info.order_by + ' ' + page_info.dir) do
array = []
for col in model.columns do
array << csv_visitor.visit_column(rec, col)
end
file.write CSV.generate_line(array)
end
file.close
File.chmod(Settings.edgarj.csv_permission, file.path)
send_file(file.path, {
type: 'text/csv',
filename: filename})
#file.close(true)
end | ruby | {
"resource": ""
} |
q5003 | Edgarj.EdgarjController.drawer_class | train | def drawer_class
@_drawer_cache ||=
if self.class == Edgarj::EdgarjController
Edgarj::Drawer::Normal
else
(self.class.name.gsub(/Controller$/, '').singularize +
'Drawer').constantize
end
end | ruby | {
"resource": ""
} |
q5004 | Edgarj.Search.column_type | train | def column_type(col_name)
cache = Cache.instance
cache.klass_hash[@_klass_str] ||= {}
if v = cache.klass_hash[@_klass_str][col_name.to_s]
cache.hit += 1
v
else
cache.miss += 1
col = @_klass_str.constantize.columns.find{|c|
c.name == col_name.to_s
}
if col
cache.klass_hash[@_klass_str][col_name.to_s] = col.type
end
end
end | ruby | {
"resource": ""
} |
q5005 | ActiveRepository.Writers.create | train | def create(attributes={})
attributes = attributes.symbolize_keys if attributes.respond_to?(:symbolize_keys)
object = self.new(attributes)
if object.present? && object.valid?
if persistence_class == self
object.id = nil unless exists?(object.id)
object.save
else
object = PersistenceAdapter.create(self, object.attributes)
end
end
new_object = serialize!(object.reload.attributes)
new_object.valid?
new_object
end | ruby | {
"resource": ""
} |
q5006 | Tableau.TableBuilder.to_html | train | def to_html
time_header, rows = '<th></th>', Array.new
end_time = Time.new(2013, 1, 1, 21, 0, 0)
# make the time row
@time = Time.new(2013, 1, 1, 9, 0, 0)
while @time < end_time
time_header += "<th>#{@time.strftime("%-k:%M")}</th>"
@time += 900
end
#make each day row
(0..4).each do |day|
classes = @timetable.classes_for_day(day)
rows << day_row(day, classes)
end
rows_str, id_str = '', "id=\"#{@timetable.name}\""
rows.each{ |r| rows_str += "<tr class=\"day\">\n#{r}\n</tr>\n" }
%Q{
<!DOCTYPE html>
<html>
<head>
<title>#{@timetable.name || 'Timetable' } - Timetablr.co</title>
<style>#{build_css}</style>
</head>
<body>
<h3>#{@timetable.name}</h3>
<table #{id_str if @timetable.name}>
<tr id="time">#{time_header}</tr>
#{rows_str}
</table>
</body>
</html>
}
end | ruby | {
"resource": ""
} |
q5007 | Kuniri.Setting.read_configuration_file | train | def read_configuration_file(pPath = '.kuniri.yml')
if !(File.exist?(pPath))
set_default_configuration
else
safeInfo = SafeYAML.load(File.read(pPath))
# SafeYAML add collon (':') in the begin of each key. We handle it here
@configurationInfo = safeInfo.map do |key, value|
[key.tr(':', '').to_sym, value]
end.to_h
verify_syntax
end
return @configurationInfo
end | ruby | {
"resource": ""
} |
q5008 | Pagify.BasicPager.page | train | def page page
if page_exists?(page)
return BasicPage.new(self, normalize_page(page))
else
if null_page
return null_page_instance
else
return nil
end
end
end | ruby | {
"resource": ""
} |
q5009 | NewsScraper.Scraper.scrape | train | def scrape
article_urls = Extractors::GoogleNewsRss.new(query: @query).extract
transformed_articles = []
article_urls.each do |article_url|
payload = Extractors::Article.new(url: article_url).extract
article_transformer = Transformers::Article.new(url: article_url, payload: payload)
begin
transformed_article = article_transformer.transform
transformed_articles << transformed_article
yield transformed_article if block_given?
rescue Transformers::ScrapePatternNotDefined => e
raise e unless block_given?
yield e
end
end
transformed_articles
end | ruby | {
"resource": ""
} |
q5010 | NewsScraper.Trainer.train | train | def train(query: '')
article_urls = Extractors::GoogleNewsRss.new(query: query).extract
article_urls.each do |url|
Trainer::UrlTrainer.new(url).train
end
end | ruby | {
"resource": ""
} |
q5011 | JsonRecord.Schema.key | train | def key (name, *args)
options = args.extract_options!
name = name.to_s
json_type = args.first || String
raise ArgumentError.new("too many arguments (must be 1 or 2 plus an options hash)") if args.length > 1
field = FieldDefinition.new(name, :type => json_type, :default => options[:default])
fields[name] = field
add_json_validations(field, options)
define_json_accessor(field, json_field_name)
end | ruby | {
"resource": ""
} |
q5012 | JsonRecord.Schema.many | train | def many (name, *args)
name = name.to_s
options = args.extract_options!
type = args.first || name.singularize.classify.constantize
field = FieldDefinition.new(name, :type => type, :multivalued => true)
fields[name] = field
add_json_validations(field, options)
define_many_json_accessor(field, json_field_name)
end | ruby | {
"resource": ""
} |
q5013 | Tableau.ClassArray.classes_for_day | train | def classes_for_day(day)
days_classes = ClassArray.new
self.each { |c| days_classes << c if c.day == day }
days_classes.count > 0 ? days_classes : nil
end | ruby | {
"resource": ""
} |
q5014 | Tableau.ClassArray.earliest_class | train | def earliest_class
earliest = self.first
self.each { |c| earliest = c if c.time < earliest.time }
earliest
end | ruby | {
"resource": ""
} |
q5015 | Todoist.Task.save | train | def save
opts = {}
opts['priority'] = priority if priority
opts['date_string'] = date if date
# if we don't have an id, then we can assume this is a new task.
unless (task_details.has_key?('id'))
result = self.class.create(self.content, self.project_id, opts)
else
result = self.class.update(self.content, self.id, opts)
end
self.content = result.content
self.project_id = result.project_id
self.task_details = result.task_details
self
end | ruby | {
"resource": ""
} |
q5016 | Ldaptic.AttributeSet.replace | train | def replace(*attributes)
attributes = safe_array(attributes)
user_modification_guard
seen = {}
filtered = []
attributes.each do |value|
matchable = matchable(value)
unless seen[matchable]
filtered << value
seen[matchable] = true
end
end
@target.replace(filtered)
self
end | ruby | {
"resource": ""
} |
q5017 | Edgarj.SearchForm.method_missing | train | def method_missing(method_name, *args)
if method_name.to_s =~ /^(.*)=$/
@attrs[$1.to_sym] = args[0]
else
val = @attrs[method_name.to_sym]
case column_type(method_name)
when :integer
if val =~ /^\d+$/
val.to_i
else
val
end
else
val
end
end
end | ruby | {
"resource": ""
} |
q5018 | LibWebSocket.URL.parse | train | def parse(string)
return nil unless string.is_a?(String)
uri = Addressable::URI.parse(string)
scheme = uri.scheme
return nil unless scheme
self.secure = true if scheme.match(/ss\Z/m)
host = uri.host
host = '/' unless host && host != ''
self.host = host
self.port = uri.port.to_s if uri.port
request_uri = uri.path
request_uri = '/' unless request_uri && request_uri != ''
request_uri += "?" + uri.query if uri.query
self.resource_name = request_uri
return self
end | ruby | {
"resource": ""
} |
q5019 | LibWebSocket.URL.to_s | train | def to_s
string = ''
string += 'ws'
string += 's' if self.secure
string += '://'
string += self.host
string += ':' + self.port.to_s if self.port
string += self.resource_name || '/'
return string
end | ruby | {
"resource": ""
} |
q5020 | Loggr.Adapter.logger | train | def logger(name, options = {}, &block)
use_adapter = options.key?(:adapter) ? get_adapter(options.delete(:adapter)) : self.adapter
use_adapter.logger(name, options).tap do |logger|
yield(logger) if block_given?
end
end | ruby | {
"resource": ""
} |
q5021 | Loggr.Adapter.get_adapter | train | def get_adapter(adp)
# okay, this is only because we can't camelize it :)
adp = Loggr::Adapter::NOP if !adp
# Code adapter from ActiveSupport::Inflector#camelize
# https://github.com/rails/rails/blob/v3.0.9/activesupport/lib/active_support/inflector/methods.rb#L30
adp = adp.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase } if adp.is_a?(Symbol)
clazz = adp
if adp.respond_to?(:to_str)
const = begin Loggr::Adapter.const_get(adp.to_s) rescue begin Loggr::Adapter.const_get(adp.to_s.upcase) rescue nil end end
unless const
# code adapter from ActiveSupport::Inflector#constantize
# https://github.com/rails/rails/blob/v3.0.9/activesupport/lib/active_support/inflector/methods.rb#L107
names = adp.to_s.split('::')
names.shift if names.empty? || names.first.empty?
const = ::Object
names.each { |n| const = const.const_get(n) }
end
clazz = const
end
raise "#{clazz}: an adapter must implement #logger and #mdc" unless clazz.respond_to?(:logger) && clazz.respond_to?(:mdc)
clazz
end | ruby | {
"resource": ""
} |
q5022 | XmlFu.Node.name_parse_special_characters | train | def name_parse_special_characters(val)
use_this = val.dup
# Ensure that we don't have special characters at end of name
while ["!","/","*"].include?(use_this.to_s[-1,1]) do
# Will this node contain escaped XML?
if use_this.to_s[-1,1] == '!'
@escape_xml = false
use_this.chop!
end
# Will this be a self closing node?
if use_this.to_s[-1,1] == '/'
@self_closing = true
use_this.chop!
end
# Will this node contain a collection of sibling nodes?
if use_this.to_s[-1,1] == '*'
@content_type = "collection"
use_this.chop!
end
end
return use_this
end | ruby | {
"resource": ""
} |
q5023 | XmlFu.Node.value= | train | def value=(val)
case val
when ::String then @value = val.to_s
when ::Hash then @value = val
when ::Array then @value = val
when ::OpenStruct then @value = val
when ::DateTime then @value = val.strftime XS_DATETIME_FORMAT
when ::Time then @value = val.strftime XS_DATETIME_FORMAT
when ::Date then @value = val.strftime XS_DATETIME_FORMAT
else
if val.respond_to?(:to_datetime)
@value = val.to_datetime
elsif val.respond_to?(:call)
@value = val.call
elsif val.nil?
@value = nil
else
@value = val.to_s
end
end
rescue => e
@value = val.to_s
end | ruby | {
"resource": ""
} |
q5024 | Languages.RubySyntax.handle_semicolon | train | def handle_semicolon(pLine)
commentLine = []
if pLine =~ /^=begin(.*?)/
@flagMultipleLineComment = true
elsif pLine =~ /^=end/
@flagMultipleLineComment = false
end
unless @flagMultipleLineComment == true || pLine =~ /#(.*)/
return pLine.split(/;/)
end
commentLine << pLine
end | ruby | {
"resource": ""
} |
q5025 | Ldaptic.DN.find | train | def find(source = @source)
scope = 0
filter = "(objectClass=*)"
if source.respond_to?(:search2_ext)
source.search2(
to_s,
scope,
filter
)
elsif source.respond_to?(:search)
Array(source.search(
:base => to_s,
:scope => scope,
:filter => filter,
:limit => 1
))
else
raise RuntimeError, "missing or invalid source for LDAP search", caller
end.first
end | ruby | {
"resource": ""
} |
q5026 | Ldaptic.DN.domain | train | def domain
components = rdns.map {|rdn| rdn[:dc]}.compact
components.join('.') unless components.empty?
end | ruby | {
"resource": ""
} |
q5027 | Jnlp.Jnlp.generate_local_jnlp | train | def generate_local_jnlp(options={})
#
# get a copy of the existing jnlp
# (it should be easier than this)
#
@local_jnlp = Nokogiri::XML(@jnlp.to_s)
#
# we'll be working with the Hpricot root element
#
jnlp_elem = (@local_jnlp/"jnlp").first
#
# set the new codebase
#
jnlp_elem[:codebase] = "file:#{@local_cache_dir}"
#
# set the new href
#
jnlp_elem[:href] = @local_jnlp_href
#
# for each jar and nativelib remove the version
# attribute and point the href to the local cache
#
@jars.each do |jar|
j = @local_jnlp.at("//jar[@href=#{jar.href}]")
j.remove_attribute(:version)
if options[:include_pack_gz]
j[:href] = jar.relative_local_path_pack_gz
else
j[:href] = jar.relative_local_path
end
end
@nativelibs.each do |nativelib|
nl = @local_jnlp.at("//nativelib[@href=#{nativelib.href}]")
nl.remove_attribute(:version)
if options[:include_pack_gz]
nl[:href] = nativelib.relative_local_path_pack_gz
else
nl[:href] = nativelib.relative_local_path
end
end
end | ruby | {
"resource": ""
} |
q5028 | Jnlp.Jnlp.resource_paths | train | def resource_paths(options={})
if options[:include_pack_gs]
cp_jars = @jars.empty? ? [] : @jars.collect {|j| j.local_path_pack_gz}
cp_nativelibs = @nativelibs.empty? ? [] : @nativelibs.collect {|n| n.local_path_pack_gz}
resources = cp_jars + cp_nativelibs
else
cp_jars = @jars.empty? ? [] : @jars.collect {|j| j.local_path}
cp_nativelibs = @nativelibs.empty? ? [] : @nativelibs.collect {|n| n.local_path}
resources = cp_jars + cp_nativelibs
end
#
# FIXME: this should probably be more discriminatory
#
if options[:remove_jruby]
resources = resources.reject {|r| r =~ /\/jruby\//}
end
resources
end | ruby | {
"resource": ""
} |
q5029 | Jnlp.Jnlp.write_local_classpath_shell_script | train | def write_local_classpath_shell_script(filename="#{@name[/[A-Za-z0-9_-]*/]}_classpath.sh", options={})
script = "export CLASSPATH=$CLASSPATH#{local_classpath(options)}"
File.open(filename, 'w'){|f| f.write script}
end | ruby | {
"resource": ""
} |
q5030 | Jnlp.Jnlp.write_jnlp | train | def write_jnlp(options={})
dir = options[:dir] || '.'
path = options[:path] || @path.gsub(/^\//, '')
Dir.chdir(dir) do
FileUtils.mkdir_p(File.dirname(path))
File.open(path, 'w') {|f| f.write to_jnlp(options[:jnlp]) }
if options[:snapshot]
snapshot_path = "#{File.dirname(path)}/#{@family}.jnlp"
File.open(snapshot_path, 'w') {|f| f.write to_jnlp(options[:jnlp]) }
current_version_path = "#{File.dirname(path)}/#{@family}-CURRENT_VERSION.txt"
File.open(current_version_path, 'w') {|f| f.write @version_str }
end
end
end | ruby | {
"resource": ""
} |
q5031 | Jnlp.Jnlp.write_local_jnlp | train | def write_local_jnlp(filename=@local_jnlp_name)
destination = File.expand_path(filename)
unless @local_jnlp_href == destination
@local_jnlp_href = destination
@local_jnlp_name = File.basename(destination)
self.generate_local_jnlp
end
File.open(filename, 'w') {|f| f.write to_local_jnlp }
end | ruby | {
"resource": ""
} |
q5032 | Jnlp.Jnlp.require_resources | train | def require_resources
if RUBY_PLATFORM =~ /java/
resource_paths(:remove_jruby => true).each {|res| require res}
true
else
false
end
end | ruby | {
"resource": ""
} |
q5033 | UnobtrusiveDatePicker.UnobtrusiveDatePickerHelper.unobtrusive_date_text_picker_tag | train | def unobtrusive_date_text_picker_tag(name, date = Date.current, options = {}, html_options = {})
date ||= Date.current
options = merge_defaults_for_text_picker(options)
DateTimePickerSelector.new(date, options, html_options).text_date_picker(name)
end | ruby | {
"resource": ""
} |
q5034 | Jnlp.Resource.update_cache | train | def update_cache(source=@url, destination=@local_path, options={})
unless destination
raise ArgumentError, "Must specify destination directory when updatng resource", caller
end
file_exists = File.exists?(destination)
if file_exists && @signature_verified == nil
verify_signature
end
unless file_exists && @signature_verified
FileUtils.mkdir_p(File.dirname(destination))
puts "reading: #{source}" if options[:verbose]
tried_to_read = 0
begin
jarfile = open(source)
rescue OpenURI::HTTPError => e
puts e
if tried_to_read < 1
tried_to_read += 1
retry
end
end
if jarfile.class == Tempfile
FileUtils.cp(jarfile.path, destination)
puts "copying to: #{destination}" if options[:verbose]
else
File.open(destination, 'w') {|f| f.write jarfile.read }
puts "writing to: #{destination}" if options[:verbose]
end
puts "#{jarfile.size} bytes written" if options[:verbose]
verify_signature ? jarfile.size : false
else
File.size(destination)
end
end | ruby | {
"resource": ""
} |
q5035 | Jnlp.Resource.verify_signature | train | def verify_signature
if @local_path
if RUBY_PLATFORM =~ /java/
begin
jarfile = java.util.jar.JarInputStream.new(FileInputStream.new(@local_path), true)
@signature_verified = true
rescue NativeException
@signature_verified = false
end
else
# Use IO.popen instead of system() to absorb
# jarsigners messages to $stdout
response = IO.popen("jarsigner -verify #{@local_path}"){|io| io.gets}
@signature_verified = ($?.exitstatus == 0)
end
else
nil
end
end | ruby | {
"resource": ""
} |
q5036 | Edgarj.AssocHelper.draw_belongs_to_clear_link | train | def draw_belongs_to_clear_link(f, col_name, popup_field, parent_name, default_label)
if Settings.edgarj.belongs_to.disable_clear_link
f.hidden_field(col_name)
else
(' ' +
link_to("[#{I18n.t('edgarj.default.clear')}]", '#',
onClick: "Edgarj.Popup.clear('#{j(popup_field.id_target)}','#{j(default_label)}'); return false;",
id: popup_field.clear_link,
style: 'display:' + (parent_name.blank? ? 'none' : '')) +
f.hidden_field(col_name)).html_safe
end
end | ruby | {
"resource": ""
} |
q5037 | Edgarj.AssocHelper.draw_belongs_to_field | train | def draw_belongs_to_field(f, popup_path, col_name, model = f.object.class)
col = model.columns.detect{|c| c.name == col_name.to_s}
return "no column found" if !col
parent_model = model.belongs_to_AR(col)
return "parent_model is nil" if !parent_model
parent_obj = f.object.belongs_to_AR(col)
popup_field = Edgarj::PopupHelper::PopupField.new_builder(
f.object_name, col_name)
default_label = '[' + draw_belongs_to_label_sub(model, col.name, parent_model) + ']'
label = content_tag(:span,
parent_obj ? parent_obj.name : default_label.html_safe,
id: popup_field.label_target)
link_tag = Settings.edgarj.belongs_to.link_tag.html_safe
if parent_obj
if Settings.edgarj.belongs_to.popup_on == 'field'
link_to(
label + link_tag,
popup_path,
remote: true)
else
link_to(label,
# TODO: Hardcoded 'master' prefix should be fixed
controller: url_prefix + parent_obj.class.name.underscore.pluralize,
action: 'show',
id: parent_obj,
topic_path: 'add')
end
else
if Settings.edgarj.belongs_to.popup_on == 'field'
link_to(
label + link_tag,
popup_path,
remote: true)
else
label
end
end +
draw_belongs_to_clear_link(f, col.name, popup_field,
parent_obj && parent_obj.name,
default_label)
end | ruby | {
"resource": ""
} |
q5038 | Edgarj.AssocHelper.flag_on? | train | def flag_on?(column_value, bitset, flag)
val = column_value || 0
(val & bitset.const_get(flag)) != 0
end | ruby | {
"resource": ""
} |
q5039 | Edgarj.AssocHelper.get_bitset | train | def get_bitset(model, col)
bitset_name = col.name.camelize + 'Bitset'
if model.const_defined?(bitset_name, false)
_module = model.const_get(bitset_name)
_module.is_a?(Module) ? _module : nil
else
nil
end
end | ruby | {
"resource": ""
} |
q5040 | Edgarj.AssocHelper.draw_column_bitset | train | def draw_column_bitset(rec, col_or_sym, bitset)
turn_on_flags = []
value = rec.send(get_column_name(col_or_sym))
for flag in bitset.constants do
turn_on_flags << flag if flag_on?(value, bitset, flag)
end
turn_on_flags.map{|f| rec.class.human_const_name(bitset, f) }.join(' ')
end | ruby | {
"resource": ""
} |
q5041 | Edgarj.AssocHelper.draw_column_enum | train | def draw_column_enum(rec, col_or_sym, enum)
Edgarj::EnumCache.instance.label(rec, get_column_name(col_or_sym), enum)
end | ruby | {
"resource": ""
} |
q5042 | Edgarj.AssocHelper.adrs_str_sub | train | def adrs_str_sub(model, prefix, element)
e = model.send(prefix + element)
e.blank? ? '' : e
end | ruby | {
"resource": ""
} |
q5043 | Edgarj.AssocHelper.adrs_str | train | def adrs_str(model, adrs_prefix)
result = ''
for adrs_element in ['prefecture', 'city', 'other', 'bldg'] do
result << adrs_str_sub(model, adrs_prefix, adrs_element)
end
result
end | ruby | {
"resource": ""
} |
q5044 | Edgarj.AssocHelper.permitted? | train | def permitted?(requested_flags = 0)
current_user_roles.any?{|ug| ug.admin?} ||
current_model_permissions.any?{|cp| cp.permitted?(requested_flags)}
end | ruby | {
"resource": ""
} |
q5045 | Serializer.ClassMethods.has_serialized | train | def has_serialized(name, &block)
serialize name, Hash
initializer = Serializer::Initializer.new
block.call(initializer)
initializer.each do |method, options|
define_method "#{method}" do
hash = send(name)
result = hash[method.to_sym] if hash
if hash.nil? or result.nil?
send("#{name}=", {}) unless send(name)
hash = send(name)
result = options[:default]
result = result.clone if result.duplicable?
hash[method.to_sym] = result
end
return result
end
define_method "#{method}?" do
hash = send(name)
result = hash[method.to_sym] if hash
if hash.nil? or result.nil?
send("#{name}=", {}) unless send(name)
hash = send(name)
result = options[:default]
result = result.clone if result.duplicable?
hash[method.to_sym] = result
end
return result
end
define_method "#{method}=" do |value|
original = send(name) || {}
if options[:type] and value
case options[:type].to_sym
when :float then value = value.to_f if value.respond_to? :to_f
when :integer then value = value.to_i if value.respond_to? :to_i
when :string then value = value.to_str if value.respond_to? :to_str
when :symbol then value = value.to_sym if value.respond_to? :to_sym
when :boolean then
value = true if value.eql? "true"
value = false if value.eql? "false"
value = !value.to_i.zero? if value.respond_to? :to_i
end
end
modified = original.clone
modified[method.to_sym] = value
send("#{name}_will_change!") unless modified.eql?(original)
send("#{name}=", modified)
end
end
end | ruby | {
"resource": ""
} |
q5046 | Tableau.BaseParser.parse_table | train | def parse_table(table_rows)
classes = Tableau::ClassArray.new
@day = 0
# delete the time header row
table_rows.delete(table_rows.first)
table_rows.each do |row|
@time = Time.new(2013, 1, 1, 9, 0, 0)
# drop the 'Day' cell from the row
row_items = row.xpath('td')
row_items.delete(row_items.first)
row_items.each do |cell|
if cell.attribute('colspan')
intervals = cell.attribute('colspan').value
classes << create_class(cell)
else intervals = 1
end
inc_time(intervals)
end
@day += 1
end
classes
end | ruby | {
"resource": ""
} |
q5047 | Tableau.BaseParser.create_class | train | def create_class(class_element)
begin
tt_class = Tableau::Class.new(@day, @time)
data = class_element.xpath('table/tr/td//text()')
raise "Misformed cell for #{module_id}" if data.count < 4
rescue Exception => e
p "EXCEPTION: #{e.message}", "Data Parsed:", data
return nil
end
# If the weeks are in the 2nd index, it's a core timetable
if @@WEEKS_REGEX.match(data[1].text())
tt_class.code = data[0].text().match(/^[A-Za-z0-9\-]+/).to_s
tt_class.type = data[0].text().gsub(tt_class.code, '').gsub('/', '')
tt_class.weeks = create_class_weeks(data[1].text())
tt_class.location = data[2].text()
tt_class.name = data[3].text()
else # this is a module timetable, laid out differently
if data[0].to_s != ""
tt_class.code = data[0].text().match(/^[A-Za-z0-9\-]+/).to_s
tt_class.type = data[0].text().gsub(tt_class.code, '').gsub('/', '')
end
tt_class.location = data[1].text()
tt_class.name = data[2].text()
tt_class.weeks = create_class_weeks(data[3].text())
end
# Same attribute on both timetables, DRY'd here
tt_class.tutor = data[4] ? data[4].text() : nil
if intervals = class_element.attribute('colspan').value
tt_class.intervals = intervals.to_i
end
tt_class
end | ruby | {
"resource": ""
} |
q5048 | Tableau.BaseParser.create_class_weeks | train | def create_class_weeks(week_data)
week_span_regex = /([\d]{2}-[\d]{2})/
week_start_regex = /^[0-9]{2}/
week_end_regex = /[0-9]{2}$/
week_single_regex = /[\d]{2}/
class_weeks = Array.new
week_data.scan(@@WEEKS_REGEX).each do |weekspan|
# if it's a 28-39 week span
if weekspan =~ week_span_regex
start = week_start_regex.match(weekspan)[0].to_i
finish = week_end_regex.match(weekspan)[0].to_i
while start <= finish
class_weeks << start
start += 1
end
# some single week (30, 31, 32 etc) support
elsif weekspan =~ week_single_regex
class_weeks << week_single_regex.match(weekspan)[0].to_i
end
end
class_weeks
end | ruby | {
"resource": ""
} |
q5049 | Parser.OutputFormat.create_all_data | train | def create_all_data(pParser)
return nil unless pParser
wrapper = self
# Go through each file
pParser.fileLanguage.each do |listOfFile|
# Inspect each element
listOfFile.fileElements.each do |singleElement|
@outputEngine.kuniri do
wrapper.handle_element(singleElement)
end
currentFilePathAndName = singleElement.name
write_file(currentFilePathAndName)
@outputEngine.reset_engine
end
end
end | ruby | {
"resource": ""
} |
q5050 | Jinda.Helpers.markdown | train | def markdown(text)
erbified = ERB.new(text.html_safe).result(binding)
red = Redcarpet::Markdown.new(Redcarpet::Render::HTML, :autolink => true, :space_after_headers => true)
red.render(erbified).html_safe
end | ruby | {
"resource": ""
} |
q5051 | Jinda.Helpers.gen_views | train | def gen_views
t = ["*** generate ui ***"]
# create array of files to be tested
$afile = Array.new
Jinda::Module.all.each do |m|
m.services.each do |s|
dir ="app/views/#{s.module.code}"
unless gen_view_file_exist?(dir)
gen_view_mkdir(dir,t)
end
if s.code=='link'
f= "app/views/#{s.module.code}/index.haml"
$afile << f
unless gen_view_file_exist?(f)
sv = "app/jinda/template/linkview.haml"
f= "app/views/#{s.module.code}/index.haml"
gen_view_createfile(sv,f,t)
end
next
end
dir ="app/views/#{s.module.code}/#{s.code}"
unless gen_view_file_exist?(dir)
gen_view_mkdir(dir,t)
end
xml= REXML::Document.new(s.xml)
xml.elements.each('*/node') do |activity|
icon = activity.elements['icon']
next unless icon
action= freemind2action(icon.attributes['BUILTIN'])
next unless ui_action?(action)
code_name = activity.attributes["TEXT"].to_s
next if code_name.comment?
code= name2code(code_name)
if action=="pdf"
f= "app/views/#{s.module.code}/#{s.code}/#{code}.pdf.prawn"
else
f= "app/views/#{s.module.code}/#{s.code}/#{code}.html.erb"
end
$afile << f
unless gen_view_file_exist?(f)
sv = "app/jinda/template/view.html.erb"
gen_view_createfile(sv,f,t)
end
end
end
end
puts $afile.join("\n")
puts t.join("\n")
return $afile
end | ruby | {
"resource": ""
} |
q5052 | ROF.Utility.decode_work_type | train | def decode_work_type(obj)
if obj['type'] =~ WORK_TYPE_WITH_PREFIX_PATTERN
return 'GenericWork' if Regexp.last_match(2).nil?
Regexp.last_match(2)
else
# this will return nil if key t does not exist
work_type = obj['type'].downcase
WORK_TYPES[work_type]
end
end | ruby | {
"resource": ""
} |
q5053 | Jnlp.Otrunk.run_local | train | def run_local(argument=@argument, main_class='net.sf.sail.emf.launch.EMFLauncher2')
if RUBY_PLATFORM =~ /java/
java.lang.Thread.currentThread.setContextClassLoader(JRuby.runtime.jruby_class_loader)
require_resources
configUrl = URL.new(JavaIO::File.new("dummy.txt").toURL, argument)
# configUrl = URL.new("document-edit.config")
unless @bundleManager
@bundleManager = SailCoreBundle::BundleManager.new
@serviceContext = @bundleManager.getServiceContext
@bundleManager.setContextURL(configUrl)
#
# Add the <code>bundles</code> configured in this bundles xml file. The format of the file
# is XMLEncoder
#
@bundleManager.addBundles(configUrl.openStream)
#
# Have all the bundles register their services, and then do any linking
# to other registered services
#
@bundleManager.initializeBundles
#
# Start the session manager
#
@manager = @serviceContext.getService(SailCoreService::SessionManager.java_class)
end
@manager.start(@serviceContext)
else
command = "java -classpath #{local_classpath} #{main_class} '#{argument}'"
$pid = fork { exec command }
end
end | ruby | {
"resource": ""
} |
q5054 | PutQR.QRCode.render_image_iterm2 | train | def render_image_iterm2
return nil unless valid?
# References:
# https://iterm2.com/documentation-images.html
# https://iterm2.com/utilities/imgcat
# tmux requires some extra work for unrecognised escape code sequences
screen = ENV['TERM'].start_with? 'screen'
prefix = screen ? "\ePtmux;\e\e]" : "\e]"
suffix = screen ? "\a\e\\" : "\a"
png = qrcode.as_png(size: 600)
png_base64 = Base64.encode64(png.to_s).chomp
options = 'inline=1'
"#{prefix}1337;File=#{options}:#{png_base64}#{suffix}"
end | ruby | {
"resource": ""
} |
q5055 | Tableau.Timetable.remove_class | train | def remove_class(rem_class)
@modules.each do |m|
if m.name == rem_class.name
m.classes.delete(rem_class)
break
end
end
end | ruby | {
"resource": ""
} |
q5056 | Tableau.Timetable.classes_for_day | train | def classes_for_day(day)
classes = Tableau::ClassArray.new
@modules.each do |mod|
cfd = mod.classes_for_day(day)
cfd.each { |cl| classes << cl } if cfd
end
classes.count > 0 ? classes : nil
end | ruby | {
"resource": ""
} |
q5057 | Tableau.Timetable.class_for_time | train | def class_for_time(day, time)
cfd = self.classes_for_day(day)
cfd.each { |c| return c if c.time == time }
nil
end | ruby | {
"resource": ""
} |
q5058 | Tableau.Timetable.earliest_class | train | def earliest_class
earliest_classes = Tableau::ClassArray.new
@modules.each { |m| earliest_classes << m.earliest_class }
earliest = earliest_classes.first
earliest_classes.each { |c| earliest = c if c.time < earliest.time }
earliest
end | ruby | {
"resource": ""
} |
q5059 | Tableau.Timetable.conflicts | train | def conflicts
conflicts = Tableau::ClassArray.new
(0..4).each do |day|
days_classes = self.classes_for_day(day)
next if !days_classes || days_classes.count == 0
# get the last element index
last = days_classes.count - 1
for i in 0..last
i_c = days_classes[i]
time_range = i_c.time..(i_c.time + 3600 * i_c.duration)
for j in (i+1)..last
if time_range.cover?(days_classes[j].time)
conflicts << [days_classes[i], days_classes[j]]
end
end
end
end
conflicts # return the conflicts
end | ruby | {
"resource": ""
} |
q5060 | Chatterbox::ExceptionNotification.Presenter.render_hash | train | def render_hash(hsh)
str = ""
indiff_hsh = hsh.with_indifferent_access
indiff_hsh.keys.sort.each do |key|
str << "#{key}: "
value = indiff_hsh[key]
PP::pp(value, str)
end
str
end | ruby | {
"resource": ""
} |
q5061 | GV.Component.html | train | def html(string)
ptr = Libcgraph.agstrdup_html(graph.ptr, string)
string = ptr.read_string
Libcgraph.agstrfree graph.ptr, ptr
string
end | ruby | {
"resource": ""
} |
q5062 | GV.BaseGraph.edge | train | def edge(name, tail, head, attrs = {})
component Edge, [name, tail, head], attrs
end | ruby | {
"resource": ""
} |
q5063 | GV.BaseGraph.sub_graph | train | def sub_graph(name, attrs = {})
graph = component SubGraph, [name], attrs
yield graph if block_given?
graph
end | ruby | {
"resource": ""
} |
q5064 | GV.Graph.save | train | def save(filename, format = 'png', layout = 'dot')
Libgvc.gvLayout(@@gvc, ptr, layout.to_s)
Libgvc.gvRenderFilename(@@gvc, ptr, format.to_s, filename);
Libgvc.gvFreeLayout(@@gvc, ptr)
nil
end | ruby | {
"resource": ""
} |
q5065 | GV.Graph.render | train | def render(format = 'png', layout = 'dot')
Libgvc.gvLayout(@@gvc, ptr, layout.to_s)
data_ptr = FFI::MemoryPointer.new(:pointer, 1)
len_ptr = FFI::MemoryPointer.new(:int, 1)
Libgvc.gvRenderData(@@gvc, ptr, format.to_s, data_ptr, len_ptr)
len = len_ptr.read_uint
data_ptr = data_ptr.read_pointer
data = data_ptr.read_string len
Libgvc.gvFreeRenderData(data_ptr)
Libgvc.gvFreeLayout(@@gvc, ptr)
data
end | ruby | {
"resource": ""
} |
q5066 | Languages.VariableBehaviourHelpers.setup_variable_behaviour | train | def setup_variable_behaviour
expression = MODULEBASE + type_of_language + VARIABLECLASS +
type_of_language
begin
clazz = Object.const_get(expression)
@variableBehaviour = clazz.new(who_am_i)
rescue NameError
Util::LoggerKuniri.error('Class name error')
end
end | ruby | {
"resource": ""
} |
q5067 | Languages.{LANG}.analyse_source | train | def analyse_source(pPath)
@name = File.basename(pPath, ".*")
@path = File.dirname(pPath)
analyse_first_step(pPath)
analyse_second_step
end | ruby | {
"resource": ""
} |
q5068 | Parser.Parser.start_parser | train | def start_parser
if (@filesPath.empty?)
raise Error::ConfigurationFileError,
"Source path not have #{@language} files."
end
@filesPath.each do |file|
language = @factory.get_language(@language)
fileElement = Languages::FileElementData.new(file)
source = File.open(file, 'rb')
language.analyse_source(fileElement, source)
@fileLanguage.push(language)
end
end | ruby | {
"resource": ""
} |
q5069 | PaynetEasy::PaynetEasyApi::Callback.CallbackFactory.callback | train | def callback(callback_type)
callback_class = "#{callback_type.camelize}Callback"
callback_file = "callback/#{callback_type}_callback"
begin
instantiate_callback callback_file, callback_class, callback_type
rescue LoadError => error
if @@allowed_payneteasy_callback_types.include? callback_type
instantiate_callback 'callback/paynet_easy_callback', 'PaynetEasyCallback', callback_type
else
raise error
end
end
end | ruby | {
"resource": ""
} |
q5070 | PaynetEasy::PaynetEasyApi::Callback.CallbackFactory.instantiate_callback | train | def instantiate_callback(callback_file, callback_class, callback_type)
require callback_file
PaynetEasy::PaynetEasyApi::Callback.const_get(callback_class).new(callback_type)
end | ruby | {
"resource": ""
} |
q5071 | SQLTree::Node.Base.equal_children? | train | def equal_children?(other)
self.class.children.all? { |child| send(child) == other.send(child) }
end | ruby | {
"resource": ""
} |
q5072 | SQLTree::Node.Base.equal_leafs? | train | def equal_leafs?(other)
self.class.leafs.all? { |leaf| send(leaf) == other.send(leaf) }
end | ruby | {
"resource": ""
} |
q5073 | RSpec.Benchmark.benchmark | train | def benchmark(times = 1, &block)
elapsed = (1..times).collect do
GC.start
::Benchmark.realtime(&block) * times
end
Result.new(elapsed)
end | ruby | {
"resource": ""
} |
q5074 | Magma.Renderer.format | train | def format(options)
options.map do |key, value|
[{
format: :f,
size: :s,
length: :hls_time,
}[key] || key, value].map(&:to_s).join('=')
end
end | ruby | {
"resource": ""
} |
q5075 | Magma.Renderer.melt_args | train | def melt_args(options)
[
options[:infile],
"-consumer avformat:#{outfile}",
].concat(pipe(options, %i[
symbolize_keys
add_defaults
select
transform
table
format
]))
end | ruby | {
"resource": ""
} |
q5076 | Magma.Renderer.render! | train | def render!
cmd = melt melt_args(options.merge(outfile: outfile)).join(' ')
puts "Run: #{cmd}"
puts
run(cmd) do |_stdin, _stdout, stderr|
stderr.each("\r") do |line|
STDOUT.write "\r#{line}"
end
end
end | ruby | {
"resource": ""
} |
q5077 | Magma.Renderer.select | train | def select(options)
# Clone original
options = options.clone
# Handle related options
options.delete(:real_time) unless options.delete(:enable_real_time)
# Reject
options.select do |key, value|
!value.nil? && %i[
format
hls_list_size
real_time
length
preset
size
start_number
vcodec
].include?(key)
end
end | ruby | {
"resource": ""
} |
q5078 | Magma.Renderer.table | train | def table(options)
lpadding = options.keys.max_by(&:length).length + 2
rpadding = options.values.max_by { |v| v.to_s.length }.to_s.length
puts 'PROPERTY'.ljust(lpadding) + 'VALUE'
puts '=' * (lpadding + rpadding)
options.keys.sort.each do |key|
puts key.to_s.ljust(lpadding) + options[key].to_s
end
puts
options
end | ruby | {
"resource": ""
} |
q5079 | Magma.Renderer.transform | train | def transform(options)
options.map do |key, value|
[key, ({
real_time: ->(x) { "-#{x}" },
}[key] || proc { |x| x }).call(value)]
end.to_h
end | ruby | {
"resource": ""
} |
q5080 | Skydrive.Collection.items | train | def items
@items = []
@data.each do |object_data|
if object_data["type"]
@items << "Skydrive::#{object_data["type"].capitalize}".constantize.new(client, object_data)
elsif object_data["id"].match /^comment\..+/
@items << Skydrive::Comment.new(client, object_data)
end
end
@items
end | ruby | {
"resource": ""
} |
q5081 | JsonRecord.AttributeMethods.read_attribute | train | def read_attribute (field, context)
if field.multivalued?
arr = json_attributes[field.name]
unless arr
arr = EmbeddedDocumentArray.new(field.type, context)
json_attributes[field.name] = arr
end
return arr
else
val = json_attributes[field.name]
if val.nil? and !field.default.nil?
val = field.default.dup rescue field.default
json_attributes[field.name] = val
end
return val
end
end | ruby | {
"resource": ""
} |
q5082 | JsonRecord.AttributeMethods.write_attribute | train | def write_attribute (field, val, context)
if field.multivalued?
val = val.values if val.is_a?(Hash)
json_attributes[field.name] = EmbeddedDocumentArray.new(field.type, context, val)
else
old_value = read_attribute(field, context)
converted_value = field.convert(val)
converted_value.parent = context if converted_value.is_a?(EmbeddedDocument)
unless old_value == converted_value
unless field.type.include?(EmbeddedDocument) or Thread.current[:do_not_track_json_field_changes]
changes = changed_attributes
if changes.include?(field.name)
changes.delete(field.name) if converted_value == changes[field.name]
else
old_value = (old_value.clone rescue old_value) unless old_value.nil? || old_value.is_a?(Numeric) || old_value.is_a?(Symbol) || old_value.is_a?(TrueClass) || old_value.is_a?(FalseClass)
changes[field.name] = old_value
end
end
unless converted_value.nil?
json_attributes[field.name] = converted_value
else
json_attributes.delete(field.name)
end
end
context.json_attributes_before_type_cast[field.name] = val
end
return val
end | ruby | {
"resource": ""
} |
q5083 | TouRETS.Property.method_missing | train | def method_missing(method_name, *args, &block)
mapped_key = key_map[method_name.to_sym]
if attributes.has_key?(mapped_key)
attributes[mapped_key]
else
super
end
end | ruby | {
"resource": ""
} |
q5084 | Languages.FileElementData.add_global_variable | train | def add_global_variable(*pVariable)
pVariable.flatten.each do |element|
next unless element.is_a?(Languages::VariableGlobalData)
@global_variables.push(element)
end
end | ruby | {
"resource": ""
} |
q5085 | Edgarj.UserGroup.permitted? | train | def permitted?(model_name, requested_flags = 0)
return false if self.kind != Kind::ROLE
return true if admin?
p = self.model_permissions.find_by_model(model_name)
if requested_flags == 0
p
else
p && p.permitted?(requested_flags)
end
end | ruby | {
"resource": ""
} |
q5086 | SafeNet.Auth.auth | train | def auth
# entry point
url = "#{@client.app_info[:launcher_server]}#{API_VERSION}/auth"
# payload
payload = {
app: {
name: @client.app_info[:name],
version: @client.app_info[:version],
vendor: @client.app_info[:vendor],
id: @client.app_info[:id]
},
permissions: @client.app_info[:permissions]
}
# api call
uri = URI(url)
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Post.new(uri.path, {'Content-Type' => 'application/json'})
req.body = payload.to_json
res = http.request(req)
# return's parser
if res.code == "200"
response = JSON.parse(res.body)
# save it in conf.json
conf = response.dup
File.open(@client.app_info[:conf_path], "w") { |f| f << JSON.pretty_generate(conf) }
else
# puts "ERROR #{res.code}: #{res.message}"
response = nil
end
# return
response
end | ruby | {
"resource": ""
} |
q5087 | SafeNet.Auth.is_token_valid | train | def is_token_valid
# entry point
url = "#{@client.app_info[:launcher_server]}#{API_VERSION}/auth"
# api call
uri = URI(url)
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Get.new(uri.path, {
'Authorization' => "Bearer #{@client.key_helper.get_token()}"
})
res = http.request(req)
res.code == "200"
end | ruby | {
"resource": ""
} |
q5088 | SafeNet.Auth.revoke_token | train | def revoke_token
# entry point
url = "#{@client.app_info[:launcher_server]}#{API_VERSION}/auth"
# api call
uri = URI(url)
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Delete.new(uri.path, {
'Authorization' => "Bearer #{@client.key_helper.get_valid_token()}"
})
res = http.request(req)
res.code == "200"
end | ruby | {
"resource": ""
} |
q5089 | SafeNet.NFS.create_directory | train | def create_directory(dir_path, options = {})
# Default values
options[:root_path] = 'app' if ! options.has_key?(:root_path)
options[:is_private] = true if ! options.has_key?(:is_private)
# Entry point
url = "#{@client.app_info[:launcher_server]}#{API_VERSION}/nfs/directory/#{options[:root_path]}/#{SafeNet.escape(dir_path)}"
# Payload
payload = {
isPrivate: options[:is_private],
}
# Optional
payload["metadata"] = Base64.strict_encode64(options[:meta]) if options.has_key?(:meta)
# API call
uri = URI(url)
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Post.new(uri.path, {
'Authorization' => "Bearer #{@client.key_helper.get_valid_token()}",
'Content-Type' => 'application/json'
})
req.body = payload.to_json
res = http.request(req)
res.code == "200" ? true : JSON.parse(res.body)
end | ruby | {
"resource": ""
} |
q5090 | SafeNet.NFS.get_directory | train | def get_directory(dir_path, options = {})
# Default values
options[:root_path] = 'app' if ! options.has_key?(:root_path)
# Entry point
url = "#{@client.app_info[:launcher_server]}#{API_VERSION}/nfs/directory/#{options[:root_path]}/#{SafeNet.escape(dir_path)}"
# API call
uri = URI(url)
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Get.new(uri.path, {
'Authorization' => "Bearer #{@client.key_helper.get_valid_token()}",
})
res = http.request(req)
JSON.parse(res.body)
end | ruby | {
"resource": ""
} |
q5091 | SafeNet.NFS.create_file | train | def create_file(file_path, contents, options = {})
# Default values
options[:root_path] = 'app' if ! options.has_key?(:root_path)
contents ||= ""
# Entry point
url = "#{@client.app_info[:launcher_server]}#{API_VERSION}/nfs/file/#{options[:root_path]}/#{SafeNet.escape(file_path)}"
# API call
uri = URI(url)
http = Net::HTTP.new(uri.host, uri.port)
headers = {
'Authorization' => "Bearer #{@client.key_helper.get_valid_token()}",
}
headers["Metadata"] = Base64.strict_encode64(options[:meta]) if options.has_key?(:meta)
headers["Content-Type"] = options[:content_type] || 'text/plain'
headers["Content-Length"] = contents.size.to_s
req = Net::HTTP::Post.new(uri.path, headers)
req.body = contents
res = http.request(req)
res.code == "200" ? true : JSON.parse(res.body)
end | ruby | {
"resource": ""
} |
q5092 | SafeNet.NFS.get_file_meta | train | def get_file_meta(file_path, options = {})
# Default values
options[:root_path] = 'app' if ! options.has_key?(:root_path)
# Entry point
url = "#{@client.app_info[:launcher_server]}#{API_VERSION}/nfs/file/#{options[:root_path]}/#{SafeNet.escape(file_path)}"
# API call
uri = URI(url)
http = Net::HTTP.new(uri.host, uri.port)
headers = {
'Authorization' => "Bearer #{@client.key_helper.get_valid_token()}",
}
req = Net::HTTP::Head.new(uri.path, headers)
res = http.request(req)
res_headers = {}
res.response.each_header {|k,v| res_headers[k] = v}
res_headers["metadata"] = Base64.strict_decode64(res_headers["metadata"]) if res_headers.has_key?("metadata")
res.code == "200" ? {"headers" => res_headers, "body" => res.body} : JSON.parse(res.body)
end | ruby | {
"resource": ""
} |
q5093 | SafeNet.NFS.get_file | train | def get_file(file_path, options = {})
# Default values
options[:offset] = 0 if ! options.has_key?(:offset)
options[:root_path] = 'app' if ! options.has_key?(:root_path)
# Entry point
url = "#{@client.app_info[:launcher_server]}#{API_VERSION}/nfs/file/#{options[:root_path]}/#{SafeNet.escape(file_path)}?"
# Query params
query = []
query << "offset=#{options[:offset]}"
query << "length=#{options[:length]}" if options.has_key?(:length) # length is optional
url = "#{url}#{query.join('&')}"
# API call
uri = URI(url)
http = Net::HTTP.new(uri.host, uri.port)
headers = {
'Authorization' => "Bearer #{@client.key_helper.get_valid_token()}",
}
headers["Range"] = options[:range] if options.has_key?(:range)
req = Net::HTTP::Get.new(uri.path, headers)
res = http.request(req)
res_headers = {}
res.response.each_header {|k,v| res_headers[k] = v}
res.code == "200" ? {"headers" => res_headers, "body" => res.body} : JSON.parse(res.body)
end | ruby | {
"resource": ""
} |
q5094 | SafeNet.NFS.move_file | train | def move_file(src_root_path, src_path, dst_root_path, dst_path, action = 'move')
# Entry point
url = "#{@client.app_info[:launcher_server]}#{API_VERSION}/nfs/movefile"
# Payload
payload = {}
payload["srcRootPath"] = src_root_path # 'app' or 'drive'
payload["srcPath"] = src_path
payload["destRootPath"] = dst_root_path # 'app' or 'drive'
payload["destPath"] = dst_path
payload["action"] = action
# API call
uri = URI(url)
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Post.new(uri.path, {
'Authorization' => "Bearer #{@client.key_helper.get_valid_token()}",
'Content-Type' => 'application/json'
})
req.body = payload.to_json
res = http.request(req)
res.code == "200" ? true : JSON.parse(res.body)
end | ruby | {
"resource": ""
} |
q5095 | SafeNet.NFS.delete_file | train | def delete_file(file_path, options = {})
# Default values
options[:root_path] = 'app' if ! options.has_key?(:root_path)
# Entry point
url = "#{@client.app_info[:launcher_server]}#{API_VERSION}/nfs/file/#{options[:root_path]}/#{SafeNet.escape(file_path)}"
# API call
uri = URI(url)
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Delete.new(uri.path, {
'Authorization' => "Bearer #{@client.key_helper.get_valid_token()}",
})
res = http.request(req)
res.code == "200" ? true : JSON.parse(res.body)
end | ruby | {
"resource": ""
} |
q5096 | SafeNet.DNS.register_service | train | def register_service(long_name, service_name, service_home_dir_path, options = {})
# Entry point
url = "#{@client.app_info[:launcher_server]}#{API_VERSION}/dns"
# Payload
payload = {
longName: long_name,
serviceName: service_name,
rootPath: 'app',
serviceHomeDirPath: service_home_dir_path,
}
# Optional
payload["metadata"] = options[:meta] if options.has_key?(:meta)
# API call
uri = URI(url)
http = Net::HTTP.new(uri.host, uri.port)
req = Net::HTTP::Post.new(uri.path, {
'Authorization' => "Bearer #{@client.key_helper.get_valid_token()}",
'Content-Type' => 'application/json'
})
req.body = payload.to_json
res = http.request(req)
res.code == "200" ? true : JSON.parse(res.body)
end | ruby | {
"resource": ""
} |
q5097 | SafeNet.SD.set | train | def set(name, contents = '', type = 500)
sd = @client.sd.update(name, contents)
if sd.is_a?(Hash) && (sd["errorCode"] == -22) # doesn't exist
sd = @client.sd.create(name, contents)
end
sd
end | ruby | {
"resource": ""
} |
q5098 | ErbLatex.Template.to_file | train | def to_file( file = suggested_filename )
execute do | contents |
if file.is_a?(String)
FileUtils.mv contents, file
else
file.write contents.read
file.rewind
end
end
file
end | ruby | {
"resource": ""
} |
q5099 | ErbLatex.Template.execute | train | def execute
latex = compile_latex
Dir.mktmpdir do | dir |
@pass_count = 0
@log = ''
success = false
while log_suggests_rerunning? && @pass_count < 5
@pass_count += 1
success = execute_xelatex(latex,dir)
end
pdf_file = Pathname.new(dir).join( "output.pdf" )
if success && pdf_file.exist?
yield pdf_file
else
errors = @log.scan(/\*\!\s(.*?)\n\s*\n/m).map{|e| e.first.gsub(/\n/,'') }.join("; ")
STDERR.puts @log, errors if ErbLatex.config.verbose_logs
raise LatexError.new( errors.empty? ? "xelatex compile error" : errors, @log )
end
end
end | ruby | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.