_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3
values | text stringlengths 30 4.3k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q12700 | Phonelib.PhoneAnalyzer.all_number_types | train | def all_number_types(phone, data, not_valid = false)
response = { valid: [], possible: [] }
types_for_check(data).each do |type|
possible, valid = get_patterns(data, type)
valid_and_possible, possible_result =
number_valid_and_possible?(phone, possible, valid, not_valid)
... | ruby | {
"resource": ""
} |
q12701 | Phonelib.PhoneAnalyzer.number_format | train | def number_format(national, format_data)
format_data && format_data.find do |format|
(format[Core::LEADING_DIGITS].nil? || \
national.match(cr("^(#{format[Core::LEADING_DIGITS]})"))) && \
| ruby | {
"resource": ""
} |
q12702 | Phonelib.PhoneAnalyzer.get_patterns | train | def get_patterns(all_patterns, type)
type = Core::FIXED_LINE if type == Core::FIXED_OR_MOBILE
patterns = all_patterns[type]
if patterns
[
type_regex(patterns, Core::POSSIBLE_PATTERN),
| ruby | {
"resource": ""
} |
q12703 | Phonelib.PhoneAnalyzerHelper.vanity_converted | train | def vanity_converted(phone)
return phone unless Phonelib.vanity_conversion
(phone || '').gsub(cr('[a-zA-Z]')) do |c|
c.upcase!
# subtract "A"
n = (c.ord - 65) / 3
# account | ruby | {
"resource": ""
} |
q12704 | Phonelib.PhoneAnalyzerHelper.passed_country | train | def passed_country(country)
code = country_prefix(country)
if Core::PLUS_SIGN == @original[0] && code && !sanitized.start_with?(code)
# in case number passed with + but it doesn't | ruby | {
"resource": ""
} |
q12705 | Phonelib.PhoneAnalyzerHelper.country_prefix | train | def country_prefix(country)
country = country.to_s.upcase
Phonelib.phone_data[country] && \
| ruby | {
"resource": ""
} |
q12706 | Phonelib.PhoneAnalyzerHelper.country_can_dp? | train | def country_can_dp?(country)
Phonelib.phone_data[country] &&
| ruby | {
"resource": ""
} |
q12707 | Phonelib.PhoneAnalyzerHelper.double_prefix_allowed? | train | def double_prefix_allowed?(data, phone, parsed = {})
data[Core::DOUBLE_COUNTRY_PREFIX_FLAG] &&
| ruby | {
"resource": ""
} |
q12708 | Phonelib.PhoneAnalyzerHelper.country_or_default_country | train | def country_or_default_country(country)
country ||= (original_starts_with_plus? | ruby | {
"resource": ""
} |
q12709 | Phonelib.PhoneAnalyzerHelper.type_regex | train | def type_regex(data, type)
regex = [data[type]]
if Phonelib.parse_special && data[Core::SHORT] && data[Core::SHORT][type]
| ruby | {
"resource": ""
} |
q12710 | Phonelib.PhoneAnalyzerHelper.phone_match_data? | train | def phone_match_data?(phone, data, possible = false)
country_code = "#{data[Core::COUNTRY_CODE]}"
inter_prefix = "(#{data[Core::INTERNATIONAL_PREFIX]})?"
return unless phone.match cr("^0{2}?#{inter_prefix}#{country_code}")
type | ruby | {
"resource": ""
} |
q12711 | Phonelib.PhoneAnalyzerHelper.types_for_check | train | def types_for_check(data)
exclude_list = PhoneAnalyzer::NOT_FOR_CHECK
exclude_list += Phonelib::Core::SHORT_CODES unless Phonelib.parse_special
| ruby | {
"resource": ""
} |
q12712 | Phonelib.PhoneAnalyzerHelper.fixed_and_mobile_keys | train | def fixed_and_mobile_keys(data)
if data[Core::FIXED_LINE] == data[Core::MOBILE]
[Core::FIXED_OR_MOBILE]
else
| ruby | {
"resource": ""
} |
q12713 | Phonelib.PhoneAnalyzerHelper.number_valid_and_possible? | train | def number_valid_and_possible?(number, p_regex, v_regex, not_valid = false)
possible = number_match?(number, p_regex)
return [!not_valid && possible, possible] if p_regex == v_regex
| ruby | {
"resource": ""
} |
q12714 | Phonelib.PhoneAnalyzerHelper.number_match? | train | def number_match?(number, regex)
match = number.match(cr("^(?:#{regex})$")) | ruby | {
"resource": ""
} |
q12715 | Phonelib.Phone.local_number | train | def local_number
return national unless possible?
format_match, format_string = formatting_data
if format_string =~ /^.*[0-9]+.*\$1/ && format_match
format_string.gsub(/^.*\$2/, '$2')
| ruby | {
"resource": ""
} |
q12716 | Phonelib.Phone.valid_for_country? | train | def valid_for_country?(country)
country = country.to_s.upcase
tdata = analyze(sanitized, passed_country(country)) | ruby | {
"resource": ""
} |
q12717 | Phonelib.DataImporterHelper.save_data_file | train | def save_data_file
File.open(file_path(Phonelib::Core::FILE_MAIN_DATA), 'wb+') do |f|
| ruby | {
"resource": ""
} |
q12718 | Phonelib.DataImporterHelper.save_extended_data_file | train | def save_extended_data_file
extended = {
Phonelib::Core::EXT_PREFIXES => @prefixes,
Phonelib::Core::EXT_GEO_NAMES => @geo_names,
Phonelib::Core::EXT_COUNTRY_NAMES => @countries,
Phonelib::Core::EXT_TIMEZONES => @timezones,
Phonelib::Core::EXT_CARRIERS => @carriers
}
... | ruby | {
"resource": ""
} |
q12719 | Phonelib.DataImporterHelper.fill_prefixes | train | def fill_prefixes(key, value, prefix, prefixes)
prefixes = {} if prefixes.nil?
if prefix.size == 1
pr = prefix.to_i
prefixes[pr] ||= {}
prefixes[pr][key] = value
else
pr = | ruby | {
"resource": ""
} |
q12720 | Phonelib.DataImporterHelper.parse_raw_file | train | def parse_raw_file(file)
data = {}
File.readlines(file).each do |line|
line = str_clean line, false
next if line.empty? || line[0] == '#'
| ruby | {
"resource": ""
} |
q12721 | Phonelib.DataImporterHelper.main_from_xml | train | def main_from_xml(file)
xml_data = File.read(file)
xml_data.force_encoding('utf-8')
doc = | ruby | {
"resource": ""
} |
q12722 | Phonelib.PhoneFormatter.national | train | def national(formatted = true)
return @national_number unless valid?
format_match, format_string = formatting_data
if format_match
out = format_string.gsub(/\$\d/) { |el| | ruby | {
"resource": ""
} |
q12723 | Phonelib.PhoneFormatter.raw_national | train | def raw_national
return nil if sanitized.nil? || sanitized.empty?
if valid?
@national_number
elsif country_code && sanitized.start_with?(country_code)
| ruby | {
"resource": ""
} |
q12724 | Phonelib.PhoneFormatter.international | train | def international(formatted = true, prefix = '+')
prefix = formatted if formatted.is_a?(String)
return nil if sanitized.empty?
return "#{prefix}#{country_prefix_or_not}#{sanitized}" unless valid?
return country_code + @national_number unless formatted
fmt = @data[country][:format]
n... | ruby | {
"resource": ""
} |
q12725 | Phonelib.PhoneFormatter.area_code | train | def area_code
return nil unless area_code_possible?
format_match, _format_string = formatting_data
take_group = 1
if type == Core::MOBILE && Core::AREA_CODE_MOBILE_TOKENS[country] && \
format_match[1] == | ruby | {
"resource": ""
} |
q12726 | Psych.ScalarScanner.tokenize | train | def tokenize string
return nil if string.empty?
return string if @string_cache.key?(string)
return @symbol_cache[string] if @symbol_cache.key?(string)
case string
# Check for a String type, being careful not to get caught by hash keys, hex values, and
# special floats (e.g., -.inf).... | ruby | {
"resource": ""
} |
q12727 | Psych.ScalarScanner.parse_time | train | def parse_time string
klass = class_loader.load 'Time'
date, time = *(string.split(/[ tT]/, 2))
(yy, m, dd) = date.match(/^(-?\d{4})-(\d{1,2})-(\d{1,2})/).captures.map { |x| x.to_i }
md = time.match(/(\d+:\d+:\d+)(?:\.(\d*))?\s*(Z|[-+]\d+(:\d\d)?)?/)
(hh, mm, ss) = md[1].split(':').map {... | ruby | {
"resource": ""
} |
q12728 | Psych.TreeBuilder.start_document | train | def start_document version, tag_directives, implicit
n = Nodes::Document.new version, tag_directives, implicit
| ruby | {
"resource": ""
} |
q12729 | Psych.TreeBuilder.end_document | train | def end_document implicit_end = !streaming?
@last.implicit_end = implicit_end
n | ruby | {
"resource": ""
} |
q12730 | Pwb.Api::V1::TranslationsController.delete_translation_values | train | def delete_translation_values
field_key = FieldKey.find_by_global_key(params[:i18n_key])
field_key.visible = false
# not convinced it makes sense | ruby | {
"resource": ""
} |
q12731 | Pwb.Api::V1::TranslationsController.create_for_locale | train | def create_for_locale
field_key = FieldKey.find_by_global_key(params[:i18n_key])
phrase = I18n::Backend::ActiveRecord::Translation.find_or_create_by(
| ruby | {
"resource": ""
} |
q12732 | Pwb.SearchController.buy | train | def buy
@page = Pwb::Page.find_by_slug "buy"
@page_title = @current_agency.company_name
# @content_to_show = []
if @page.present?
@page_title = @page.page_title + ' - ' + @current_agency.company_name
# TODO: - allow addition of custom content
# @page.ordered_visible_page_... | ruby | {
"resource": ""
} |
q12733 | Pwb.Prop.set_features= | train | def set_features=(features_json)
# return unless features_json.class == Hash
features_json.keys.each do |feature_key|
# TODO - create feature_key if its missing
if features_json[feature_key] == "true" || features_json[feature_key] == true
| ruby | {
"resource": ""
} |
q12734 | Pwb.Prop.contextual_price_with_currency | train | def contextual_price_with_currency(rent_or_sale)
contextual_price = self.contextual_price rent_or_sale
if contextual_price.zero?
| ruby | {
"resource": ""
} |
q12735 | Pwb.Api::V1::WebContentsController.update_photo | train | def update_photo
content_tag = params[:content_tag]
# photo = ContentPhoto.find(params[:id])
# find would throw error if not found
photo = ContentPhoto.find_by_id(params[:id])
unless photo
if content_tag
# where photo has never been set before, associated Content will not... | ruby | {
"resource": ""
} |
q12736 | Pwb.Api::V1::WebContentsController.create_content_with_photo | train | def create_content_with_photo
tag = params[:tag]
photo = ContentPhoto.create
key = tag.underscore.camelize + photo.id.to_s
new_content = Content.create(tag: tag, key: key)
# photo.subdomain = subdomain
# photo.folder = current_tenant_model.whitelabel_country_code
# photo.tena... | ruby | {
"resource": ""
} |
q12737 | Pwb.PagePartManager.seed_container_block_content | train | def seed_container_block_content(locale, seed_content)
page_part_editor_setup = page_part.editor_setup
raise "Invalid editorBlocks for page_part_editor_setup" unless page_part_editor_setup && page_part_editor_setup["editorBlocks"].present?
# page = page_part.page
# page_part_key uniquely identif... | ruby | {
"resource": ""
} |
q12738 | Pwb.PagePartManager.set_page_part_block_contents | train | def set_page_part_block_contents(_page_part_key, locale, fragment_details)
# page_part = self.page_parts.find_by_page_part_key page_part_key
if page_part.present?
page_part.block_contents[locale] = fragment_details
page_part.save!
# fragment_details passed in might be a params object... | ruby | {
"resource": ""
} |
q12739 | Pwb.PagePartManager.rebuild_page_content | train | def rebuild_page_content(locale)
unless page_part && page_part.template
raise "page_part with valid template not available"
end
# page_part = self.page_parts.find_by_page_part_key page_part_key
if page_part.present?
l_template = Liquid::Template.parse(page_part.template)
... | ruby | {
"resource": ""
} |
q12740 | Pwb.PagePartManager.seed_fragment_photo | train | def seed_fragment_photo(block_label, photo_file)
# content_key = self.slug + "_" + page_part_key
# get in content model associated with page and fragment
# join_model = page_contents.find_or_create_by(page_part_key: page_part_key)
# page_fragment_content = join_model.create_content(page_part_key... | ruby | {
"resource": ""
} |
q12741 | Pwb.Website.get_element_class | train | def get_element_class(element_name)
style_details = style_variables_for_theme["vic"] || Pwb::PresetStyle.default_values | ruby | {
"resource": ""
} |
q12742 | Pwb.Website.style_settings_from_preset= | train | def style_settings_from_preset=(preset_style_name)
preset_style = Pwb::PresetStyle.where(name: preset_style_name).first | ruby | {
"resource": ""
} |
q12743 | TTY.Prompt.invoke_question | train | def invoke_question(object, message, *args, &block)
options = Utils.extract_options!(args)
| ruby | {
"resource": ""
} |
q12744 | TTY.Prompt.invoke_select | train | def invoke_select(object, question, *args, &block)
options = Utils.extract_options!(args)
choices = if block
[]
elsif args.empty?
possible = options.dup
options = {}
possible
elsif args.size == 1 && args[... | ruby | {
"resource": ""
} |
q12745 | TTY.Prompt.yes? | train | def yes?(message, *args, &block)
defaults = { default: true }
options = Utils.extract_options!(args)
options.merge!(defaults.reject { |k, _| options.key?(k) })
| ruby | {
"resource": ""
} |
q12746 | TTY.Prompt.slider | train | def slider(question, *args, &block)
options = Utils.extract_options!(args)
slider = Slider.new(self, | ruby | {
"resource": ""
} |
q12747 | TTY.Prompt.say | train | def say(message = '', options = {})
message = message.to_s
return if message.empty?
| ruby | {
"resource": ""
} |
q12748 | TTY.Prompt.debug | train | def debug(*messages)
longest = messages.max_by(&:length).size
width = TTY::Screen.width - longest
print cursor.save
messages.each_with_index do |msg, i|
| ruby | {
"resource": ""
} |
q12749 | TTY.Prompt.suggest | train | def suggest(message, possibilities, options = {})
suggestion | ruby | {
"resource": ""
} |
q12750 | TTY.Prompt.collect | train | def collect(options = {}, &block)
collector = AnswersCollector.new(self, | ruby | {
"resource": ""
} |
q12751 | TTY.Utils.extract_options | train | def extract_options(args)
options = args.last
| ruby | {
"resource": ""
} |
q12752 | TTY.Utils.blank? | train | def blank?(value)
value.nil? ||
value.respond_to?(:empty?) && value.empty? | ruby | {
"resource": ""
} |
q12753 | Spring.Application.shush_backtraces | train | def shush_backtraces
Kernel.module_eval do
old_raise = Kernel.method(:raise)
remove_method :raise
define_method :raise do |*args|
begin
| ruby | {
"resource": ""
} |
q12754 | Spring.OkJson.decode | train | def decode(s)
ts = lex(s)
v, ts = textparse(ts)
| ruby | {
"resource": ""
} |
q12755 | Spring.OkJson.objparse | train | def objparse(ts)
ts = eat('{', ts)
obj = {}
if ts[0][0] == '}'
return obj, ts[1..-1]
end
k, v, ts = pairparse(ts)
obj[k] = v
if ts[0][0] == '}'
return obj, ts[1..-1]
end
loop do
| ruby | {
"resource": ""
} |
q12756 | Spring.OkJson.pairparse | train | def pairparse(ts)
(typ, _, k), ts = ts[0], ts[1..-1]
if typ != :str
raise Error, "unexpected #{k.inspect}"
end
ts = | ruby | {
"resource": ""
} |
q12757 | Spring.OkJson.arrparse | train | def arrparse(ts)
ts = eat('[', ts)
arr = []
if ts[0][0] == ']'
return arr, ts[1..-1]
end
v, ts = valparse(ts)
arr << v
if ts[0][0] == ']'
return arr, ts[1..-1]
end
loop do
| ruby | {
"resource": ""
} |
q12758 | Spring.OkJson.tok | train | def tok(s)
case s[0]
when ?{ then ['{', s[0,1], s[0,1]]
when ?} then ['}', s[0,1], s[0,1]]
when ?: then [':', s[0,1], s[0,1]]
when ?, then [',', s[0,1], s[0,1]]
when ?[ then ['[', s[0,1], s[0,1]]
when ?] then [']', s[0,1], s[0,1]]
when ?n then nulltok(s)
when ?t then truetok(s)
w... | ruby | {
"resource": ""
} |
q12759 | Spring.OkJson.unquote | train | def unquote(q)
q = q[1...-1]
a = q.dup # allocate a big enough string
# In ruby >= 1.9, a[w] is a codepoint, not a byte.
if rubydoesenc?
a.force_encoding('UTF-8')
end
r, w = 0, 0
while r < q.length
c = q[r]
if c == ?\\
r += 1
if r >= q.length
raise... | ruby | {
"resource": ""
} |
q12760 | Spring.OkJson.ucharenc | train | def ucharenc(a, i, u)
if u <= Uchar1max
a[i] = (u & 0xff).chr
1
elsif u <= Uchar2max
a[i+0] = (Utag2 | ((u>>6)&0xff)).chr
a[i+1] = (Utagx | (u&Umaskx)).chr
2
elsif u <= Uchar3max
a[i+0] = (Utag3 | ((u>>12)&0xff)).chr
a[i+1] = (Utagx | ((u>>6)&Umaskx)).chr
a[i+... | ruby | {
"resource": ""
} |
q12761 | Spring.ApplicationManager.run | train | def run(client)
with_child do
child.send_io client
child.gets or raise Errno::EPIPE
end
pid = child.gets.to_i
unless pid.zero?
log "got worker pid #{pid}"
pid
end
rescue Errno::ECONNRESET, | ruby | {
"resource": ""
} |
q12762 | Koala.Utils.symbolize_hash | train | def symbolize_hash(hash)
return hash unless hash.is_a?(Hash)
hash.inject({}){ |memo,(key,value)| | ruby | {
"resource": ""
} |
q12763 | PublicActivity.ViewHelpers.single_content_for | train | def single_content_for(name, content = nil, &block)
@view_flow.set(name, ActiveSupport::SafeBuffer.new)
| ruby | {
"resource": ""
} |
q12764 | PublicActivity.Common.create_activity! | train | def create_activity!(*args)
return unless self.public_activity_enabled?
options = prepare_settings(*args)
if call_hook_safe(options[:key].split('.').last)
| ruby | {
"resource": ""
} |
q12765 | PublicActivity.Common.prepare_custom_fields | train | def prepare_custom_fields(options)
customs = self.class.activity_custom_fields_global.clone
customs.merge!(self.activity_custom_fields) if | ruby | {
"resource": ""
} |
q12766 | PublicActivity.Common.prepare_key | train | def prepare_key(action, options = {})
(
options[:key] ||
self.activity_key ||
| ruby | {
"resource": ""
} |
q12767 | PublicActivity.Renderable.text | train | def text(params = {})
# TODO: some helper for key transformation for two supported formats
k = key.split('.')
k.unshift('activity') if k.first != 'activity'
| ruby | {
"resource": ""
} |
q12768 | PublicActivity.Renderable.render | train | def render(context, params = {})
partial_root = params.delete(:root) || 'public_activity'
partial_path = nil
layout_root = params.delete(:layout_root) || 'layouts'
if params.has_key? :display
if params[:display].to_sym == :"i18n"
text = self.text(params)
... | ruby | {
"resource": ""
} |
q12769 | PublicActivity.Renderable.template_path | train | def template_path(key, partial_root)
path = key.split(".")
path.delete_at(0) if path[0] == "activity"
| ruby | {
"resource": ""
} |
q12770 | Restforce.Collection.each | train | def each
@raw_page['records'].each { |record| yield Restforce::Mash.build(record, @client) }
np = next_page
while | ruby | {
"resource": ""
} |
q12771 | Restforce.Middleware::Authentication.encode_www_form | train | def encode_www_form(params)
if URI.respond_to?(:encode_www_form)
URI.encode_www_form(params)
else
params.map do |k, v|
k = CGI.escape(k.to_s)
| ruby | {
"resource": ""
} |
q12772 | RMagick.Extconf.have_enum_values | train | def have_enum_values(enum, values, headers = nil, &b)
values.each do |value|
| ruby | {
"resource": ""
} |
q12773 | Magick.RVG.bgfill | train | def bgfill
if @background_fill.nil?
color = Magick::Pixel.new(0, 0, 0, Magick::TransparentOpacity)
else
color = @background_fill | ruby | {
"resource": ""
} |
q12774 | Magick.RVG.background_image= | train | def background_image=(bg_image)
warn 'background_image= has no effect in nested RVG objects' if @nested
raise ArgumentError, "background image must be an Image | ruby | {
"resource": ""
} |
q12775 | Magick.RVG.add_outermost_primitives | train | def add_outermost_primitives(gc) #:nodoc:
add_transform_primitives(gc)
gc.push
add_viewbox_primitives(@width, @height, | ruby | {
"resource": ""
} |
q12776 | Magick.RVG.add_primitives | train | def add_primitives(gc) #:nodoc:
raise ArgumentError, 'RVG width or height undefined' if @width.nil? || @height.nil?
return | ruby | {
"resource": ""
} |
q12777 | Magick.Geometry.to_s | train | def to_s
str = ''
if @width > 0
fmt = @width.truncate == @width ? '%d' : '%.2f'
str << format(fmt, @width)
str << '%' if @flag == PercentGeometry
end
str << 'x' if (@width > 0 && @flag != PercentGeometry) || (@height > 0)
if @height > 0
fmt = @height.trunc... | ruby | {
"resource": ""
} |
q12778 | Magick.Draw.arc | train | def arc(start_x, start_y, end_x, end_y, start_degrees, end_degrees)
primitive 'arc ' + format('%g,%g %g,%g %g,%g',
| ruby | {
"resource": ""
} |
q12779 | Magick.Draw.circle | train | def circle(origin_x, origin_y, perim_x, perim_y)
primitive 'circle ' + format('%g,%g | ruby | {
"resource": ""
} |
q12780 | Magick.Draw.clip_rule | train | def clip_rule(rule)
Kernel.raise ArgumentError, "Unknown clipping rule | ruby | {
"resource": ""
} |
q12781 | Magick.Draw.clip_units | train | def clip_units(unit)
Kernel.raise ArgumentError, "Unknown clip unit #{unit}" | ruby | {
"resource": ""
} |
q12782 | Magick.Draw.color | train | def color(x, y, method)
Kernel.raise ArgumentError, "Unknown PaintMethod: #{method}" | ruby | {
"resource": ""
} |
q12783 | Magick.Draw.ellipse | train | def ellipse(origin_x, origin_y, width, height, arc_start, arc_end)
primitive 'ellipse ' + format('%g,%g %g,%g %g,%g',
| ruby | {
"resource": ""
} |
q12784 | Magick.Draw.interline_spacing | train | def interline_spacing(space)
begin
Float(space)
rescue ArgumentError
Kernel.raise ArgumentError, 'invalid value for interline_spacing'
rescue TypeError
| ruby | {
"resource": ""
} |
q12785 | Magick.Draw.line | train | def line(start_x, start_y, end_x, end_y)
primitive 'line ' + format('%g,%g | ruby | {
"resource": ""
} |
q12786 | Magick.Draw.opacity | train | def opacity(opacity)
if opacity.is_a?(Numeric)
Kernel.raise ArgumentError, 'opacity must be >= 0 and <= 1.0' if | ruby | {
"resource": ""
} |
q12787 | Magick.Draw.pattern | train | def pattern(name, x, y, width, height)
push('defs')
push("pattern #{name} #{x} #{y} #{width} #{height}")
push('graphic-context')
yield
| ruby | {
"resource": ""
} |
q12788 | Magick.Draw.polygon | train | def polygon(*points)
if points.length.zero?
Kernel.raise ArgumentError, 'no points specified'
elsif points.length.odd?
Kernel.raise ArgumentError, 'odd | ruby | {
"resource": ""
} |
q12789 | Magick.Draw.rectangle | train | def rectangle(upper_left_x, upper_left_y, lower_right_x, lower_right_y)
primitive 'rectangle ' + format('%g,%g %g,%g',
| ruby | {
"resource": ""
} |
q12790 | Magick.Draw.roundrectangle | train | def roundrectangle(center_x, center_y, width, height, corner_width, corner_height)
primitive 'roundrectangle ' + format('%g,%g,%g,%g,%g,%g',
| ruby | {
"resource": ""
} |
q12791 | Magick.Draw.stroke_dasharray | train | def stroke_dasharray(*list)
if list.length.zero?
primitive 'stroke-dasharray none'
else
list.each do |x|
Kernel.raise ArgumentError, "dash array elements must | ruby | {
"resource": ""
} |
q12792 | Magick.Draw.text | train | def text(x, y, text)
Kernel.raise ArgumentError, 'missing text argument' if text.to_s.empty?
if text.length > 2 && /\A(?:\"[^\"]+\"|\'[^\']+\'|\{[^\}]+\})\z/.match(text)
# text already quoted
elsif !text['\'']
| ruby | {
"resource": ""
} |
q12793 | Magick.Draw.text_align | train | def text_align(alignment)
Kernel.raise ArgumentError, "Unknown alignment constant: #{alignment}" unless ALIGN_TYPE_NAMES.key?(alignment.to_i)
| ruby | {
"resource": ""
} |
q12794 | Magick.Draw.text_anchor | train | def text_anchor(anchor)
Kernel.raise ArgumentError, "Unknown anchor constant: #{anchor}" unless ANCHOR_TYPE_NAMES.key?(anchor.to_i)
| ruby | {
"resource": ""
} |
q12795 | Magick.Image.color_point | train | def color_point(x, y, fill)
f = | ruby | {
"resource": ""
} |
q12796 | Magick.Image.color_floodfill | train | def color_floodfill(x, y, fill)
target = pixel_color(x, | ruby | {
"resource": ""
} |
q12797 | Magick.Image.color_fill_to_border | train | def color_fill_to_border(x, y, fill)
color_flood_fill(border_color, fill, x, | ruby | {
"resource": ""
} |
q12798 | Magick.Image.each_pixel | train | def each_pixel
get_pixels(0, 0, columns, rows).each_with_index do |p, n|
| ruby | {
"resource": ""
} |
q12799 | Magick.Image.matte_fill_to_border | train | def matte_fill_to_border(x, y)
f = copy
f.opacity = Magick::OpaqueOpacity unless | ruby | {
"resource": ""
} |
Subsets and Splits
SQL Console for CoIR-Retrieval/CodeSearchNet-ccr-ruby-queries-corpus
Retrieves a large number of entries in the 'ruby' language, providing basic information but limited analytical value.