_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_name.underscore
load "#{filename}.rb"
return class_name.constantize
end
return controller
end | 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)
expanded_nested_elements = nested_elements.expanded
if expanded_nested_elements.present?
ids += expanded_nested_elements.collect(&:richtext_contents_ids)
end
ids.flatten
end | 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 @_element_definitions.blank?
@_existing_element_names = elements_including_fixed.pluck(:name)
delete_unique_element_definitions!
delete_outnumbered_element_definitions!
@_element_definitions
end | 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']
end
else
available_element_definitions
end
end | 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 method name as a callback for `on_page_layout`"
end
end
end | 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.new(self, element: element) if block_given?
end
# wrap output in a useful DOM element
if tag = options.delete(:tag)
# add preview attributes
options.merge!(element_preview_code_attributes(element))
# add tags
if tags_formatter = options.delete(:tags_formatter)
options.merge!(element_tags_attributes(element, formatter: tags_formatter))
end
output = content_tag(tag, output, options)
end
# that's it!
output
end | 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 MissingImageFileError, WrongImageFormatError => e
log_warning e.message
nil
end | 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)
end
end | 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_format == 'gif'
}.merge(options)
encoding_options = []
if target_format =~ /jpe?g/
quality = options[:quality] || Config.get(:output_image_jpg_quality)
encoding_options << "-quality #{quality}"
end
if options[:flatten]
encoding_options << '-flatten'
end
convertion_needed = target_format != image_file_format || encoding_options.present?
if has_convertible_format? && convertion_needed
image = image.encode(target_format, encoding_options.join(' '))
end
image
end | 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 attribute_value && attribute[:type].to_s =~ /(date|time)/
localization_format = if attribute[:type] == :datetime
options[:datetime_format] || :'alchemy.default'
elsif attribute[:type] == :date
options[:date_format] || :'alchemy.default'
else
options[:time_format] || :'alchemy.time'
end
value = l(attribute_value, format: localization_format)
else
value = attribute_value
end
options.reverse_merge!(truncate: 50)
if options[:truncate]
value.to_s.truncate(options.fetch(:truncate, 50))
else
value
end
end | 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]) || Time.current
options.merge(
as: 'string',
input_html: {
'data-datepicker-type' => input_type,
value: date ? date.iso8601 : nil
}
)
when 'text'
options.merge(as: 'text', input_html: {rows: 4})
else
options.merge(as: 'string')
end
end | 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] }
end
end | 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] || "#{association.name}_id".to_sym
resource_relations[foreign_key] = options.merge(model_association: association, name: name)
end
end | 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 + 1}. #{todo[0]}"
log title, :message
puts '=' * title.length
puts ""
log todo[1], :message
end
puts ""
puts "============================================================"
puts "= ✨ Please take a minute and read the notes from above ✨ ="
puts "============================================================"
puts ""
end | 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)}#{message}"
else
puts "#{color(:green)}== #{message}#{color(:clear)}"
end
end
end | 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.presence,
crop_size: crop_size.presence,
flatten: true,
format: picture.image_file_format
}
picture.url(options)
end | 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_size)
point_and_mask_to_points(top_left, crop_size)
end | 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[:height] = get_base_dimensions[:height] if size[:height].zero?
size = reduce_to_image(size)
else
size = get_base_dimensions
end
size = size_when_fitting({width: THUMBNAIL_WIDTH, height: THUMBNAIL_HEIGHT}, size)
"#{size[:width]}x#{size[:height]}"
end | 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, top_left, crop_dimensions, upsample)
else
center_crop(render_to, upsample)
end
end | 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[:width] / zoom).round
height = (dimensions[:height] / zoom).round
end
{width: width.to_i, height: height.to_i}
end | 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
image_file.convert "#{crop_argument} #{resize_argument}"
end | 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,
options[:class]
].compact
content_tag('i', nil, class: classes)
end | 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 ? "" : warning('Essence is nil', Alchemy.t(:content_essence_not_found))
end
render partial: "alchemy/essences/#{content.essence_partial_name}_#{part}", locals: {
content: content,
options: options["for_#{part}".to_sym],
html_options: html_options
}
end | 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_session ||
Language.default
end
store_current_alchemy_language(@language)
end | 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 custom finder instance to options[:finder]."
end
if options[:from_cell]
Alchemy::Deprecation.warn "options[:from_cell] has been removed without replacement. " \
"Please `render element.nested_elements.available` instead."
end
finder = options[:finder] || Alchemy::ElementsFinder.new(options)
elements = finder.elements(page: options[:from_page])
buff = []
elements.each_with_index do |element, i|
buff << render_element(element, options, i + 1)
end
buff.join(options[:separator]).html_safe
end | 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}.#{error}".to_sym,
"errors.#{error}".to_sym
],
field: Content.translated_label_for(content_name, name)
)
end
end
messages
end | 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.count < 2
render(
partial: "alchemy/language_links/language",
collection: languages,
spacer_template: "alchemy/language_links/spacer",
locals: {languages: languages, options: options}
)
end | 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/navigation/link',
show_nonactive: false,
restricted_only: false,
show_title: true,
reverse: false,
reverse_children: false
}.merge(options)
page = page_or_find(options[:from_page])
return nil if page.blank?
pages = page.children.accessible_by(current_ability, :see)
pages = pages.restricted if options.delete(:restricted_only)
if depth = options[:deepness]
pages = pages.where('depth <= ?', depth)
end
if options[:reverse]
pages.reverse!
end
render options[:navigation_partial],
options: options,
pages: pages,
html_options: html_options
end | 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)
if options.delete(:restricted_only)
pages = pages.restricted
end
if options.delete(:reverse)
pages = pages.reorder('lft DESC')
end
if options[:without].present?
without = options.delete(:without)
pages = pages.where.not(id: without.try(:collect, &:id) || without.id)
end
render 'alchemy/breadcrumb/wrapper', pages: pages, options: options
end | 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.status
end
title_parts << options[:suffix]
title_parts.reject(&:blank?).join(options[:separator]).html_safe
end | 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_layout: params[:page_layout])
end
render json: @pages, adapter: :json, root: :pages
end | 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.where(page_id: params[:page_id])
end
if params[:named].present?
@elements = @elements.named(params[:named])
end
render json: @elements, adapter: :json, root: :elements
end | 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', {})
definition_from_mainnavi(module_navi, name_or_params) ||
definition_from_subnavi(module_navi, name_or_params)
end
else
raise ArgumentError, "Could not find module definition for #{name_or_params}"
end
end | 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.where(element_id: params[:element_id])
end
render json: @contents, adapter: :json, root: :contents
end | 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_name: default_language['frontpage_name'],
page_layout: default_language['page_layout'],
public: true,
default: true
)
else
raise DefaultLanguageNotFoundError
end
end | 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: '::ActsAsBookable::Booking'
validates_presence_of :schedule, if: :schedule_required?
validates_presence_of :capacity, if: :capacity_required?
validates_numericality_of :capacity, if: :capacity_required?, only_integer: true, greater_than_or_equal_to: 0
def self.bookable?
true
end
def schedule_required?
self.booking_opts && self.booking_opts && self.booking_opts[:time_type] != :none
end
def capacity_required?
self.booking_opts && self.booking_opts[:capacity_type] != :none
end
end
end
include Core
end | 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::WebDriver::Remote::Capabilities.new(caps),
http_client: http_client,
browser: :remote
}
driver = Capybara::Selenium::Driver.new(app, options)
driver.browser.file_detector = remote_file_detector
driver
end | 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 || LOG_LEVEL
end
end | 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 resources so that namespaced objects are deleted first
if a.metadata.namespace == b.metadata.namespace
0
elsif a.metadata.namespace.nil? && !b.metadata.namespace.nil?
1
else
-1
end
end.each do |resource|
next if PRUNE_IGNORE.include? "#{resource.apiVersion}:#{resource.kind}"
resource_label = resource.metadata.labels ? resource.metadata.labels[@label] : nil
resource_checksum = resource.metadata.annotations ? resource.metadata.annotations[@checksum_annotation] : nil
logger.debug { "List resource #{resource.apiVersion}:#{resource.kind}/#{resource.metadata.name} in namespace #{resource.metadata.namespace} with checksum=#{resource_checksum}" }
if resource_label != name
# apiserver did not respect labelSelector
elsif keep_resources && keep_resource?(resource)
# resource is up-to-date
else
logger.info "Delete resource #{resource.apiVersion}:#{resource.kind}/#{resource.metadata.name} in namespace #{resource.metadata.namespace}"
begin
client.delete_resource(resource, propagationPolicy: 'Background')
rescue K8s::Error::NotFound => e
# assume aliased objects in multiple API groups, like for Deployments
# alternatively, a custom resource whose definition was already deleted earlier
logger.debug { "Ignoring #{e} : #{e.message}" }
end
end
end
end | 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).map{ |resource, api_client|
next nil unless api_client.api_resources?
resource_client = api_client.client_for_resource(resource)
{
method: 'GET',
path: resource_client.path(resource.metadata.name, namespace: resource.metadata.namespace),
response_class: resource_client.resource_class
}
}
# map non-nil requests to response objects, or nil for nil request options
Util.compact_map(requests) { |reqs|
@transport.requests(*reqs, skip_missing: true)
}
end | 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.debug(request) if logger
response = commit(save_request(request), (options[:test] || false))
parse_ship_response(response)
end | 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_shipment_response(response)
rescue ActiveUtils::ResponseError, ActiveShipping::ResponseError => e
error_response(e.response.body, CPPWSShippingResponse)
rescue MissingCustomerNumberError
CPPWSShippingResponse.new(false, "Missing Customer Number", {}, :carrier => @@name)
end | 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
# slice CSV values
csv_lines.map! do |line|
line.values_at(*use_indexes)
end
end | 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| link_queue.enq(url) }
loop do
page = page_queue.deq
@pages.touch_key page.url
puts "#{page.url} Queue: #{link_queue.size}" if @opts[:verbose]
do_page_blocks page
page.discard_doc! if @opts[:discard_page_bodies]
links = links_to_follow page
links.each do |link|
link_queue << [link, page.url.dup, page.depth + 1]
end
@pages.touch_keys links
@pages[page.url] = page
# if we are done with the crawl, tell the threads to end
if link_queue.empty? and page_queue.empty?
until link_queue.num_waiting == @tentacles.size
Thread.pass
end
if page_queue.empty?
@tentacles.size.times { link_queue << :END }
break
end
end
end
@tentacles.each { |thread| thread.join }
do_after_crawl_blocks
self
end | 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.