_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3
values | text stringlengths 66 10.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q17100 | ActiveMocker.Queries.sum | train | def sum(key)
values = values_by_key(key)
values.inject(0) do |sum, n|
sum + (n || 0)
end
end | ruby | {
"resource": ""
} |
q17101 | ActiveMocker.Queries.average | train | def average(key)
values = values_by_key(key)
total = values.inject { |sum, n| sum + n }
BigDecimal.new(total) / BigDecimal.new(values.count)
end | ruby | {
"resource": ""
} |
q17102 | ActiveMocker.Base.slice | train | def slice(*methods)
Hash[methods.map! { |method| [method, public_send(method)] }].with_indifferent_access
end | ruby | {
"resource": ""
} |
q17103 | Danger.DangerXcodeSummary.warning_error_count | train | def warning_error_count(file_path)
if File.file?(file_path)
xcode_summary = JSON.parse(File.read(file_path), symbolize_names: true)
warning_count = warnings(xcode_summary).count
error_count = errors(xcode_summary).count
result = { warnings: warning_count, errors: error_count }
... | ruby | {
"resource": ""
} |
q17104 | RegexpExamples.MultiGroup.result | train | def result
strings = @groups.map { |repeater| repeater.public_send(__callee__) }
RegexpExamples.permutations_of_strings(strings).map do |result|
GroupResult.new(result, group_id)
end
end | ruby | {
"resource": ""
} |
q17105 | Bh.Helpers.button | train | def button(*args, &block)
button = Bh::Button.new(self, *args, &block)
button.extract! :context, :size, :layout
button.append_class! :btn
button.append_class! button.context_class
button.append_class! button.size_class
button.append_class! button.layout_class
button.render_tag... | ruby | {
"resource": ""
} |
q17106 | Bh.Helpers.panel_row | train | def panel_row(options = {}, &block)
panel_row = Bh::PanelRow.new self, options, &block
panel_row.extract! :column_class
panel_row.append_class! :row
panel_row.render_tag :div
end | ruby | {
"resource": ""
} |
q17107 | Bh.Helpers.panel | train | def panel(*args, &block)
panel = Bh::Panel.new self, *args, &block
panel.extract! :body, :context, :title, :heading, :tag
panel.append_class! :panel
panel.append_class! panel.context_class
panel.merge_html! panel.body
panel.prepend_html! panel.heading
if panel_row = Bh::Stack... | ruby | {
"resource": ""
} |
q17108 | Bh.Helpers.modal | train | def modal(*args, &block)
modal = Bh::Modal.new self, *args, &block
modal.extract! :button, :size, :body, :title, :id
modal.extract_from :button, [:context, :size, :layout, :caption]
modal.append_class_to! :button, :btn
modal.append_class_to! :button, modal.button_context_class
modal... | ruby | {
"resource": ""
} |
q17109 | Bh.Helpers.nav | train | def nav(options = {}, &block)
nav = Bh::Nav.new(self, options, &block)
nav.extract! :as, :layout
nav.append_class! :nav
if Bh::Stack.find(Bh::Navbar)
nav.append_class! :'navbar-nav'
else
nav.merge! role: :tablist
nav.append_class! nav.style_class
nav.append... | ruby | {
"resource": ""
} |
q17110 | Bh.Helpers.horizontal | train | def horizontal(*args, &block)
if navbar = Bh::Stack.find(Bh::Navbar)
horizontal = Bh::Base.new self, *args, &block
horizontal.append_class! :'collapse navbar-collapse'
horizontal.merge! id: navbar.id
horizontal.render_tag :div
end
end | ruby | {
"resource": ""
} |
q17111 | Bh.Helpers.icon | train | def icon(name = nil, options = {})
icon = Bh::Icon.new self, nil, options.merge(name: name)
icon.extract! :library, :name
icon.append_class! icon.library_class
icon.append_class! icon.name_class
icon.render_tag :span
end | ruby | {
"resource": ""
} |
q17112 | Bh.Helpers.vertical | train | def vertical(*args, &block)
if navbar = Bh::Stack.find(Bh::Navbar)
vertical = Bh::Vertical.new self, *args, &block
vertical.append_class! :'navbar-header'
vertical.prepend_html! vertical.toggle_button(navbar.id)
vertical.render_tag :div
end
end | ruby | {
"resource": ""
} |
q17113 | Bh.Helpers.progress_bar | train | def progress_bar(args = nil, container_options = {})
progress_bars = Array.wrap(args).map do |options|
progress_bar = Bh::ProgressBar.new self, nil, options
progress_bar.extract! :percentage, :context, :striped, :animated, :label
progress_bar.merge! progress_bar.aria_values
progre... | ruby | {
"resource": ""
} |
q17114 | Bh.Helpers.navbar | train | def navbar(options = {}, &block)
navbar = Bh::Navbar.new(self, options, &block)
navbar.extract! :inverted, :position, :padding, :fluid, :id
navbar.append_class_to! :navigation, :navbar
navbar.append_class_to! :navigation, navbar.style_class
navbar.append_class_to! :navigation, navbar.posi... | ruby | {
"resource": ""
} |
q17115 | Bh.Helpers.link_to | train | def link_to(*args, &block)
link_to = Bh::LinkTo.new self, *args, &block
link_to.append_class! :'alert-link' if Bh::Stack.find(Bh::AlertBox)
link_to.append_class! :'navbar-brand' if Bh::Stack.find(Bh::Vertical)
link_to.merge! role: :menuitem if Bh::Stack.find(Bh::Dropdown)
link_to.merge! t... | ruby | {
"resource": ""
} |
q17116 | Bh.Helpers.alert_box | train | def alert_box(*args, &block)
alert_box = Bh::AlertBox.new(self, *args, &block)
alert_box.extract! :context, :priority, :dismissible
alert_box.append_class! :alert
alert_box.append_class! alert_box.context_class
alert_box.merge! role: :alert
alert_box.prepend_html! alert_box.dismissi... | ruby | {
"resource": ""
} |
q17117 | Jekyll.OctopodFilters.otherwise | train | def otherwise(first, second)
first = first.to_s
first.empty? ? second : first
end | ruby | {
"resource": ""
} |
q17118 | Jekyll.OctopodFilters.audio | train | def audio(hsh, key = nil)
if !hsh.nil? && hsh.length
if key.nil?
hsh['mp3'] ? hsh['mp3'] : hsh['m4a'] ? hsh['m4a'] : hsh['ogg'] ? hsh['ogg'] : hsh['opus'] ? hsh['opus'] : hsh.values.first
else
hsh[key]
end
end
end | ruby | {
"resource": ""
} |
q17119 | Jekyll.OctopodFilters.audio_type | train | def audio_type(hsh)
if !hsh.nil? && hsh.length
hsh['mp3'] ? mime_type('mp3') : hsh['m4a'] ? mime_type('m4a') : hsh['ogg'] ? mime_type('ogg') : mime_type('opus')
end
end | ruby | {
"resource": ""
} |
q17120 | Jekyll.OctopodFilters.split_chapter | train | def split_chapter(chapter_str, attribute = nil)
attributes = chapter_str.split(/ /, 2)
return nil unless attributes.first.match(/\A(\d|:|\.)+\z/)
if attribute.nil?
{ 'start' => attributes.first, 'title' => attributes.last }
else
attribute == 'start' ? attributes.first : attribut... | ruby | {
"resource": ""
} |
q17121 | Jekyll.OctopodFilters.string_of_size | train | def string_of_size(bytes)
bytes = bytes.to_i.to_f
out = '0'
return out if bytes == 0.0
jedec = %w[b K M G]
[3, 2, 1, 0].each { |i|
if bytes > 1024 ** i
out = "%.1f#{jedec[i]}" % (bytes / 1024 ** i)
break
end
}
return out
end | ruby | {
"resource": ""
} |
q17122 | Jekyll.OctopodFilters.disqus_config | train | def disqus_config(site, page = nil)
if page
disqus_vars = {
'disqus_identifier' => page['url'],
'disqus_url' => "#{site['url']}#{page['url']}",
'disqus_category_id' => page['disqus_category_id'] || site['disqus_category_id'],
'disqus_title' => j(page[... | ruby | {
"resource": ""
} |
q17123 | Jekyll.OctopodFilters.sha1 | train | def sha1(str, lenght = 8)
sha1 = Digest::SHA1.hexdigest(str)
sha1[0, lenght.to_i]
end | ruby | {
"resource": ""
} |
q17124 | Jekyll.DateDe.format_date | train | def format_date(date, format)
date = datetime(date)
if format.nil? || format.empty? || format == "ordinal"
date_formatted = ordinalize(date)
else
format.gsub!(/%a/, ABBR_DAYNAMES_DE[date.wday])
format.gsub!(/%A/, DAYNAMES_DE[date.wday])
format.gsub!(/%b/, AB... | ruby | {
"resource": ""
} |
q17125 | Jekyll.FlattrFilters.flattr_loader_options | train | def flattr_loader_options(site)
return if site['flattr_uid'].nil?
keys = %w[mode https popout uid button language category]
options = flattr_options(site, nil, keys).delete_if { |_, v| v.to_s.empty? }
options.map { |k, v| "#{k}=#{ERB::Util.url_encode(v)}" }.join('&')
end | ruby | {
"resource": ""
} |
q17126 | Jekyll.FlattrFilters.flattr_button | train | def flattr_button(site, page = nil)
return if site['flattr_uid'].nil?
keys = %w[url title description uid popout button category language tags]
options = flattr_options(site, page, keys)
button = '<a class="FlattrButton" style="display:none;" '
button << %Q{title="#{options.delete('titl... | ruby | {
"resource": ""
} |
q17127 | Jekyll.FlattrFilters.flattrize | train | def flattrize(hsh)
config = {}
hsh.to_hash.each { |k, v|
if new_key = k.to_s.match(/\Aflattr_(.*)\z/)
config[new_key[1]] = v
else
config[k] = v
end
}
config
end | ruby | {
"resource": ""
} |
q17128 | Prius.Registry.load | train | def load(name, options = {})
env_var = options.fetch(:env_var, name.to_s.upcase)
type = options.fetch(:type, :string)
required = options.fetch(:required, true)
@registry[name] = case type
when :string then load_string(env_var, required)
when :int ... | ruby | {
"resource": ""
} |
q17129 | Interferon.Interferon.run | train | def run
start_time = Time.new.to_f
Signal.trap('TERM') do
log.info('SIGTERM received. shutting down gracefully...')
@request_shutdown = true
end
run_desc = @dry_run ? 'dry run' : 'run'
log.info("beginning alerts #{run_desc}")
alerts = read_alerts(@alert_sources)
... | ruby | {
"resource": ""
} |
q17130 | Interferon::HostSources.AwsRds.account_number | train | def account_number
return @account_number if @account_number
begin
my_arn = AWS::IAM.new(
access_key_id: @access_key_id,
secret_access_key: @secret_access_key
).client.get_user[:user][:arn]
rescue AWS::IAM::Errors::AccessDenied => e
my_arn = e.message.split... | ruby | {
"resource": ""
} |
q17131 | TimeMath.Op.call | train | def call(*tms)
unless @arguments.empty?
tms.empty? or raise(ArgumentError, 'Op arguments is already set, use call()')
tms = @arguments
end
res = [*tms].flatten.map(&method(:perform))
tms.count == 1 && Util.timey?(tms.first) ? res.first : res
end | ruby | {
"resource": ""
} |
q17132 | Tire.Alias.indices | train | def indices(*names)
names = Array(names).flatten
names.compact.empty? ? @attributes[:indices] : (names.each { |n| @attributes[:indices].push(n) } and return self)
end | ruby | {
"resource": ""
} |
q17133 | Tire.Alias.filter | train | def filter(type=nil, *options)
type ? (@attributes[:filter] = Search::Filter.new(type, *options).to_hash and return self ) : @attributes[:filter]
end | ruby | {
"resource": ""
} |
q17134 | Tire.Alias.as_json | train | def as_json(options=nil)
actions = []
indices.add_indices.each do |index|
operation = { :index => index, :alias => name }
operation.update( { :routing => routing } ) if respond_to?(:routing) and routing
operation.update( { :filter => filter } ) if respond_to?(:filter) and filter
... | ruby | {
"resource": ""
} |
q17135 | Tire.Index.mapping! | train | def mapping!(*args)
mapping(*args)
raise RuntimeError, response.body unless response.success?
end | ruby | {
"resource": ""
} |
q17136 | AmazonSellerCentral.InventoryPage.listing_row_to_object | train | def listing_row_to_object(row)
l = Listing.new
row.css('td').each_with_index do |td, i|
txt = td.text.strip # yes, slightly slower to do this here, but I type less.
case i
when 4
l.sku = txt
when 5
l.asin = txt
when 6
... | ruby | {
"resource": ""
} |
q17137 | Gruff.Base.theme= | train | def theme=(options)
reset_themes
defaults = {
:colors => %w(black white),
:additional_line_colors => [],
:marker_color => 'white',
:marker_shadow_color => nil,
:font_color => 'black',
:background_colors => nil,
:background_image => nil
... | ruby | {
"resource": ""
} |
q17138 | Gruff.Base.data | train | def data(name, data_points=[], color=nil)
data_points = Array(data_points) # make sure it's an array
@data << [name, data_points, color]
# Set column count if this is larger than previous counts
@column_count = (data_points.length > @column_count) ? data_points.l... | ruby | {
"resource": ""
} |
q17139 | Gruff.Base.draw | train | def draw
# Maybe should be done in one of the following functions for more granularity.
unless @has_data
draw_no_data
return
end
setup_data
setup_drawing
debug {
# Outer margin
@d.rectangle(@left_margin, @top_margin,
@raw_columns... | ruby | {
"resource": ""
} |
q17140 | Gruff.Base.normalize | train | def normalize(force=false)
if @norm_data.nil? || force
@norm_data = []
return unless @has_data
@data.each do |data_row|
norm_data_points = []
data_row[DATA_VALUES_INDEX].each do |data_point|
if data_point.nil?
norm_data_points << nil
... | ruby | {
"resource": ""
} |
q17141 | Gruff.Base.setup_graph_measurements | train | def setup_graph_measurements
@marker_caps_height = @hide_line_markers ? 0 :
calculate_caps_height(@marker_font_size)
@title_caps_height = (@hide_title || @title.nil?) ? 0 :
calculate_caps_height(@title_font_size) * @title.lines.to_a.size
@legend_caps_height = @hide_legend ? 0 :
... | ruby | {
"resource": ""
} |
q17142 | Gruff.Base.draw_axis_labels | train | def draw_axis_labels
unless @x_axis_label.nil?
# X Axis
# Centered vertically and horizontally by setting the
# height to 1.0 and the width to the width of the graph.
x_axis_label_y_coordinate = @graph_bottom + LABEL_MARGIN * 2 + @marker_caps_height
# TODO Center between g... | ruby | {
"resource": ""
} |
q17143 | Gruff.Base.draw_line_markers | train | def draw_line_markers
return if @hide_line_markers
@d = @d.stroke_antialias false
if @y_axis_increment.nil?
# Try to use a number of horizontal lines that will come out even.
#
# TODO Do the same for larger numbers...100, 75, 50, 25
if @marker_count.nil?
(3.... | ruby | {
"resource": ""
} |
q17144 | Gruff.Base.draw_legend | train | def draw_legend
return if @hide_legend
@legend_labels = @data.collect { |item| item[DATA_LABEL_INDEX] }
legend_square_width = @legend_box_size # small square with color of this item
# May fix legend drawing problem at small sizes
@d.font = @font if @font
@d.pointsize = @legend_fon... | ruby | {
"resource": ""
} |
q17145 | Gruff.Base.draw_title | train | def draw_title
return if (@hide_title || @title.nil?)
@d.fill = @font_color
@d.font = @title_font || @font if @title_font || @font
@d.stroke('transparent')
@d.pointsize = scale_fontsize(@title_font_size)
@d.font_weight = if @bold_title then BoldWeight else NormalWeight end
@d.... | ruby | {
"resource": ""
} |
q17146 | Gruff.Base.draw_value_label | train | def draw_value_label(x_offset, y_offset, data_point, bar_value=false)
return if @hide_line_markers && !bar_value
#y_offset = @graph_bottom + LABEL_MARGIN
@d.fill = @font_color
@d.font = @font if @font
@d.stroke('transparent')
@d.font_weight = NormalWeight
@d.pointsize = scale... | ruby | {
"resource": ""
} |
q17147 | Gruff.Base.draw_no_data | train | def draw_no_data
@d.fill = @font_color
@d.font = @font if @font
@d.stroke('transparent')
@d.font_weight = NormalWeight
@d.pointsize = scale_fontsize(80)
@d.gravity = CenterGravity
@d = @d.annotate_scaled(@base_image,
@raw_columns, @raw_rows/2.0,
... | ruby | {
"resource": ""
} |
q17148 | Gruff.Base.render_gradiated_background | train | def render_gradiated_background(top_color, bottom_color, direct = :top_bottom)
case direct
when :bottom_top
gradient_fill = GradientFill.new(0, 0, 100, 0, bottom_color, top_color)
when :left_right
gradient_fill = GradientFill.new(0, 0, 0, 100, top_color, bottom_color)
when :right... | ruby | {
"resource": ""
} |
q17149 | Gruff.Base.sort_data | train | def sort_data
@data = @data.sort_by { |a| -a[DATA_VALUES_INDEX].inject(0) { |sum, num| sum + num.to_f } }
end | ruby | {
"resource": ""
} |
q17150 | Gruff.Base.sort_norm_data | train | def sort_norm_data
@norm_data =
@norm_data.sort_by { |a| -a[DATA_VALUES_INDEX].inject(0) { |sum, num| sum + num.to_f } }
end | ruby | {
"resource": ""
} |
q17151 | Gruff.Base.get_maximum_by_stack | train | def get_maximum_by_stack
# Get sum of each stack
max_hash = {}
@data.each do |data_set|
data_set[DATA_VALUES_INDEX].each_with_index do |data_point, i|
max_hash[i] = 0.0 unless max_hash[i]
max_hash[i] += data_point.to_f
end
end
# @maximum_value = 0
... | ruby | {
"resource": ""
} |
q17152 | Gruff.Base.label | train | def label(value, increment)
label = if increment
if increment >= 10 || (increment * 1) == (increment * 1).to_i.to_f
sprintf('%0i', value)
elsif increment >= 1.0 || (increment * 10) == (increment * 10).to_i.to_f
sprintf('%0.1f', value)
... | ruby | {
"resource": ""
} |
q17153 | Gruff.Base.calculate_width | train | def calculate_width(font_size, text)
return 0 if text.nil?
@d.pointsize = font_size
@d.font = @font if @font
@d.get_type_metrics(@base_image, text.to_s).width
end | ruby | {
"resource": ""
} |
q17154 | Magick.Draw.annotate_scaled | train | def annotate_scaled(img, width, height, x, y, text, scale)
scaled_width = (width * scale) >= 1 ? (width * scale) : 1
scaled_height = (height * scale) >= 1 ? (height * scale) : 1
self.annotate(img,
scaled_width, scaled_height,
x * scale, y * scale,
... | ruby | {
"resource": ""
} |
q17155 | TrafficJam.Configuration.limits | train | def limits(action)
@limits ||= {}
limits = @limits[action.to_sym]
raise TrafficJam::LimitNotFound.new(action) if limits.nil?
limits
end | ruby | {
"resource": ""
} |
q17156 | TrafficJam.LimitGroup.increment | train | def increment(amount = 1, time: Time.now)
exceeded_index = limits.find_index do |limit|
!limit.increment(amount, time: time)
end
if exceeded_index
limits[0...exceeded_index].each do |limit|
limit.decrement(amount, time: time)
end
end
exceeded_index.nil?
... | ruby | {
"resource": ""
} |
q17157 | TrafficJam.LimitGroup.increment! | train | def increment!(amount = 1, time: Time.now)
exception = nil
exceeded_index = limits.find_index do |limit|
begin
limit.increment!(amount, time: time)
rescue TrafficJam::LimitExceededError => e
exception = e
true
end
end
if exceeded_index
... | ruby | {
"resource": ""
} |
q17158 | TrafficJam.LimitGroup.decrement | train | def decrement(amount = 1, time: Time.now)
limits.all? { |limit| limit.decrement(amount, time: time) }
end | ruby | {
"resource": ""
} |
q17159 | TrafficJam.LimitGroup.limit_exceeded | train | def limit_exceeded(amount = 1)
limits.each do |limit|
limit_exceeded = limit.limit_exceeded(amount)
return limit_exceeded if limit_exceeded
end
nil
end | ruby | {
"resource": ""
} |
q17160 | TrafficJam.GCRALimit.increment | train | def increment(amount = 1, time: Time.now)
return true if amount == 0
return false if max == 0
raise ArgumentError.new("Amount must be positive") if amount < 0
if amount != amount.to_i
raise ArgumentError.new("Amount must be an integer")
end
return false if amount > max
... | ruby | {
"resource": ""
} |
q17161 | TrafficJam.Limit.increment | train | def increment(amount = 1, time: Time.now)
return amount <= 0 if max.zero?
if amount != amount.to_i
raise ArgumentError.new("Amount must be an integer")
end
timestamp = (time.to_f * 1000).to_i
argv = [timestamp, amount.to_i, max, period * 1000]
result =
begin
... | ruby | {
"resource": ""
} |
q17162 | TrafficJam.LifetimeLimit.used | train | def used
return 0 if max.zero?
amount = redis.get(key) || 0
[amount.to_i, max].min
end | ruby | {
"resource": ""
} |
q17163 | Volt.Dispatcher.dispatch | train | def dispatch(channel, message)
# Dispatch the task in the worker pool. Pas in the meta data
@worker_pool.post do
begin
dispatch_in_thread(channel, message)
rescue => e
err = "Worker Thread Exception for #{message}\n"
err += e.inspect
err += e.backtrac... | ruby | {
"resource": ""
} |
q17164 | Volt.Dispatcher.safe_method? | train | def safe_method?(klass, method_name)
# Make sure the class being called is a Task.
return false unless klass.ancestors.include?(Task)
# Make sure the method is defined on the klass we're using and not up the hiearchy.
# ^ This check prevents methods like #send, #eval, #instance_eval, #class_e... | ruby | {
"resource": ""
} |
q17165 | Volt.Dispatcher.dispatch_in_thread | train | def dispatch_in_thread(channel, message)
callback_id, class_name, method_name, meta_data, *args = message
method_name = method_name.to_sym
# Get the class
klass = Object.send(:const_get, class_name)
promise = Promise.new
cookies = nil
start_time = Time.now.to_f
# Chec... | ruby | {
"resource": ""
} |
q17166 | Volt.Validations.validate | train | def validate(field_name = nil, options = nil, &block)
if block
# Setup a custom validation inside of the current validations block.
if field_name || options
fail 'validate should be passed a field name and options or a block, not both.'
end
@instance_custom_validations <<... | ruby | {
"resource": ""
} |
q17167 | Volt.Validations.mark_all_fields! | train | def mark_all_fields!
# TODO: We can use a Set here, but set was having issues. Check in a
# later version of opal.
fields_to_mark = []
# Look at each validation
validations = self.class.validations_to_run
if validations
fields_to_mark += validations.keys
end
# ... | ruby | {
"resource": ""
} |
q17168 | Volt.Validations.error_in_changed_attributes? | train | def error_in_changed_attributes?
errs = errors
changed_attributes.each_pair do |key, _|
# If any of the fields with errors are also the ones that were
return true if errs[key]
end
false
end | ruby | {
"resource": ""
} |
q17169 | Volt.Validations.run_validations | train | def run_validations(validations = nil)
# Default to running the class level validations
validations ||= self.class.validations_to_run
promise = Promise.new.resolve(nil)
if validations
# Run through each validation
validations.each_pair do |field_name, options|
promise... | ruby | {
"resource": ""
} |
q17170 | Volt.Validations.run_validation | train | def run_validation(field_name, options)
promise = Promise.new.resolve(nil)
options.each_pair do |validation, args|
# Call the specific validator, then merge the results back
# into one large errors hash.
klass = validation_class(validation, args)
if klass
# Chain o... | ruby | {
"resource": ""
} |
q17171 | Volt.ReactiveArray.__clear | train | def __clear
old_size = @array.size
deps = @array_deps
@array_deps = []
# Trigger remove for each cell
old_size.times do |index|
trigger_removed!(old_size - index - 1)
end
# Trigger on each cell since we are clearing out the array
if deps
deps.eac... | ruby | {
"resource": ""
} |
q17172 | Volt.Buffer.promise_for_errors | train | def promise_for_errors(errors)
mark_all_fields!
# Wrap in an Errors class unless it already is one
errors = errors.is_a?(Errors) ? errors : Errors.new(errors)
Promise.new.reject(errors)
end | ruby | {
"resource": ""
} |
q17173 | Volt.Buffer.buffer | train | def buffer
model_path = options[:path]
model_klass = self.class
new_options = options.merge(path: model_path, save_to: self, buffer: true).reject { |k, _| k.to_sym == :persistor }
model = nil
Volt::Model.no_validate do
model = model_klass.new(attributes, new_options, :loaded)
... | ruby | {
"resource": ""
} |
q17174 | Volt.ModelHashBehaviour.to_h | train | def to_h
@size_dep.depend
if @attributes.nil?
nil
else
hash = {}
@attributes.each_pair do |key, value|
hash[key] = deep_unwrap(value)
end
hash
end
end | ruby | {
"resource": ""
} |
q17175 | Volt.ArrayModel.to_a | train | def to_a
@size_dep.depend
array = []
Volt.run_in_mode(:no_model_promises) do
attributes.size.times do |index|
array << deep_unwrap(self[index])
end
end
array
end | ruby | {
"resource": ""
} |
q17176 | Volt.ArrayModel.create_new_model | train | def create_new_model(model, from_method)
if model.is_a?(Model)
if model.buffer?
fail "The #{from_method} does not take a buffer. Call .save! on buffer's to persist them."
end
# Set the new path and the persistor.
model.options = @options.merge(parent: self, path: @optio... | ruby | {
"resource": ""
} |
q17177 | Volt.URL.url_for | train | def url_for(params)
host_with_port = host || location.host
host_with_port += ":#{port}" if port && port != 80
scheme = scheme || location.scheme
unless RUBY_PLATFORM == 'opal'
# lazy load routes and views on the server
if !@router && @routes_loader
# Load the templates... | ruby | {
"resource": ""
} |
q17178 | Volt.URL.assign_query_hash_to_params | train | def assign_query_hash_to_params
# Get a nested hash representing the current url params.
query_hash = parse_query
# Get the params that are in the route
new_params = @router.url_to_params(path)
fail "no routes match path: #{path}" if new_params == false
return false if new_params ... | ruby | {
"resource": ""
} |
q17179 | Volt.URL.assign_new | train | def assign_new(params, new_params)
new_params.each_pair do |name, value|
if value.is_a?(Hash)
assign_new(params.get(name), value)
else
# assign
params.set(name, value)
end
end
end | ruby | {
"resource": ""
} |
q17180 | Volt.URL.query_key | train | def query_key(path)
i = 0
path.map do |v|
i += 1
if i != 1
"[#{v}]"
else
v
end
end.join('')
end | ruby | {
"resource": ""
} |
q17181 | Volt.ViewBinding.create_controller_handler | train | def create_controller_handler(full_path, controller_path)
# If arguments is nil, then an blank SubContext will be created
args = [SubContext.new(@arguments, nil, true)]
# get the controller class and action
controller_class, action = ControllerHandler.get_controller_and_action(controller_path)
... | ruby | {
"resource": ""
} |
q17182 | Volt.ComponentPaths.app_folders | train | def app_folders
# Find all app folders
@app_folders ||= begin
volt_app = File.expand_path(File.join(File.dirname(__FILE__), '../../../../app'))
app_folders = [volt_app, "#{@root}/app", "#{@root}/vendor/app"].map { |f| File.expand_path(f) }
# Gem folders with volt in them
... | ruby | {
"resource": ""
} |
q17183 | Volt.ComponentPaths.components | train | def components
return @components if @components
@components = {}
app_folders do |app_folder|
Dir["#{app_folder}/*"].sort.each do |folder|
if File.directory?(folder)
folder_name = folder[/[^\/]+$/]
# Add in the folder if it's not alreay in there
... | ruby | {
"resource": ""
} |
q17184 | Volt.ComponentPaths.asset_folders | train | def asset_folders
folders = []
app_folders do |app_folder|
Dir["#{app_folder}/*/assets"].sort.each do |asset_folder|
folders << yield(asset_folder)
end
end
folders.flatten
end | ruby | {
"resource": ""
} |
q17185 | Volt.DomTemplate.track_binding_anchors | train | def track_binding_anchors
@binding_anchors = {}
# Loop through the bindings, find in nodes.
@bindings.each_pair do |name, binding|
if name.is_a?(String)
# Find the dom node for an attribute anchor
node = nil
`
node = self.nodes.querySelector('#' + nam... | ruby | {
"resource": ""
} |
q17186 | Volt.ViewLookupForPath.path_for_template | train | def path_for_template(lookup_path, force_section = nil)
parts = lookup_path.split('/')
parts_size = parts.size
return nil, nil if parts_size == 0
default_parts = %w(main main index body)
# When forcing a sub template, we can default the sub template section
default_parts[... | ruby | {
"resource": ""
} |
q17187 | Volt.ModelController.first_element | train | def first_element
check_section!('first_element')
range = dom_nodes
nodes = `range.startContainer.childNodes`
start_index = `range.startOffset`
end_index = `range.endOffset`
start_index.upto(end_index) do |index|
node = `nodes[index]`
# Return if an element
... | ruby | {
"resource": ""
} |
q17188 | Volt.ModelController.yield_html | train | def yield_html
if (template_path = attrs.content_template_path)
@yield_renderer ||= StringTemplateRenderer.new(@volt_app, attrs.content_controller, template_path)
@yield_renderer.html
else
# no template, empty string
''
end
end | ruby | {
"resource": ""
} |
q17189 | Volt.ModelController.model= | train | def model=(val)
if val.is_a?(Promise)
# Resolve the promise before setting
self.last_promise = val
val.then do |result|
# Only assign if nothing else has been assigned since we started the resolve
self.model = result if last_promise == val
end.fail do |err|
... | ruby | {
"resource": ""
} |
q17190 | Volt.ModelController.loaded? | train | def loaded?
if model.respond_to?(:loaded?)
# There is a model and it is loaded
return model.loaded?
elsif last_promise || model.is_a?(Promise)
# The model is a promise or is resolving
return false
else
# Otherwise, its loaded
return true
end
en... | ruby | {
"resource": ""
} |
q17191 | Volt.ModelController.raw | train | def raw(str)
# Promises need to have .to_s called using .then, since .to_s is a promise
# method, so it won't be passed down to the value.
if str.is_a?(Promise)
str = str.then(&:to_s)
else
str = str.to_s unless str.is_a?(String)
end
str.html_safe
end | ruby | {
"resource": ""
} |
q17192 | Volt.NumericalityValidator.check_errors | train | def check_errors
if @value && @value.is_a?(Numeric)
if @args.is_a?(Hash)
@args.each do |arg, val|
case arg
when :min
add_error("number must be greater than #{val}") if @value < val
when :max
add_error("number must be less than #{va... | ruby | {
"resource": ""
} |
q17193 | Volt.HttpController.params | train | def params
@params ||= begin
params = request.params.symbolize_keys.merge(@initial_params)
Volt::Model.new(params, persistor: Volt::Persistors::Params)
end
end | ruby | {
"resource": ""
} |
q17194 | Volt.AttributeSection.rezero_bindings | train | def rezero_bindings(html, bindings)
@@base_binding_id ||= 20_000
# rezero
parts = html.split(/(\<\!\-\- \$\/?[0-9]+ \-\-\>)/).reject { |v| v == '' }
new_html = []
new_bindings = {}
id_map = {}
parts.each do |part|
case part
when /\<\!\-\- \$[0-9]+ \-\-\>/
... | ruby | {
"resource": ""
} |
q17195 | Volt.AttributeSection.set_content_and_rezero_bindings | train | def set_content_and_rezero_bindings(html, bindings)
html, bindings = rezero_bindings(html, bindings)
if @binding_name == 'main'
@target.html = html
else
@target.find_by_binding_id(@binding_name).html = html
end
bindings
end | ruby | {
"resource": ""
} |
q17196 | Volt.ViewParser.code | train | def code(app_reference)
code = ''
templates.each_pair do |name, template|
binding_code = []
if template['bindings']
template['bindings'].each_pair do |key, value|
binding_code << "#{key.inspect} => [#{value.join(', ')}]"
end
end
binding_code ... | ruby | {
"resource": ""
} |
q17197 | Volt.Duration.duration_in_words | train | def duration_in_words(places=2, min_unit=:minutes, recent_message='just now')
parts = []
secs = to_i
UNIT_MAP.each_pair do |unit, count|
val = (secs / count).floor
secs = secs % count
parts << [val, unit] if val > 0
break if unit == min_unit
end
# Trim num... | ruby | {
"resource": ""
} |
q17198 | Volt.Tasks.response | train | def response(promise_id, result, error, cookies)
# Set the cookies
if cookies
cookies.each do |key, value|
@volt_app.cookies.set(key, value)
end
end
promise = @promises.delete(promise_id)
if promise
if error
# TODO: full error handling
... | ruby | {
"resource": ""
} |
q17199 | Volt.Tasks.notify_query | train | def notify_query(method_name, collection, query, *args)
query_obj = Persistors::ArrayStore.query_pool.lookup(collection, query)
query_obj.send(method_name, *args)
end | ruby | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.