_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3
values | text stringlengths 66 10.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q20800 | Hpe3parSdk.Client.get_ip_ports | train | def get_ip_ports(state = nil)
begin
@port.get_ip_ports(state)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20801 | Hpe3parSdk.Client.get_cpgs | train | def get_cpgs
begin
@cpg.get_cpgs
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20802 | Hpe3parSdk.Client.get_cpg | train | def get_cpg(name)
begin
@cpg.get_cpg(name)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20803 | Hpe3parSdk.Client.create_cpg | train | def create_cpg(name, optional = nil)
begin
@cpg.create_cpg(name, optional)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20804 | Hpe3parSdk.Client.modify_cpg | train | def modify_cpg(name, cpg_mods)
begin
@cpg.modify_cpg(name, cpg_mods)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20805 | Hpe3parSdk.Client.get_cpg_available_space | train | def get_cpg_available_space(name)
begin
@cpg.get_cpg_available_space(name)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20806 | Hpe3parSdk.Client.delete_cpg | train | def delete_cpg(name)
begin
@cpg.delete_cpg(name)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20807 | Hpe3parSdk.Client.get_online_physical_copy_status | train | def get_online_physical_copy_status(name)
begin
@volume.get_online_physical_copy_status(name)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20808 | Hpe3parSdk.Client.stop_offline_physical_copy | train | def stop_offline_physical_copy(name)
begin
@volume.stop_offline_physical_copy(name)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20809 | Hpe3parSdk.Client.stop_online_physical_copy | train | def stop_online_physical_copy(name)
begin
@volume.stop_online_physical_copy(name)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20810 | Hpe3parSdk.Client.resync_physical_copy | train | def resync_physical_copy(name)
begin
@volume.resync_physical_copy(name)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20811 | Hpe3parSdk.Client.wait_for_task_to_end | train | def wait_for_task_to_end(task_id, poll_rate_secs = 15)
begin
@task.wait_for_task_to_end(task_id, poll_rate_secs)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20812 | Hpe3parSdk.Client.cancel_task | train | def cancel_task(task_id)
begin
@task.cancel_task(task_id)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20813 | Hpe3parSdk.Client.logout | train | def logout
unless @log_file_path.nil?
if Hpe3parSdk.logger != nil
Hpe3parSdk.logger.close
Hpe3parSdk.logger = nil
end
end
begin
@http.unauthenticate
rescue Hpe3parSdk::HPE3PARException => ex
#Do nothing
end
end | ruby | {
"resource": ""
} |
q20814 | HealthMonitor.BuiltInChecks.ey_agent_check | train | def ey_agent_check
results = {
:description => 'Run ey-agent to monitor haproxy and monitor'
}
agent_results = JSON.load( `sudo ey-agent` )
results.update(
:message => agent_results.inspect,
:status => agent_results && agent_results.any?{|k,v| v == 'down' }
)
... | ruby | {
"resource": ""
} |
q20815 | HealthMonitor.HealthMonitoring.monitor_health | train | def monitor_health
find_features
@results = @features.inject({}) do |results, feature_name|
results[ feature_name ] = monitor_health_of( feature_name )
results
end
healthy? ? on_healthy : on_unhealthy
render_health
end | ruby | {
"resource": ""
} |
q20816 | HealthMonitor.HealthMonitoring.render_health | train | def render_health
return if performed?
respond_to do |format|
format.html { render_health_html }
format.js { render_health_json }
format.xml { render_health_xml }
end
end | ruby | {
"resource": ""
} |
q20817 | HealthMonitor.HealthMonitoring.find_features | train | def find_features
@features = if params[ :only ]
params[ :only ].to_s.split( "," ).collect( &:to_sym ).uniq
elsif skip = params[ :skip ] || params[ :exclude ]
monitored_features.keys - skip.to_s.split( "," ).collect( &:to_sym )
else
monitored_features.keys
end
end | ruby | {
"resource": ""
} |
q20818 | VMC::App.Start.switch_mode | train | def switch_mode(app, mode)
mode = nil if mode == "none"
mode = "run" if mode == "" # no value given
return false if app.debug == mode
if mode.nil?
with_progress("Removing debug mode") do
app.debug = nil
app.stop! if app.started?
end
return true
... | ruby | {
"resource": ""
} |
q20819 | XClarityClient.ManagementMixin.add_listname_on_body | train | def add_listname_on_body(resource, body)
body.kind_of?(Array) ? process_body_as_array(resource, body) : process_body_as_hash(resource, body)
end | ruby | {
"resource": ""
} |
q20820 | XClarityClient.ManagementMixin.any_listname_of | train | def any_listname_of(resource)
if resource::LIST_NAME.kind_of?(Array)
resource::LIST_NAME.first # If is an array, any listname can be use
else
resource::LIST_NAME # If is not an array, just return the listname of resource
end
end | ruby | {
"resource": ""
} |
q20821 | XClarityClient.ManagementMixin.process_body_as_hash | train | def process_body_as_hash(resource, body)
result = body
if resource::LIST_NAME.kind_of? Array # search which list name is present on body
list_name = resource::LIST_NAME.find { |name| body.keys.include?(name) && body[name].kind_of?(Array) }
else
list_name = any_listname_of(resource)
... | ruby | {
"resource": ""
} |
q20822 | XClarityClient.UserManagement.mount_response_change_password | train | def mount_response_change_password(response)
response = JSON.parse(response.body)
{
changed: response['response']['changed'],
message: response['messages'].first['explanation']
}
end | ruby | {
"resource": ""
} |
q20823 | Markaby.Builder.capture | train | def capture(&block)
@streams.push(@builder.target = Stream.new)
@builder.level += 1
str = instance_eval(&block)
str = @streams.last.join if @streams.last.any?
@streams.pop
@builder.level -= 1
@builder.target = @streams.last
str
end | ruby | {
"resource": ""
} |
q20824 | Markaby.Builder.tag! | train | def tag!(tag, *args, &block)
ele_id = nil
# TODO: Move this logic to the tagset so that the tagset itself can validate + raise when invalid
if @auto_validation && @tagset
if !@tagset.tagset.has_key?(tag)
raise InvalidXhtmlError, "no element `#{tag}' for #{tagset.doctype}"
el... | ruby | {
"resource": ""
} |
q20825 | XClarityClient.UpdateCompManagement.add_uri | train | def add_uri(force_update_mode, onerror_mode, uri)
fmode = force_update_mode.nil?
uri += '&forceUpdateMode=' + force_update_mode unless fmode
uri += '&onErrorMode=' + onerror_mode unless onerror_mode.nil?
uri
end | ruby | {
"resource": ""
} |
q20826 | RestFtpDaemon.JobQueue.jobs_with_status | train | def jobs_with_status status
# No status filter: return all execept queued
if status.empty?
@jobs.reject { |job| job.status == JOB_STATUS_QUEUED }
# Status filtering: only those jobs
else
@jobs.select { |job| job.status == status.to_s }
end
end | ruby | {
"resource": ""
} |
q20827 | RestFtpDaemon.Job.debug_value_utf8 | train | def debug_value_utf8 value
case value
when Symbol
return value.to_s.force_encoding(Encoding::UTF_8)
when String
return value.dup.force_encoding(Encoding::UTF_8) if value.is_a? String
else
return value
end
end | ruby | {
"resource": ""
} |
q20828 | Canard.UserModel.has_roles_mask_accessors? | train | def has_roles_mask_accessors?
instance_method_names = instance_methods.map { |method_name| method_name.to_s }
[roles_attribute_name.to_s, "#{roles_attribute_name}="].all? do |accessor|
instance_method_names.include?(accessor)
end
end | ruby | {
"resource": ""
} |
q20829 | Shwedagon.App.create_new_post | train | def create_new_post(params)
post_title = params['post']['title']
post_date = (Time.now).strftime("%Y-%m-%d")
content = yaml_data(post_title).to_yaml + "---\n" + params[:post][:content]
post_file = (post_date + " " + post_title).to_url + '.md'
file = File.join(jekyll_site.... | ruby | {
"resource": ""
} |
q20830 | Shwedagon.App.merge_config | train | def merge_config(yaml, params)
if params['post'].has_key? 'yaml'
params['post']['yaml'].each do |key, value|
if value == 'true'
yaml[key] = true
elsif value == 'false'
yaml[key] = false
else
yaml[key] = value
end
end
... | ruby | {
"resource": ""
} |
q20831 | Shwedagon.App.update_post | train | def update_post(params)
post_file = params[:post][:name]
post = jekyll_post(post_file)
yaml_config = merge_config(post.data, params)
write_post_contents(params[:post][:content], yaml_config, post_file)
post_file
end | ruby | {
"resource": ""
} |
q20832 | Shwedagon.App.jekyll_site | train | def jekyll_site
if not @site
# Supress stdout
original_stdout = $stdout
$stdout = File.new('/tmp/null.txt', 'w')
config = Jekyll.configuration({'source' => cloned_repo_path})
@site = Jekyll::Site.new(config)
@site.read
$stdout = original_stdout
en... | ruby | {
"resource": ""
} |
q20833 | Shwedagon.App.posts_template_data | train | def posts_template_data(post_items)
if post_items.nil?
return []
end
template_data = post_items.map do |post|
{
:title => post.data['title'],
:filename => post.name,
:date => post.date
}
end
template_data.sort! { |x,y| y[:date]... | ruby | {
"resource": ""
} |
q20834 | Nimbus.Application.nimbus_exception_handling | train | def nimbus_exception_handling
begin
yield
rescue SystemExit => ex
raise
rescue Nimbus::Error => ex
display_error_message(ex)
Nimbus.stop
rescue Exception => ex
display_error_message(ex)
Nimbus.stop
end
end | ruby | {
"resource": ""
} |
q20835 | Nimbus.RegressionTree.seed | train | def seed(all_individuals, individuals_sample, ids_fenotypes)
super
@structure = build_node individuals_sample, Nimbus::LossFunctions.average(individuals_sample, @id_to_fenotype)
end | ruby | {
"resource": ""
} |
q20836 | Nimbus.Configuration.load | train | def load(config_file = DEFAULTS[:config_file])
user_config_params = {}
dirname = Dir.pwd
if File.exists?(File.expand_path(config_file, Dir.pwd))
begin
config_file_path = File.expand_path config_file, Dir.pwd
user_config_params = Psych.load(File.open(config_file_path))
... | ruby | {
"resource": ""
} |
q20837 | Alchemy.User.fullname | train | def fullname(options = {})
if lastname.blank? && firstname.blank?
login
else
options = {:flipped => false}.merge(options)
fullname = options[:flipped] ? "#{lastname}, #{firstname}" : "#{firstname} #{lastname}"
fullname.squeeze(" ").strip
end
end | ruby | {
"resource": ""
} |
q20838 | Alchemy.User.deliver_welcome_mail | train | def deliver_welcome_mail
if has_role?('author') || has_role?('editor') || has_role?('admin')
Notifications.alchemy_user_created(self).deliver_later
else
Notifications.member_created(self).deliver_later
end
end | ruby | {
"resource": ""
} |
q20839 | Alchemy.UserSessionsController.after_sign_out_path_for | train | def after_sign_out_path_for(resource_or_scope)
if request.referer.blank? || request.referer.to_s =~ /admin/
root_path
else
request.referer
end
end | ruby | {
"resource": ""
} |
q20840 | Nimbus.Forest.traverse_regression_forest | train | def traverse_regression_forest
@predictions = {}
prediction_count = trees.size
@options.read_testing_data{|individual|
individual_prediction = 0.0
trees.each do |t|
individual_prediction = (individual_prediction + Nimbus::Tree.traverse(t, individual.snp_list)).round(5)
... | ruby | {
"resource": ""
} |
q20841 | Relaton.Db.docid_type | train | def docid_type(code)
stdclass = standard_class(code) or return [nil, code]
prefix, code = strip_id_wrapper(code, stdclass)
[@registry.processors[stdclass].idtype, code]
end | ruby | {
"resource": ""
} |
q20842 | Relaton.Db.to_xml | train | def to_xml
db = @local_db || @db || return
Nokogiri::XML::Builder.new(encoding: "UTF-8") do |xml|
xml.documents do
xml.parent.add_child db.all.join(" ")
end
end.to_xml
end | ruby | {
"resource": ""
} |
q20843 | Relaton.Db.new_bib_entry | train | def new_bib_entry(code, year, opts, stdclass)
bib = @registry.processors[stdclass].get(code, year, opts)
bib = bib.to_xml if bib.respond_to? :to_xml
bib = "not_found #{Date.today}" if bib.nil? || bib.empty?
bib
end | ruby | {
"resource": ""
} |
q20844 | Relaton.DbCache.all | train | def all
Dir.glob("#{@dir}/**/*.xml").sort.map do |f|
File.read(f, encoding: "utf-8")
end
end | ruby | {
"resource": ""
} |
q20845 | Telephony.Call.terminate_conversation_and_all_call_legs | train | def terminate_conversation_and_all_call_legs(trace_only = false)
if self.conversation
Rails.logger.info "zestphone: ** Terminating all linked calls and conversation **"
Rails.logger.info "zestphone: conversation - (pre) state: #{self.conversation.state}"
Rails.logger.info "zestphone: c... | ruby | {
"resource": ""
} |
q20846 | Phaxio.Resource.populate_attributes | train | def populate_attributes
self.class.normal_attribute_list.each do |normal_attribute|
self.public_send "#{normal_attribute}=", raw_data[normal_attribute]
end
self.class.time_attribute_list.each do |time_attribute|
time = raw_data[time_attribute]
time = Time.parse(time) if !time.... | ruby | {
"resource": ""
} |
q20847 | MaterializePagination.ViewHelpers.will_paginate | train | def will_paginate(collection_or_options = nil, options = {})
if collection_or_options.is_a? Hash
options, collection_or_options = collection_or_options, nil
end
unless options[:renderer]
options = options.merge :renderer => MaterializePagination::Rails
end
super *[collectio... | ruby | {
"resource": ""
} |
q20848 | DataType.Base.structure_changes_from | train | def structure_changes_from(current_structure = nil)
new_structure = column
if current_structure
# General RDBMS data loss scenarios
if new_structure[:limit] && current_structure[:limit].to_i != new_structure[:limit].to_i ||
new_structure[:type] != current_structure[:type] ||... | ruby | {
"resource": ""
} |
q20849 | SalesforceArSync.SalesforceSync.salesforce_attributes_to_set | train | def salesforce_attributes_to_set(attributes = {})
{}.tap do |hash|
# loop through the hash of attributes from the outbound message, and compare to our sf mappings and
# create a reversed hash of value's and key's to pass to update_attributes
attributes.each do |key, value|
# make... | ruby | {
"resource": ""
} |
q20850 | SalesforceArSync.SalesforceSync.salesforce_process_update | train | def salesforce_process_update(attributes = {})
attributes_to_update = salesforce_attributes_to_set(self.new_record? ? attributes : salesforce_empty_attributes.merge(attributes)) # only merge empty attributes for updates, so we don't overwrite the default create attributes
attributes_to_update.each_pair do |... | ruby | {
"resource": ""
} |
q20851 | SalesforceArSync.SalesforceSync.system_mod_stamp | train | def system_mod_stamp
hash = JSON.parse(SF_CLIENT.http_get("/services/data/v#{SF_CLIENT.version}/query", :q => "SELECT SystemModstamp FROM #{salesforce_object_name} WHERE Id = '#{salesforce_id}'").body)
hash["records"].first.try(:[], "SystemModstamp")
end | ruby | {
"resource": ""
} |
q20852 | SalesforceArSync.SalesforceSync.salesforce_attributes_to_update | train | def salesforce_attributes_to_update(include_all = false)
{}.tap do |hash|
self.class.salesforce_sync_attribute_mapping.each do |key, value|
if self.respond_to?(value)
#Checkboxes in SFDC Cannot be nil. Here we check for boolean field type and set nil values to be false
... | ruby | {
"resource": ""
} |
q20853 | SalesforceArSync.SalesforceSync.salesforce_perform_async_call? | train | def salesforce_perform_async_call?
return false if salesforce_attributes_to_update.empty? || self.class.salesforce_async_attributes.empty?
salesforce_attributes_to_update.keys.all? {|key| self.class.salesforce_async_attributes.include?(key) } && salesforce_id.present?
end | ruby | {
"resource": ""
} |
q20854 | SalesforceArSync.SalesforceSync.salesforce_sync | train | def salesforce_sync
return if self.salesforce_skip_sync?
if salesforce_perform_async_call?
Delayed::Job.enqueue(SalesforceArSync::SalesforceObjectSync.new(self.class.salesforce_web_class_name, salesforce_id, salesforce_attributes_to_update), :priority => 50)
else
if salesforce_object_e... | ruby | {
"resource": ""
} |
q20855 | SalesforceArSync.SoapMessageController.validate_ip_ranges | train | def validate_ip_ranges
raise ActionController::RoutingError.new('Not Found') unless SalesforceArSync::IPConstraint.new.matches?(request)
end | ruby | {
"resource": ""
} |
q20856 | ApiClient.Scope.request | train | def request(method, path, options = {})
options = options.dup
raw = raw? || options.delete(:raw)
params(options)
response = connection.send method, path, (@raw_body || @params), @headers
raw ? response : @scopeable.parse(response)
end | ruby | {
"resource": ""
} |
q20857 | GovukSchemas.RandomExample.payload | train | def payload
payload = @random_generator.payload
# ensure the base payload is valid
errors = validation_errors_for(payload)
raise InvalidContentGenerated, error_message(payload, errors) if errors.any?
if block_given?
payload = yield(payload)
# check the payload again after ... | ruby | {
"resource": ""
} |
q20858 | HideMyAss.IP.decode | train | def decode(elements)
elements.each do |element|
# Remove elements with CSS style "none"
if !TAGS.include?(element.name) || (element["style"] && element["style"] =~ /none/)
element.children.remove
# Get rid of decoy children
elsif element["class"]
decoys.each d... | ruby | {
"resource": ""
} |
q20859 | Ambry.AbstractKeySet.count | train | def count(&block)
return keys.count unless block_given?
proxy = HashProxy.new
keys.inject(0) do |count, key|
proxy.with(mapper[key], &block) ? count.succ : count
end
end | ruby | {
"resource": ""
} |
q20860 | IntervalTree.Tree.center | train | def center(intervals)
i = intervals.reduce([intervals.first.first, intervals.first.last]) { |acc, int| [[acc.first, int.first].min, [acc.last, int.last].max] }
i.first + (i.last - i.first) / 2
end | ruby | {
"resource": ""
} |
q20861 | Ambry.HashProxy.method_missing | train | def method_missing(symbol)
if hash.key?(symbol)
hash[symbol]
elsif hash.key?(symbol.to_s)
hash[symbol.to_s]
else
raise NoMethodError
end
end | ruby | {
"resource": ""
} |
q20862 | Ambry.HashProxy.[] | train | def [](key)
if hash.key?(key) then hash[key]
elsif hash.key?(key.to_sym) then hash[key.to_sym]
elsif hash.key?(key.to_s) then hash[key.to_s]
end
end | ruby | {
"resource": ""
} |
q20863 | Ambry.Mapper.[]= | train | def []=(key, value)
@lock.synchronize do
@indexes = {}
if value.id_changed?
hash.delete value.to_id(true)
end
saved = hash[key] = value.to_hash.freeze
adapter.save_database if @options[:sync]
saved
end
end | ruby | {
"resource": ""
} |
q20864 | Caboose.Invoice.authorize_and_capture | train | def authorize_and_capture
resp = StdClass.new
if self.financial_status == Invoice::FINANCIAL_STATUS_CAPTURED
resp.error = "Funds for this invoice have already been captured."
else
sc = self.site.store_config
... | ruby | {
"resource": ""
} |
q20865 | Caboose.Invoice.void | train | def void
resp = StdClass.new
t = InvoiceTransaction.where(:invoice_id => self.id, :transaction_type => InvoiceTransaction::TYPE_AUTHORIZE, :success => true).first
if self.financial_status == Invoice::FINANCIAL_STATUS_CAPTURED
resp.error = "This invoice has already been capt... | ruby | {
"resource": ""
} |
q20866 | Beaker.Vmpooler.add_tags | train | def add_tags(host)
host[:host_tags].merge(
'beaker_version' => Beaker::Version::STRING,
'jenkins_build_url' => @options[:jenkins_build_url],
'department' => @options[:department],
'project' => @options[:project],
'created_by' => @options... | ruby | {
"resource": ""
} |
q20867 | Caboose.Subscription.create_invoices | train | def create_invoices
self.calculate_date_started_full if self.date_started_full.nil?
v = self.variant
interval = case v.subscription_interval
when Variant::SUBSCRIPTION_INTERVAL_MONTHLY then 1.month
when Variant::SUBSCRIPTION_INTERVAL_YEARLY then 1.year
end
... | ruby | {
"resource": ""
} |
q20868 | Caboose.InvoicePackage.activemerchant_package | train | def activemerchant_package
sc = self.invoice.site.store_config
weight = 0.0
self.line_items.each{ |li| weight = weight + (li.variant.weight * li.quantity) }
weight = weight * 0.035274 if sc.weight_unit == StoreConfig::WEIGHT_UNIT_METRIC # grams to ounces
sp ... | ruby | {
"resource": ""
} |
q20869 | Caboose.ShippingPackage.boxes | train | def boxes(rigid_variants)
stackable = {}
nonstackable = []
rigid_variants.each do |v|
sgid = v.product.stackable_group_id
if sgid
stackable[sgid] = [] if stackable[sgid].nil?
stackable[sgid] << v
else
nonstackable << [v.leng... | ruby | {
"resource": ""
} |
q20870 | Caboose.ApplicationController.init_cart | train | def init_cart
# Check if the cart ID is defined and that it exists in the database
create_new_invoice = false
if session[:cart_id]
@invoice = Caboose::Invoice.where(:id => session[:cart_id]).first
create_new_invoice = true if @invoice.nil? || @invoice.status != 'cart' ... | ruby | {
"resource": ""
} |
q20871 | Caboose.ApplicationController.parse_url_params | train | def parse_url_params
return if !Caboose.use_url_params
url = "#{request.fullpath}"
url[0] = "" if url.starts_with?('/')
url = url.split('?')[0] if url.include?('?')
arr = url.split('/')
i = arr.count - 1
while i >= 1 do
k = arr[i-1]
... | ruby | {
"resource": ""
} |
q20872 | Caboose.ApplicationController.login_user | train | def login_user(user, remember = false)
session["app_user"] = Caboose::StdClass.new({
:id => user.id ,
:site_id => user.site_id ,
:first_name => user.first_name ,
:last_name => user.last_name ,
:username => user.username ,
:email ... | ruby | {
"resource": ""
} |
q20873 | Caboose.ApplicationController.logged_in? | train | def logged_in?
validate_token
validate_cookie
return true if !session["app_user"].nil? && session["app_user"] != false && session["app_user"].id != -1 && session["app_user"].id != User.logged_out_user_id(@site.id)
return false
end | ruby | {
"resource": ""
} |
q20874 | Caboose.ApplicationController.validate_token | train | def validate_token
token = params[:token]
return false if token.nil?
user = User.validate_token(token)
return false if user.nil?
login_user(user)
return true
end | ruby | {
"resource": ""
} |
q20875 | Caboose.ApplicationController.validate_cookie | train | def validate_cookie
if cookies[:caboose_user_id]
user = User.where(:id => cookies[:caboose_user_id]).first
if user
login_user(user)
return true
end
end
return false
end | ruby | {
"resource": ""
} |
q20876 | Caboose.ApplicationController.reject_param | train | def reject_param(url, param)
arr = url.split('?')
return url if (arr.count == 1)
qs = arr[1].split('&').reject { |pair| pair.split(/[=;]/).first == param }
url2 = arr[0]
url2 += "?" + qs.join('&') if qs.count > 0
return url2
end | ruby | {
"resource": ""
} |
q20877 | Caboose.ApplicationController.under_construction_or_forwarding_domain? | train | def under_construction_or_forwarding_domain?
d = Caboose::Domain.where(:domain => request.host_with_port).first
if d.nil?
Caboose.log("Could not find domain for #{request.host_with_port}\nAdd this domain to the caboose site.")
elsif d.under_construction == true
if d.site.u... | ruby | {
"resource": ""
} |
q20878 | Caboose.CheckoutController.shipping_json | train | def shipping_json
render :json => { :error => 'Not logged in.' } and return if !logged_in?
render :json => { :error => 'No shippable items.' } and return if !@invoice.has_shippable_items?
render :json => { :error => 'Empty shipping address.' } and return if @invoice.shipping_address.nil? ... | ruby | {
"resource": ""
} |
q20879 | Caboose.CheckoutController.update_stripe_details | train | def update_stripe_details
render :json => false and return if !logged_in?
sc = @site.store_config
Stripe.api_key = sc.stripe_secret_key.strip
u = logged_in_user
c = nil
if u.stripe_customer_id
c = Stripe::Customer.retrieve(u.stripe_customer_id)
... | ruby | {
"resource": ""
} |
q20880 | Caboose.InvoicesMailer.fulfillment_new_invoice | train | def fulfillment_new_invoice(invoice)
@invoice = invoice
sc = invoice.site.store_config
mail(:to => sc.fulfillment_email, :subject => 'New Order')
end | ruby | {
"resource": ""
} |
q20881 | Caboose.InvoicesMailer.shipping_invoice_ready | train | def shipping_invoice_ready(invoice)
@invoice = invoice
sc = invoice.site.store_config
mail(:to => sc.shipping_email, :subject => 'Order ready for shipping')
end | ruby | {
"resource": ""
} |
q20882 | XapianDb.DocumentBlueprint.accessors_module | train | def accessors_module
return @accessors_module unless @accessors_module.nil?
@accessors_module = Module.new
# Add the accessors for the indexed class and the score
@accessors_module.instance_eval do
define_method :indexed_class do
self.values[0].value
end
defi... | ruby | {
"resource": ""
} |
q20883 | XapianDb.DocumentBlueprint.attribute | train | def attribute(name, options={}, &block)
raise ArgumentError.new("You cannot use #{name} as an attribute name since it is a reserved method name of Xapian::Document") if reserved_method_name?(name)
do_not_index = options.delete(:index) == false
@type_map[name] = (options.delete(:as) || :string)
... | ruby | {
"resource": ""
} |
q20884 | XapianDb.DocumentBlueprint.attributes | train | def attributes(*attributes)
attributes.each do |attr|
raise ArgumentError.new("You cannot use #{attr} as an attribute name since it is a reserved method name of Xapian::Document") if reserved_method_name?(attr)
@attributes_hash[attr] = {}
@type_map[attr] = :string
self.index attr
... | ruby | {
"resource": ""
} |
q20885 | XapianDb.DocumentBlueprint.index | train | def index(*args, &block)
case args.size
when 1
@indexed_methods_hash[args.first] = IndexOptions.new(:weight => 1, :block => block)
when 2
# Is it a method name with options?
if args.last.is_a? Hash
options = args.last
assert_valid_keys options,... | ruby | {
"resource": ""
} |
q20886 | XapianDb.DocumentBlueprint.natural_sort_order | train | def natural_sort_order(name=nil, &block)
raise ArgumentError.new("natural_sort_order accepts a method name or a block, but not both") if name && block
@_natural_sort_order = name || block
end | ruby | {
"resource": ""
} |
q20887 | XapianDb.Config.database | train | def database(path)
# If the current database is a persistent database, we must release the
# database and run the garbage collector to remove the write lock
if @_database.is_a?(XapianDb::PersistentDatabase)
@_database = nil
GC.start
end
if path.to_sym == :memory
@... | ruby | {
"resource": ""
} |
q20888 | XapianDb.Config.adapter | train | def adapter(type)
begin
@_adapter = XapianDb::Adapters.const_get("#{camelize(type.to_s)}Adapter")
rescue NameError
require File.dirname(__FILE__) + "/adapters/#{type}_adapter"
@_adapter = XapianDb::Adapters.const_get("#{camelize(type.to_s)}Adapter")
end
end | ruby | {
"resource": ""
} |
q20889 | XapianDb.Config.writer | train | def writer(type)
# We try to guess the writer name
begin
require File.dirname(__FILE__) + "/index_writers/#{type}_writer"
@_writer = XapianDb::IndexWriters.const_get("#{camelize(type.to_s)}Writer")
rescue LoadError
puts "XapianDb: cannot load #{type} writer; see README for supp... | ruby | {
"resource": ""
} |
q20890 | XapianDb.Config.language | train | def language(lang)
lang ||= :none
@_stemmer = XapianDb::Repositories::Stemmer.stemmer_for lang
@_stopper = lang == :none ? nil : XapianDb::Repositories::Stopper.stopper_for(lang)
end | ruby | {
"resource": ""
} |
q20891 | XapianDb.Utilities.assert_valid_keys | train | def assert_valid_keys(hash, *valid_keys)
unknown_keys = hash.keys - [valid_keys].flatten
raise(ArgumentError, "Unsupported option(s) detected: #{unknown_keys.join(", ")}") unless unknown_keys.empty?
end | ruby | {
"resource": ""
} |
q20892 | Mocha.API.assert_received | train | def assert_received(mock, expected_method_name)
matcher = have_received(expected_method_name)
yield(matcher) if block_given?
assert matcher.matches?(mock), matcher.failure_message
end | ruby | {
"resource": ""
} |
q20893 | XapianDb.Resultset.decorate | train | def decorate(match)
klass_name = match.document.values[0].value
blueprint = XapianDb::DocumentBlueprint.blueprint_for klass_name
match.document.extend blueprint.accessors_module
match.document.instance_variable_set :@score, match.percent
match
end | ruby | {
"resource": ""
} |
q20894 | XapianDb.Database.delete_docs_of_class | train | def delete_docs_of_class(klass)
writer.delete_document("C#{klass}")
if klass.respond_to? :descendants
klass.descendants.each do |subclass|
writer.delete_document("C#{subclass}")
end
end
true
end | ruby | {
"resource": ""
} |
q20895 | XapianDb.Database.search | train | def search(expression, options={})
opts = {:sort_decending => false}.merge(options)
@query_parser ||= QueryParser.new(self)
query = @query_parser.parse(expression)
# If we do not have a valid query we return an empty result set
return Resultset.new(nil, opts) unless query... | ruby | {
"resource": ""
} |
q20896 | XapianDb.Database.facets | train | def facets(attribute, expression)
# return an empty hash if no search expression is given
return {} if expression.nil? || expression.strip.empty?
value_number = XapianDb::DocumentBlueprint.value_number_for(attribute)
@query_parser ||= QueryParser.new(self)
query ... | ruby | {
"resource": ""
} |
q20897 | XapianDb.Indexer.store_fields | train | def store_fields
# class name of the object goes to position 0
@xapian_doc.add_value 0, @obj.class.name
# natural sort order goes to position 1
if @blueprint._natural_sort_order.is_a? Proc
sort_value = @obj.instance_eval &@blueprint._natural_sort_order
else
sort_value = @o... | ruby | {
"resource": ""
} |
q20898 | XapianDb.Indexer.index_text | train | def index_text
term_generator = Xapian::TermGenerator.new
term_generator.database = @database.writer
term_generator.document = @xapian_doc
if XapianDb::Config.stemmer
term_generator.stemmer = XapianDb::Config.stemmer
term_generator.stopper = XapianDb::Config.stopper if XapianDb... | ruby | {
"resource": ""
} |
q20899 | XapianDb.Indexer.get_values_to_index_from | train | def get_values_to_index_from(obj)
# if it's an array, we collect the values for its elements recursive
if obj.is_a? Array
return obj.map { |element| get_values_to_index_from element }.flatten.compact
end
# if the object responds to attributes and attributes is a hash,
# we use th... | ruby | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.