_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3
values | text stringlengths 66 10.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q15300 | WebsocketRails.BaseController.send_message | train | def send_message(event_name, message, options={})
options.merge! :connection => connection, :data => message
event = Event.new( event_name, options )
@_dispatcher.send_message event if @_dispatcher.respond_to?(:send_message)
end | ruby | {
"resource": ""
} |
q15301 | WebsocketRails.ControllerFactory.reload! | train | def reload!(controller)
return controller unless defined?(Rails) and !Rails.configuration.cache_classes
# we don't reload our own controller as we assume it provide as 'library'
unless controller.name == "WebsocketRails::InternalController"
class_name = controller.name
filename = class... | ruby | {
"resource": ""
} |
q15302 | WebsocketRails.ConnectionManager.call | train | def call(env)
request = ActionDispatch::Request.new(env)
if request.post?
response = parse_incoming_event(request.params)
else
response = open_connection(request)
end
response
rescue InvalidConnectionError
BadRequestResponse
end | ruby | {
"resource": ""
} |
q15303 | Alchemy.LegacyPageRedirects.legacy_page_redirect_url | train | def legacy_page_redirect_url
page = last_legacy_url.page
return unless page
alchemy.show_page_path(
locale: prefix_locale? ? page.language_code : nil,
urlname: page.urlname
)
end | ruby | {
"resource": ""
} |
q15304 | Alchemy.Element::ElementContents.update_contents | train | def update_contents(contents_attributes)
return true if contents_attributes.nil?
contents.each do |content|
content_hash = contents_attributes[content.id.to_s] || next
content.update_essence(content_hash) || errors.add(:base, :essence_validation_failed)
end
errors.blank?
end | ruby | {
"resource": ""
} |
q15305 | Alchemy.Element::ElementContents.copy_contents_to | train | def copy_contents_to(element)
contents.map do |content|
Content.copy(content, element_id: element.id)
end
end | ruby | {
"resource": ""
} |
q15306 | Alchemy.Element::ElementContents.content_definition_for | train | def content_definition_for(content_name)
if content_definitions.blank?
log_warning "Element #{name} is missing the content definition for #{content_name}"
nil
else
content_definitions.detect { |d| d['name'] == content_name }
end
end | ruby | {
"resource": ""
} |
q15307 | Alchemy.Element::ElementContents.richtext_contents_ids | train | def richtext_contents_ids
# This is not very efficient SQL wise I know, but we need to iterate
# recursivly through all descendent elements and I don't know how to do this
# in pure SQL. Anyone with a better idea is welcome to submit a patch.
ids = contents.select(&:has_tinymce?).collect(&:id)
... | ruby | {
"resource": ""
} |
q15308 | Alchemy.Element::ElementContents.create_contents | train | def create_contents
definition.fetch('contents', []).each do |attributes|
Content.create(attributes.merge(element: self))
end
end | ruby | {
"resource": ""
} |
q15309 | Alchemy.Page::PageElements.available_element_definitions | train | def available_element_definitions(only_element_named = nil)
@_element_definitions ||= if only_element_named
definition = Element.definition_by_name(only_element_named)
element_definitions_by_name(definition['nestable_elements'])
else
element_definitions
end
return [] if ... | ruby | {
"resource": ""
} |
q15310 | Alchemy.Page::PageElements.available_elements_within_current_scope | train | def available_elements_within_current_scope(parent)
@_available_elements = if parent
parents_unique_nested_elements = parent.nested_elements.where(unique: true).pluck(:name)
available_element_definitions(parent.name).reject do |e|
parents_unique_nested_elements.include? e['name']
... | ruby | {
"resource": ""
} |
q15311 | Alchemy.Page::PageElements.descendent_element_definitions | train | def descendent_element_definitions
definitions = element_definitions_by_name(element_definition_names)
definitions.select { |d| d.key?('nestable_elements') }.each do |d|
definitions += element_definitions_by_name(d['nestable_elements'])
end
definitions.uniq { |d| d['name'] }
end | ruby | {
"resource": ""
} |
q15312 | Alchemy.Page::PageElements.generate_elements | train | def generate_elements
elements_already_on_page = elements_including_fixed.pluck(:name)
definition.fetch('autogenerate', []).each do |element_name|
next if elements_already_on_page.include?(element_name)
Element.create(page: self, name: element_name)
end
end | ruby | {
"resource": ""
} |
q15313 | Alchemy.Page::PageElements.delete_outnumbered_element_definitions! | train | def delete_outnumbered_element_definitions!
@_element_definitions.delete_if do |element|
outnumbered = @_existing_element_names.select { |name| name == element['name'] }
element['amount'] && outnumbered.count >= element['amount'].to_i
end
end | ruby | {
"resource": ""
} |
q15314 | Alchemy.OnPageLayout.on_page_layout | train | def on_page_layout(page_layouts, callback = nil, &block)
callback = block || callback
[page_layouts].flatten.each do |page_layout|
if callback
OnPageLayout.register_callback(page_layout, callback)
else
raise ArgumentError,
"You need to either pass a block or m... | ruby | {
"resource": ""
} |
q15315 | Alchemy.Content.serialize | train | def serialize
{
name: name,
value: serialized_ingredient,
link: essence.try(:link)
}.delete_if { |_k, v| v.blank? }
end | ruby | {
"resource": ""
} |
q15316 | Alchemy.Content.update_essence | train | def update_essence(params = {})
raise EssenceMissingError if essence.nil?
if essence.update(params)
return true
else
errors.add(:essence, :validation_failed)
return false
end
end | ruby | {
"resource": ""
} |
q15317 | Alchemy.ElementsBlockHelper.element_view_for | train | def element_view_for(element, options = {})
options = {
tag: :div,
id: element_dom_id(element),
class: element.name,
tags_formatter: ->(tags) { tags.join(" ") }
}.merge(options)
# capture inner template block
output = capture do
yield ElementViewHelper.ne... | ruby | {
"resource": ""
} |
q15318 | Alchemy.Picture::Url.url | train | def url(options = {})
image = image_file
raise MissingImageFileError, "Missing image file for #{inspect}" if image.nil?
image = processed_image(image, options)
image = encoded_image(image, options)
image.url(options.except(*TRANSFORMATION_OPTIONS).merge(name: name))
rescue MissingIm... | ruby | {
"resource": ""
} |
q15319 | Alchemy.Picture::Url.processed_image | train | def processed_image(image, options = {})
size = options[:size]
upsample = !!options[:upsample]
return image unless size.present? && has_convertible_format?
if options[:crop]
crop(size, options[:crop_from], options[:crop_size], upsample)
else
resize(size, upsample)
e... | ruby | {
"resource": ""
} |
q15320 | Alchemy.Picture::Url.encoded_image | train | def encoded_image(image, options = {})
target_format = options[:format] || default_render_format
unless target_format.in?(Alchemy::Picture.allowed_filetypes)
raise WrongImageFormatError.new(self, target_format)
end
options = {
flatten: target_format != 'gif' && image_file_forma... | ruby | {
"resource": ""
} |
q15321 | Alchemy.ResourcesHelper.render_attribute | train | def render_attribute(resource, attribute, options = {})
attribute_value = resource.send(attribute[:name])
if attribute[:relation]
record = resource.send(attribute[:relation][:name])
value = record.present? ? record.send(attribute[:relation][:attr_method]) : Alchemy.t(:not_found)
elsif ... | ruby | {
"resource": ""
} |
q15322 | Alchemy.ResourcesHelper.resource_attribute_field_options | train | def resource_attribute_field_options(attribute)
options = {hint: resource_handler.help_text_for(attribute)}
input_type = attribute[:type].to_s
case input_type
when 'boolean'
options
when 'date', 'time', 'datetime'
date = resource_instance_variable.send(attribute[:name]) || ... | ruby | {
"resource": ""
} |
q15323 | Alchemy.ResourcesHelper.render_resources | train | def render_resources
render partial: resource_name, collection: resources_instance_variable
rescue ActionView::MissingTemplate
render partial: 'resource', collection: resources_instance_variable
end | ruby | {
"resource": ""
} |
q15324 | Alchemy.Resource.searchable_attribute_names | train | def searchable_attribute_names
if model.respond_to?(:searchable_alchemy_resource_attributes)
model.searchable_alchemy_resource_attributes
else
attributes.select { |a| searchable_attribute?(a) }
.concat(searchable_relation_attributes(attributes))
.collect { |h| h[:name] }
... | ruby | {
"resource": ""
} |
q15325 | Alchemy.Resource.help_text_for | train | def help_text_for(attribute)
::I18n.translate!(attribute[:name], scope: [:alchemy, :resource_help_texts, resource_name])
rescue ::I18n::MissingTranslationData
false
end | ruby | {
"resource": ""
} |
q15326 | Alchemy.Resource.map_relations | train | def map_relations
self.resource_relations = {}
model.alchemy_resource_relations.each do |name, options|
name = name.to_s.gsub(/_id$/, '') # ensure that we don't have an id
association = association_from_relation_name(name)
foreign_key = association.options[:foreign_key] || "#{associa... | ruby | {
"resource": ""
} |
q15327 | Alchemy.Resource.store_model_associations | train | def store_model_associations
self.model_associations = model.reflect_on_all_associations.delete_if { |a| DEFAULT_SKIPPED_ASSOCIATIONS.include?(a.name.to_s) }
end | ruby | {
"resource": ""
} |
q15328 | Alchemy.Shell.display_todos | train | def display_todos
return if todos.empty?
log "\n+---------+", :message
log "| 📝 TODO |", :message
log "+---------+\n", :message
puts "\nWe did most of the work for you, but there are still some things left for you to do."
todos.each_with_index do |todo, i|
title = "\n#{i + ... | ruby | {
"resource": ""
} |
q15329 | Alchemy.Shell.log | train | def log(message, type = nil)
unless Alchemy::Shell.silenced?
case type
when :skip
puts "#{color(:yellow)}== Skipping! #{message}#{color(:clear)}"
when :error
puts "#{color(:red)}!! ERROR: #{message}#{color(:clear)}"
when :message
puts "#{color(:clear)}... | ruby | {
"resource": ""
} |
q15330 | Alchemy.Shell.color | train | def color(name)
color_const = name.to_s.upcase
if Thor::Shell::Color.const_defined?(color_const)
"Thor::Shell::Color::#{color_const}".constantize
else
""
end
end | ruby | {
"resource": ""
} |
q15331 | Alchemy.EssencePicture.picture_url_options | train | def picture_url_options
return {} if picture.nil?
{
format: picture.default_render_format,
crop_from: crop_from.presence,
crop_size: crop_size.presence
}.with_indifferent_access
end | ruby | {
"resource": ""
} |
q15332 | Alchemy.EssencePicture.thumbnail_url | train | def thumbnail_url(options = {})
return if picture.nil?
crop = crop_values_present? || content.settings_value(:crop, options)
size = render_size || content.settings_value(:size, options)
options = {
size: thumbnail_size(size, crop),
crop: !!crop,
crop_from: crop_from.pre... | ruby | {
"resource": ""
} |
q15333 | Alchemy.EssencePicture.cropping_mask | train | def cropping_mask
return if crop_from.blank? || crop_size.blank?
crop_from = point_from_string(read_attribute(:crop_from))
crop_size = sizes_from_string(read_attribute(:crop_size))
point_and_mask_to_points(crop_from, crop_size)
end | ruby | {
"resource": ""
} |
q15334 | Alchemy.EssencePicture.allow_image_cropping? | train | def allow_image_cropping?(options = {})
content && content.settings_value(:crop, options) && picture &&
picture.can_be_cropped_to(
content.settings_value(:size, options),
content.settings_value(:upsample, options)
)
end | ruby | {
"resource": ""
} |
q15335 | Alchemy.Hints.hint | train | def hint
hint = definition['hint']
if hint == true
Alchemy.t(name, scope: hint_translation_scope)
else
hint
end
end | ruby | {
"resource": ""
} |
q15336 | Alchemy.Picture::Transformations.default_mask | train | def default_mask(mask_arg)
mask = mask_arg.dup
mask[:width] = image_file_width if mask[:width].zero?
mask[:height] = image_file_height if mask[:height].zero?
crop_size = size_when_fitting({width: image_file_width, height: image_file_height}, mask)
top_left = get_top_left_crop_corner(crop_... | ruby | {
"resource": ""
} |
q15337 | Alchemy.Picture::Transformations.thumbnail_size | train | def thumbnail_size(size_string = "0x0", crop = false)
size = sizes_from_string(size_string)
# only if crop is set do we need to actually parse the size string, otherwise
# we take the base image size.
if crop
size[:width] = get_base_dimensions[:width] if size[:width].zero?
size[... | ruby | {
"resource": ""
} |
q15338 | Alchemy.Picture::Transformations.crop | train | def crop(size, crop_from = nil, crop_size = nil, upsample = false)
raise "No size given!" if size.empty?
render_to = sizes_from_string(size)
if crop_from && crop_size
top_left = point_from_string(crop_from)
crop_dimensions = sizes_from_string(crop_size)
xy_crop_resize(render_to... | ruby | {
"resource": ""
} |
q15339 | Alchemy.Picture::Transformations.size_when_fitting | train | def size_when_fitting(target, dimensions = get_base_dimensions)
zoom = [
dimensions[:width].to_f / target[:width],
dimensions[:height].to_f / target[:height]
].max
if zoom == 0.0
width = target[:width]
height = target[:height]
else
width = (dimensions[:wi... | ruby | {
"resource": ""
} |
q15340 | Alchemy.Picture::Transformations.center_crop | train | def center_crop(dimensions, upsample)
if is_smaller_than(dimensions) && upsample == false
dimensions = reduce_to_image(dimensions)
end
image_file.thumb("#{dimensions_to_string(dimensions)}#")
end | ruby | {
"resource": ""
} |
q15341 | Alchemy.Picture::Transformations.xy_crop_resize | train | def xy_crop_resize(dimensions, top_left, crop_dimensions, upsample)
crop_argument = "-crop #{dimensions_to_string(crop_dimensions)}"
crop_argument += "+#{top_left[:x]}+#{top_left[:y]}"
resize_argument = "-resize #{dimensions_to_string(dimensions)}"
resize_argument += ">" unless upsample
i... | ruby | {
"resource": ""
} |
q15342 | Alchemy.Picture::Transformations.reduce_to_image | train | def reduce_to_image(dimensions)
{
width: [dimensions[:width], image_file_width].min,
height: [dimensions[:height], image_file_height].min
}
end | ruby | {
"resource": ""
} |
q15343 | Alchemy.Page.previous | train | def previous(options = {})
pages = self_and_siblings.where('lft < ?', lft)
select_page(pages, options.merge(order: :desc))
end | ruby | {
"resource": ""
} |
q15344 | Alchemy.Page.publish! | train | def publish!
current_time = Time.current
update_columns(
published_at: current_time,
public_on: already_public_for?(current_time) ? public_on : current_time,
public_until: still_public_for?(current_time) ? public_until : nil
)
end | ruby | {
"resource": ""
} |
q15345 | Alchemy.Page.create_legacy_url | train | def create_legacy_url
if active_record_5_1?
former_urlname = urlname_before_last_save
else
former_urlname = urlname_was
end
legacy_urls.find_or_create_by(urlname: former_urlname)
end | ruby | {
"resource": ""
} |
q15346 | Alchemy.Page::PageNatures.cache_page? | train | def cache_page?
return false unless caching_enabled?
page_layout = PageLayout.get(self.page_layout)
page_layout['cache'] != false && page_layout['searchresults'] != true
end | ruby | {
"resource": ""
} |
q15347 | Alchemy.Taggable.tag_list= | train | def tag_list=(tags)
case tags
when String
self.tag_names = tags.split(/,\s*/)
when Array
self.tag_names = tags
end
end | ruby | {
"resource": ""
} |
q15348 | Alchemy.AttachmentsController.download | train | def download
response.headers['Content-Length'] = @attachment.file.size.to_s
send_file(
@attachment.file.path, {
filename: @attachment.file_name,
type: @attachment.file_mime_type
}
)
end | ruby | {
"resource": ""
} |
q15349 | Alchemy.Picture.security_token | train | def security_token(params = {})
params = params.dup.stringify_keys
params.update({
'crop' => params['crop'] ? 'crop' : nil,
'id' => id
})
PictureAttributes.secure(params)
end | ruby | {
"resource": ""
} |
q15350 | Alchemy.Page::PageNaming.update_urlname! | train | def update_urlname!
new_urlname = nested_url_name(slug)
if urlname != new_urlname
legacy_urls.create(urlname: urlname)
update_column(:urlname, new_urlname)
end
end | ruby | {
"resource": ""
} |
q15351 | Alchemy.Page::PageNaming.convert_url_name | train | def convert_url_name(value)
url_name = convert_to_urlname(value.blank? ? name : value)
if url_name.length < 3
('-' * (3 - url_name.length)) + url_name
else
url_name
end
end | ruby | {
"resource": ""
} |
q15352 | Alchemy.ElementsController.show | train | def show
@page = @element.page
@options = params[:options]
respond_to do |format|
format.html
format.js { @container_id = params[:container_id] }
end
end | ruby | {
"resource": ""
} |
q15353 | Alchemy.BaseHelper.render_icon | train | def render_icon(icon_class, options = {})
options = {style: 'solid'}.merge(options)
classes = [
"icon fa-fw",
"fa-#{icon_class}",
"fa#{options[:style].first}",
options[:size] ? "fa-#{options[:size]}" : nil,
options[:transform] ? "fa-#{options[:transform]}" : nil,
... | ruby | {
"resource": ""
} |
q15354 | Alchemy.BaseHelper.page_or_find | train | def page_or_find(page)
if page.is_a?(String)
page = Language.current.pages.find_by(page_layout: page)
end
if page.blank?
warning("No Page found for #{page.inspect}")
return
else
page
end
end | ruby | {
"resource": ""
} |
q15355 | Alchemy.PagesController.load_page | train | def load_page
@page ||= Language.current.pages.contentpages.find_by(
urlname: params[:urlname],
language_code: params[:locale] || Language.current.code
)
end | ruby | {
"resource": ""
} |
q15356 | Alchemy.PagesController.render_fresh_page? | train | def render_fresh_page?
must_not_cache? || stale?(etag: page_etag,
last_modified: @page.published_at,
public: !@page.restricted,
template: 'pages/show')
end | ruby | {
"resource": ""
} |
q15357 | Alchemy.EssencesHelper.render_essence_view_by_name | train | def render_essence_view_by_name(element, name, options = {}, html_options = {})
if element.blank?
warning('Element is nil')
return ""
end
content = element.content_by_name(name)
render_essence_view(content, options, html_options)
end | ruby | {
"resource": ""
} |
q15358 | Alchemy.EssencesHelper.render_essence | train | def render_essence(content, part = :view, options = {}, html_options = {})
options = {for_view: {}, for_editor: {}}.update(options)
if content.nil?
return part == :view ? "" : warning('Content is nil', Alchemy.t(:content_not_found))
elsif content.essence.nil?
return part == :view ? "" ... | ruby | {
"resource": ""
} |
q15359 | Alchemy.ControllerActions.current_alchemy_user | train | def current_alchemy_user
current_user_method = Alchemy.current_user_method
raise NoCurrentUserFoundError if !respond_to?(current_user_method, true)
send current_user_method
end | ruby | {
"resource": ""
} |
q15360 | Alchemy.ControllerActions.set_alchemy_language | train | def set_alchemy_language(lang = nil)
if lang
@language = lang.is_a?(Language) ? lang : load_alchemy_language_from_id_or_code(lang)
else
# find the best language and remember it for later
@language = load_alchemy_language_from_params ||
load_alchemy_language_from_s... | ruby | {
"resource": ""
} |
q15361 | Alchemy.ControllerActions.store_current_alchemy_language | train | def store_current_alchemy_language(language)
if language && language.id
session[:alchemy_language_id] = language.id
Language.current = language
end
end | ruby | {
"resource": ""
} |
q15362 | Alchemy.ElementsHelper.render_elements | train | def render_elements(options = {})
options = {
from_page: @page,
render_format: 'html'
}.update(options)
if options[:sort_by]
Alchemy::Deprecation.warn "options[:sort_by] has been removed without replacement. " \
"Please implement your own element sorting by passing a... | ruby | {
"resource": ""
} |
q15363 | Alchemy.ElementsHelper.element_preview_code | train | def element_preview_code(element)
if respond_to?(:tag_options)
tag_options(element_preview_code_attributes(element))
else
# Rails 5.1 uses TagBuilder
tag_builder.tag_options(element_preview_code_attributes(element))
end
end | ruby | {
"resource": ""
} |
q15364 | Alchemy.ElementsHelper.element_tags_attributes | train | def element_tags_attributes(element, options = {})
options = {
formatter: lambda { |tags| tags.join(' ') }
}.merge(options)
return {} if !element.taggable? || element.tag_list.blank?
{ 'data-element-tags' => options[:formatter].call(element.tag_list) }
end | ruby | {
"resource": ""
} |
q15365 | Alchemy.Element.next | train | def next(name = nil)
elements = page.elements.published.where('position > ?', position)
select_element(elements, name, :asc)
end | ruby | {
"resource": ""
} |
q15366 | Alchemy.Element.copy_nested_elements_to | train | def copy_nested_elements_to(target_element)
nested_elements.map do |nested_element|
Element.copy(nested_element, {
parent_element_id: target_element.id,
page_id: target_element.page_id
})
end
end | ruby | {
"resource": ""
} |
q15367 | Alchemy.Element::ElementEssences.essence_error_messages | train | def essence_error_messages
messages = []
essence_errors.each do |content_name, errors|
errors.each do |error|
messages << Alchemy.t(
"#{name}.#{content_name}.#{error}",
scope: 'content_validations',
default: [
"fields.#{content_name}.#{erro... | ruby | {
"resource": ""
} |
q15368 | Alchemy.PagesHelper.language_links | train | def language_links(options = {})
options = {
linkname: 'name',
show_title: true,
spacer: '',
reverse: false
}.merge(options)
languages = Language.on_current_site.published.with_root_page.order("name #{options[:reverse] ? 'DESC' : 'ASC'}")
return nil if languages.c... | ruby | {
"resource": ""
} |
q15369 | Alchemy.PagesHelper.render_navigation | train | def render_navigation(options = {}, html_options = {})
options = {
submenu: false,
all_sub_menues: false,
from_page: @root_page || Language.current_root_page,
spacer: nil,
navigation_partial: 'alchemy/navigation/renderer',
navigation_link_partial: 'alchemy/navigatio... | ruby | {
"resource": ""
} |
q15370 | Alchemy.PagesHelper.external_page_css_class | train | def external_page_css_class(page)
return nil if !page.redirects_to_external?
request.path.split('/').delete_if(&:blank?).first == page.urlname.gsub(/^\//, '') ? 'active' : nil
end | ruby | {
"resource": ""
} |
q15371 | Alchemy.PagesHelper.render_breadcrumb | train | def render_breadcrumb(options = {})
options = {
separator: ">",
page: @page,
restricted_only: false,
reverse: false,
link_active_page: false
}.merge(options)
pages = Page.
ancestors_for(options[:page]).
accessible_by(current_ability, :see)
... | ruby | {
"resource": ""
} |
q15372 | Alchemy.PagesHelper.page_title | train | def page_title(options = {})
return "" if @page.title.blank?
options = {
prefix: "",
suffix: "",
separator: ""
}.update(options)
title_parts = [options[:prefix]]
if response.status == 200
title_parts << @page.title
else
title_parts << response.... | ruby | {
"resource": ""
} |
q15373 | Alchemy.Api::PagesController.index | train | def index
# Fix for cancancan not able to merge multiple AR scopes for logged in users
if can? :edit_content, Alchemy::Page
@pages = Page.all
else
@pages = Page.accessible_by(current_ability, :index)
end
if params[:page_layout].present?
@pages = @pages.where(page_la... | ruby | {
"resource": ""
} |
q15374 | Alchemy.Api::PagesController.nested | train | def nested
@page = Page.find_by(id: params[:page_id]) || Language.current_root_page
render json: PageTreeSerializer.new(@page,
ability: current_ability,
user: current_alchemy_user,
elements: params[:elements],
full: true)
end | ruby | {
"resource": ""
} |
q15375 | Alchemy.Api::ElementsController.index | train | def index
@elements = Element.not_nested
# Fix for cancancan not able to merge multiple AR scopes for logged in users
if cannot? :manage, Alchemy::Element
@elements = @elements.accessible_by(current_ability, :index)
end
if params[:page_id].present?
@elements = @elements.whe... | ruby | {
"resource": ""
} |
q15376 | Alchemy.ConfigurationMethods.prefix_locale? | train | def prefix_locale?(locale = Language.current.code)
multi_language? && locale != ::I18n.default_locale.to_s
end | ruby | {
"resource": ""
} |
q15377 | Alchemy.Modules.module_definition_for | train | def module_definition_for(name_or_params)
case name_or_params
when String
alchemy_modules.detect { |m| m['name'] == name_or_params }
when Hash
name_or_params.stringify_keys!
alchemy_modules.detect do |alchemy_module|
module_navi = alchemy_module.fetch('navigation', {}... | ruby | {
"resource": ""
} |
q15378 | Alchemy.Api::ContentsController.index | train | def index
# Fix for cancancan not able to merge multiple AR scopes for logged in users
if can? :manage, Alchemy::Content
@contents = Content.all
else
@contents = Content.accessible_by(current_ability, :index)
end
if params[:element_id].present?
@contents = @contents... | ruby | {
"resource": ""
} |
q15379 | Alchemy.Api::ContentsController.show | train | def show
if params[:id]
@content = Content.find(params[:id])
elsif params[:element_id] && params[:name]
@content = Content.find_by!(element_id: params[:element_id], name: params[:name])
end
authorize! :show, @content
respond_with @content
end | ruby | {
"resource": ""
} |
q15380 | Alchemy.Site.create_default_language! | train | def create_default_language!
default_language = Alchemy::Config.get(:default_language)
if default_language
languages.build(
name: default_language['name'],
language_code: default_language['code'],
locale: default_language['code'],
frontpage_... | ruby | {
"resource": ""
} |
q15381 | Alchemy.UrlHelper.show_page_path_params | train | def show_page_path_params(page, optional_params = {})
raise ArgumentError, 'Page is nil' if page.nil?
url_params = {urlname: page.urlname}.update(optional_params)
prefix_locale? ? url_params.update(locale: page.language_code) : url_params
end | ruby | {
"resource": ""
} |
q15382 | Alchemy.PageRedirects.page_redirect_url | train | def page_redirect_url(options = {})
options = {
locale: prefix_locale? ? @page.language_code : nil,
urlname: @page.urlname
}.merge(options)
alchemy.show_page_path additional_params.merge(options)
end | ruby | {
"resource": ""
} |
q15383 | ActsAsBookable.Bookable.bookable | train | def bookable(options)
if bookable?
self.booking_opts = options
else
class_attribute :booking_opts
self.booking_opts = options
class_eval do
serialize :schedule, IceCube::Schedule
has_many :bookings, as: :bookable, dependent: :destroy, class_name: '::Act... | ruby | {
"resource": ""
} |
q15384 | ActsAsBookable.Booking.bookable_must_be_bookable | train | def bookable_must_be_bookable
if bookable.present? && !bookable.class.bookable?
errors.add(:bookable, T.er('booking.bookable_must_be_bookable', model: bookable.class.to_s))
end
end | ruby | {
"resource": ""
} |
q15385 | ActsAsBookable.Booking.booker_must_be_booker | train | def booker_must_be_booker
if booker.present? && !booker.class.booker?
errors.add(:booker, T.er('booking.booker_must_be_booker', model: booker.class.to_s))
end
end | ruby | {
"resource": ""
} |
q15386 | Howitzer.CapybaraHelpers.cloud_driver | train | def cloud_driver(app, caps, url)
http_client = ::Selenium::WebDriver::Remote::Http::Default.new
http_client.read_timeout = Howitzer.cloud_http_idle_timeout
http_client.open_timeout = Howitzer.cloud_http_idle_timeout
options = {
url: url,
desired_capabilities: ::Selenium::WebDriv... | ruby | {
"resource": ""
} |
q15387 | K8s.Logging.logger! | train | def logger!(progname: self.class.name, target: LOG_TARGET, level: nil, debug: false)
@logger = Logger.new(target).tap do |logger|
level = Logger::DEBUG if debug
logger.progname = "#{self.class.name}<#{progname}>"
logger.level = level || self.class.log_level || K8s::Logging.log_level || LO... | ruby | {
"resource": ""
} |
q15388 | K8s.Stack.prune | train | def prune(client, keep_resources:, skip_forbidden: true)
# using skip_forbidden: assume we can't create resource types that we are forbidden to list, so we don't need to prune them either
client.list_resources(labelSelector: { @label => name }, skip_forbidden: skip_forbidden).sort do |a, b|
# Sort r... | ruby | {
"resource": ""
} |
q15389 | K8s.Client.get_resources | train | def get_resources(resources)
# prefetch api resources, skip missing APIs
resource_apis = apis(resources.map(&:apiVersion), prefetch_resources: true, skip_missing: true)
# map each resource to excon request options, or nil if resource is not (yet) defined
requests = resources.zip(resource_apis).... | ruby | {
"resource": ""
} |
q15390 | ActiveShipping.FedEx.create_shipment | train | def create_shipment(origin, destination, packages, options = {})
options = @options.merge(options)
packages = Array(packages)
raise Error, "Multiple packages are not supported yet." if packages.length > 1
request = build_shipment_request(origin, destination, packages, options)
logger.debu... | ruby | {
"resource": ""
} |
q15391 | ActiveShipping.Carrier.timestamp_from_business_day | train | def timestamp_from_business_day(days)
return unless days
date = DateTime.now.utc
days.times do
date += 1.day
date += 2.days if date.saturday?
date += 1.day if date.sunday?
end
date.to_datetime
end | ruby | {
"resource": ""
} |
q15392 | ActiveShipping.RateEstimate.add | train | def add(package, rate = nil)
cents = Package.cents_from(rate)
raise ArgumentError.new("New packages must have valid rate information since this RateEstimate has no total_price set.") if cents.nil? and total_price.nil?
@package_rates << {:package => package, :rate => cents}
self
end | ruby | {
"resource": ""
} |
q15393 | ActiveShipping.CanadaPostPWS.create_shipment | train | def create_shipment(origin, destination, package, line_items = [], options = {})
request_body = build_shipment_request(origin, destination, package, line_items, options)
response = ssl_post(create_shipment_url(options), request_body, headers(options, SHIPMENT_MIMETYPE, SHIPMENT_MIMETYPE))
parse_shipme... | ruby | {
"resource": ""
} |
q15394 | ActiveAdminImport.Importer.batch_slice_columns | train | def batch_slice_columns(slice_columns)
use_indexes = []
headers.values.each_with_index do |val, index|
use_indexes << index if val.in?(slice_columns)
end
return csv_lines if use_indexes.empty?
# slice CSV headers
@headers = headers.to_a.values_at(*use_indexes).to_h
# sl... | ruby | {
"resource": ""
} |
q15395 | Anemone.PageStore.has_page? | train | def has_page?(url)
schemes = %w(http https)
if schemes.include? url.scheme
u = url.dup
return schemes.any? { |s| u.scheme = s; has_key?(u) }
end
has_key? url
end | ruby | {
"resource": ""
} |
q15396 | Anemone.Core.run | train | def run
process_options
@urls.delete_if { |url| !visit_link?(url) }
return if @urls.empty?
link_queue = Queue.new
page_queue = Queue.new
@opts[:threads].times do
@tentacles << Thread.new { Tentacle.new(link_queue, page_queue, @opts).run }
end
@urls.each{ |url|... | ruby | {
"resource": ""
} |
q15397 | Anemone.Core.freeze_options | train | def freeze_options
@opts.freeze
@opts.each_key { |key| @opts[key].freeze }
@opts[:cookies].each_key { |key| @opts[:cookies][key].freeze } rescue nil
end | ruby | {
"resource": ""
} |
q15398 | Anemone.HTTP.allowed? | train | def allowed?(to_url, from_url)
to_url.host.nil? || (to_url.host == from_url.host)
end | ruby | {
"resource": ""
} |
q15399 | Anemone.Tentacle.run | train | def run
loop do
link, referer, depth = @link_queue.deq
break if link == :END
@http.fetch_pages(link, referer, depth).each { |page| @page_queue << page }
delay
end
end | ruby | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.