id
int32 0
24.9k
| repo
stringlengths 5
58
| path
stringlengths 9
168
| func_name
stringlengths 9
130
| original_string
stringlengths 66
10.5k
| language
stringclasses 1
value | code
stringlengths 66
10.5k
| code_tokens
list | docstring
stringlengths 8
16k
| docstring_tokens
list | sha
stringlengths 40
40
| url
stringlengths 94
266
|
|---|---|---|---|---|---|---|---|---|---|---|---|
12,700
|
daddyz/phonelib
|
lib/phonelib/phone_analyzer.rb
|
Phonelib.PhoneAnalyzer.all_number_types
|
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)
response[:possible] << type if possible_result
response[:valid] << type if valid_and_possible
end
sanitize_fixed_mobile(response)
end
|
ruby
|
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)
response[:possible] << type if possible_result
response[:valid] << type if valid_and_possible
end
sanitize_fixed_mobile(response)
end
|
[
"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",
")",
"response",
"[",
":possible",
"]",
"<<",
"type",
"if",
"possible_result",
"response",
"[",
":valid",
"]",
"<<",
"type",
"if",
"valid_and_possible",
"end",
"sanitize_fixed_mobile",
"(",
"response",
")",
"end"
] |
Returns all valid and possible phone number types for currently parsed
phone for provided data hash.
==== Attributes
* +phone+ - phone number for parsing
* +data+ - country data
* +not_valid+ - specifies that number is not valid by general desc pattern
|
[
"Returns",
"all",
"valid",
"and",
"possible",
"phone",
"number",
"types",
"for",
"currently",
"parsed",
"phone",
"for",
"provided",
"data",
"hash",
"."
] |
aa0023eab7c896b71275bf342bc7f49735cbdbbf
|
https://github.com/daddyz/phonelib/blob/aa0023eab7c896b71275bf342bc7f49735cbdbbf/lib/phonelib/phone_analyzer.rb#L163-L176
|
12,701
|
daddyz/phonelib
|
lib/phonelib/phone_analyzer.rb
|
Phonelib.PhoneAnalyzer.number_format
|
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]})"))) && \
national.match(cr("^(#{format[Core::PATTERN]})$"))
end || Core::DEFAULT_NUMBER_FORMAT
end
|
ruby
|
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]})"))) && \
national.match(cr("^(#{format[Core::PATTERN]})$"))
end || Core::DEFAULT_NUMBER_FORMAT
end
|
[
"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]})\"",
")",
")",
")",
"&&",
"national",
".",
"match",
"(",
"cr",
"(",
"\"^(#{format[Core::PATTERN]})$\"",
")",
")",
"end",
"||",
"Core",
"::",
"DEFAULT_NUMBER_FORMAT",
"end"
] |
Gets matched number formatting rule or default one
==== Attributes
* +national+ - national phone number
* +format_data+ - formatting data from country data
|
[
"Gets",
"matched",
"number",
"formatting",
"rule",
"or",
"default",
"one"
] |
aa0023eab7c896b71275bf342bc7f49735cbdbbf
|
https://github.com/daddyz/phonelib/blob/aa0023eab7c896b71275bf342bc7f49735cbdbbf/lib/phonelib/phone_analyzer.rb#L184-L190
|
12,702
|
daddyz/phonelib
|
lib/phonelib/phone_analyzer.rb
|
Phonelib.PhoneAnalyzer.get_patterns
|
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),
type_regex(patterns, Core::VALID_PATTERN)
]
else
[nil, nil]
end
end
|
ruby
|
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),
type_regex(patterns, Core::VALID_PATTERN)
]
else
[nil, nil]
end
end
|
[
"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",
")",
",",
"type_regex",
"(",
"patterns",
",",
"Core",
"::",
"VALID_PATTERN",
")",
"]",
"else",
"[",
"nil",
",",
"nil",
"]",
"end",
"end"
] |
Returns possible and valid patterns for validation for provided type
==== Attributes
* +all_patterns+ - hash of all patterns for validation
* +type+ - type of phone to get patterns for
|
[
"Returns",
"possible",
"and",
"valid",
"patterns",
"for",
"validation",
"for",
"provided",
"type"
] |
aa0023eab7c896b71275bf342bc7f49735cbdbbf
|
https://github.com/daddyz/phonelib/blob/aa0023eab7c896b71275bf342bc7f49735cbdbbf/lib/phonelib/phone_analyzer.rb#L198-L210
|
12,703
|
daddyz/phonelib
|
lib/phonelib/phone_analyzer_helper.rb
|
Phonelib.PhoneAnalyzerHelper.vanity_converted
|
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 for #7 & #9 which have 4 chars
n -= 1 if c.match(Core::VANITY_4_LETTERS_KEYS_REGEX)
(n + 2).to_s
end
end
|
ruby
|
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 for #7 & #9 which have 4 chars
n -= 1 if c.match(Core::VANITY_4_LETTERS_KEYS_REGEX)
(n + 2).to_s
end
end
|
[
"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 for #7 & #9 which have 4 chars",
"n",
"-=",
"1",
"if",
"c",
".",
"match",
"(",
"Core",
"::",
"VANITY_4_LETTERS_KEYS_REGEX",
")",
"(",
"n",
"+",
"2",
")",
".",
"to_s",
"end",
"end"
] |
converts symbols in phone to numbers
|
[
"converts",
"symbols",
"in",
"phone",
"to",
"numbers"
] |
aa0023eab7c896b71275bf342bc7f49735cbdbbf
|
https://github.com/daddyz/phonelib/blob/aa0023eab7c896b71275bf342bc7f49735cbdbbf/lib/phonelib/phone_analyzer_helper.rb#L11-L22
|
12,704
|
daddyz/phonelib
|
lib/phonelib/phone_analyzer_helper.rb
|
Phonelib.PhoneAnalyzerHelper.passed_country
|
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 start with passed
# country prefix
country = nil
end
country
end
|
ruby
|
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 start with passed
# country prefix
country = nil
end
country
end
|
[
"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 start with passed",
"# country prefix",
"country",
"=",
"nil",
"end",
"country",
"end"
] |
defines if to validate against single country or not
|
[
"defines",
"if",
"to",
"validate",
"against",
"single",
"country",
"or",
"not"
] |
aa0023eab7c896b71275bf342bc7f49735cbdbbf
|
https://github.com/daddyz/phonelib/blob/aa0023eab7c896b71275bf342bc7f49735cbdbbf/lib/phonelib/phone_analyzer_helper.rb#L25-L33
|
12,705
|
daddyz/phonelib
|
lib/phonelib/phone_analyzer_helper.rb
|
Phonelib.PhoneAnalyzerHelper.country_prefix
|
def country_prefix(country)
country = country.to_s.upcase
Phonelib.phone_data[country] && \
Phonelib.phone_data[country][Core::COUNTRY_CODE]
end
|
ruby
|
def country_prefix(country)
country = country.to_s.upcase
Phonelib.phone_data[country] && \
Phonelib.phone_data[country][Core::COUNTRY_CODE]
end
|
[
"def",
"country_prefix",
"(",
"country",
")",
"country",
"=",
"country",
".",
"to_s",
".",
"upcase",
"Phonelib",
".",
"phone_data",
"[",
"country",
"]",
"&&",
"Phonelib",
".",
"phone_data",
"[",
"country",
"]",
"[",
"Core",
"::",
"COUNTRY_CODE",
"]",
"end"
] |
returns country prefix for provided country or nil
|
[
"returns",
"country",
"prefix",
"for",
"provided",
"country",
"or",
"nil"
] |
aa0023eab7c896b71275bf342bc7f49735cbdbbf
|
https://github.com/daddyz/phonelib/blob/aa0023eab7c896b71275bf342bc7f49735cbdbbf/lib/phonelib/phone_analyzer_helper.rb#L36-L40
|
12,706
|
daddyz/phonelib
|
lib/phonelib/phone_analyzer_helper.rb
|
Phonelib.PhoneAnalyzerHelper.country_can_dp?
|
def country_can_dp?(country)
Phonelib.phone_data[country] &&
Phonelib.phone_data[country][Core::DOUBLE_COUNTRY_PREFIX_FLAG] &&
!original_starts_with_plus?
end
|
ruby
|
def country_can_dp?(country)
Phonelib.phone_data[country] &&
Phonelib.phone_data[country][Core::DOUBLE_COUNTRY_PREFIX_FLAG] &&
!original_starts_with_plus?
end
|
[
"def",
"country_can_dp?",
"(",
"country",
")",
"Phonelib",
".",
"phone_data",
"[",
"country",
"]",
"&&",
"Phonelib",
".",
"phone_data",
"[",
"country",
"]",
"[",
"Core",
"::",
"DOUBLE_COUNTRY_PREFIX_FLAG",
"]",
"&&",
"!",
"original_starts_with_plus?",
"end"
] |
defines whether country can have double country prefix in number
|
[
"defines",
"whether",
"country",
"can",
"have",
"double",
"country",
"prefix",
"in",
"number"
] |
aa0023eab7c896b71275bf342bc7f49735cbdbbf
|
https://github.com/daddyz/phonelib/blob/aa0023eab7c896b71275bf342bc7f49735cbdbbf/lib/phonelib/phone_analyzer_helper.rb#L48-L52
|
12,707
|
daddyz/phonelib
|
lib/phonelib/phone_analyzer_helper.rb
|
Phonelib.PhoneAnalyzerHelper.double_prefix_allowed?
|
def double_prefix_allowed?(data, phone, parsed = {})
data[Core::DOUBLE_COUNTRY_PREFIX_FLAG] &&
phone =~ cr("^#{data[Core::COUNTRY_CODE]}") &&
parsed && (parsed[:valid].nil? || parsed[:valid].empty?) &&
!original_starts_with_plus?
end
|
ruby
|
def double_prefix_allowed?(data, phone, parsed = {})
data[Core::DOUBLE_COUNTRY_PREFIX_FLAG] &&
phone =~ cr("^#{data[Core::COUNTRY_CODE]}") &&
parsed && (parsed[:valid].nil? || parsed[:valid].empty?) &&
!original_starts_with_plus?
end
|
[
"def",
"double_prefix_allowed?",
"(",
"data",
",",
"phone",
",",
"parsed",
"=",
"{",
"}",
")",
"data",
"[",
"Core",
"::",
"DOUBLE_COUNTRY_PREFIX_FLAG",
"]",
"&&",
"phone",
"=~",
"cr",
"(",
"\"^#{data[Core::COUNTRY_CODE]}\"",
")",
"&&",
"parsed",
"&&",
"(",
"parsed",
"[",
":valid",
"]",
".",
"nil?",
"||",
"parsed",
"[",
":valid",
"]",
".",
"empty?",
")",
"&&",
"!",
"original_starts_with_plus?",
"end"
] |
checks if country can have numbers with double country prefixes
==== Attributes
* +data+ - country data used for parsing
* +phone+ - phone number being parsed
* +parsed+ - parsed regex match for phone
|
[
"checks",
"if",
"country",
"can",
"have",
"numbers",
"with",
"double",
"country",
"prefixes"
] |
aa0023eab7c896b71275bf342bc7f49735cbdbbf
|
https://github.com/daddyz/phonelib/blob/aa0023eab7c896b71275bf342bc7f49735cbdbbf/lib/phonelib/phone_analyzer_helper.rb#L74-L79
|
12,708
|
daddyz/phonelib
|
lib/phonelib/phone_analyzer_helper.rb
|
Phonelib.PhoneAnalyzerHelper.country_or_default_country
|
def country_or_default_country(country)
country ||= (original_starts_with_plus? ? nil : Phonelib.default_country)
country && country.to_s.upcase
end
|
ruby
|
def country_or_default_country(country)
country ||= (original_starts_with_plus? ? nil : Phonelib.default_country)
country && country.to_s.upcase
end
|
[
"def",
"country_or_default_country",
"(",
"country",
")",
"country",
"||=",
"(",
"original_starts_with_plus?",
"?",
"nil",
":",
"Phonelib",
".",
"default_country",
")",
"country",
"&&",
"country",
".",
"to_s",
".",
"upcase",
"end"
] |
Get country that was provided or default country in needable format
==== Attributes
* +country+ - country passed for parsing
|
[
"Get",
"country",
"that",
"was",
"provided",
"or",
"default",
"country",
"in",
"needable",
"format"
] |
aa0023eab7c896b71275bf342bc7f49735cbdbbf
|
https://github.com/daddyz/phonelib/blob/aa0023eab7c896b71275bf342bc7f49735cbdbbf/lib/phonelib/phone_analyzer_helper.rb#L91-L94
|
12,709
|
daddyz/phonelib
|
lib/phonelib/phone_analyzer_helper.rb
|
Phonelib.PhoneAnalyzerHelper.type_regex
|
def type_regex(data, type)
regex = [data[type]]
if Phonelib.parse_special && data[Core::SHORT] && data[Core::SHORT][type]
regex << data[Core::SHORT][type]
end
regex.join('|')
end
|
ruby
|
def type_regex(data, type)
regex = [data[type]]
if Phonelib.parse_special && data[Core::SHORT] && data[Core::SHORT][type]
regex << data[Core::SHORT][type]
end
regex.join('|')
end
|
[
"def",
"type_regex",
"(",
"data",
",",
"type",
")",
"regex",
"=",
"[",
"data",
"[",
"type",
"]",
"]",
"if",
"Phonelib",
".",
"parse_special",
"&&",
"data",
"[",
"Core",
"::",
"SHORT",
"]",
"&&",
"data",
"[",
"Core",
"::",
"SHORT",
"]",
"[",
"type",
"]",
"regex",
"<<",
"data",
"[",
"Core",
"::",
"SHORT",
"]",
"[",
"type",
"]",
"end",
"regex",
".",
"join",
"(",
"'|'",
")",
"end"
] |
Returns regex for type with special types if needed
==== Attributes
* +data+ - country types data for single type
* +type+ - possible or valid regex type needed
|
[
"Returns",
"regex",
"for",
"type",
"with",
"special",
"types",
"if",
"needed"
] |
aa0023eab7c896b71275bf342bc7f49735cbdbbf
|
https://github.com/daddyz/phonelib/blob/aa0023eab7c896b71275bf342bc7f49735cbdbbf/lib/phonelib/phone_analyzer_helper.rb#L120-L126
|
12,710
|
daddyz/phonelib
|
lib/phonelib/phone_analyzer_helper.rb
|
Phonelib.PhoneAnalyzerHelper.phone_match_data?
|
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 = possible ? Core::POSSIBLE_PATTERN : Core::VALID_PATTERN
phone.match full_regex_for_data(data, type, false)
end
|
ruby
|
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 = possible ? Core::POSSIBLE_PATTERN : Core::VALID_PATTERN
phone.match full_regex_for_data(data, type, false)
end
|
[
"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",
"=",
"possible",
"?",
"Core",
"::",
"POSSIBLE_PATTERN",
":",
"Core",
"::",
"VALID_PATTERN",
"phone",
".",
"match",
"full_regex_for_data",
"(",
"data",
",",
"type",
",",
"false",
")",
"end"
] |
Check if phone match country data
==== Attributes
* +phone+ - phone number for parsing
* +data+ - country data
|
[
"Check",
"if",
"phone",
"match",
"country",
"data"
] |
aa0023eab7c896b71275bf342bc7f49735cbdbbf
|
https://github.com/daddyz/phonelib/blob/aa0023eab7c896b71275bf342bc7f49735cbdbbf/lib/phonelib/phone_analyzer_helper.rb#L134-L141
|
12,711
|
daddyz/phonelib
|
lib/phonelib/phone_analyzer_helper.rb
|
Phonelib.PhoneAnalyzerHelper.types_for_check
|
def types_for_check(data)
exclude_list = PhoneAnalyzer::NOT_FOR_CHECK
exclude_list += Phonelib::Core::SHORT_CODES unless Phonelib.parse_special
Core::TYPES_DESC.keys - exclude_list + fixed_and_mobile_keys(data)
end
|
ruby
|
def types_for_check(data)
exclude_list = PhoneAnalyzer::NOT_FOR_CHECK
exclude_list += Phonelib::Core::SHORT_CODES unless Phonelib.parse_special
Core::TYPES_DESC.keys - exclude_list + fixed_and_mobile_keys(data)
end
|
[
"def",
"types_for_check",
"(",
"data",
")",
"exclude_list",
"=",
"PhoneAnalyzer",
"::",
"NOT_FOR_CHECK",
"exclude_list",
"+=",
"Phonelib",
"::",
"Core",
"::",
"SHORT_CODES",
"unless",
"Phonelib",
".",
"parse_special",
"Core",
"::",
"TYPES_DESC",
".",
"keys",
"-",
"exclude_list",
"+",
"fixed_and_mobile_keys",
"(",
"data",
")",
"end"
] |
returns array of phone types for check for current country data
==== Attributes
* +data+ - country data hash
|
[
"returns",
"array",
"of",
"phone",
"types",
"for",
"check",
"for",
"current",
"country",
"data"
] |
aa0023eab7c896b71275bf342bc7f49735cbdbbf
|
https://github.com/daddyz/phonelib/blob/aa0023eab7c896b71275bf342bc7f49735cbdbbf/lib/phonelib/phone_analyzer_helper.rb#L160-L164
|
12,712
|
daddyz/phonelib
|
lib/phonelib/phone_analyzer_helper.rb
|
Phonelib.PhoneAnalyzerHelper.fixed_and_mobile_keys
|
def fixed_and_mobile_keys(data)
if data[Core::FIXED_LINE] == data[Core::MOBILE]
[Core::FIXED_OR_MOBILE]
else
[Core::FIXED_LINE, Core::MOBILE]
end
end
|
ruby
|
def fixed_and_mobile_keys(data)
if data[Core::FIXED_LINE] == data[Core::MOBILE]
[Core::FIXED_OR_MOBILE]
else
[Core::FIXED_LINE, Core::MOBILE]
end
end
|
[
"def",
"fixed_and_mobile_keys",
"(",
"data",
")",
"if",
"data",
"[",
"Core",
"::",
"FIXED_LINE",
"]",
"==",
"data",
"[",
"Core",
"::",
"MOBILE",
"]",
"[",
"Core",
"::",
"FIXED_OR_MOBILE",
"]",
"else",
"[",
"Core",
"::",
"FIXED_LINE",
",",
"Core",
"::",
"MOBILE",
"]",
"end",
"end"
] |
Checks if fixed line pattern and mobile pattern are the same and returns
appropriate keys
==== Attributes
* +data+ - country data
|
[
"Checks",
"if",
"fixed",
"line",
"pattern",
"and",
"mobile",
"pattern",
"are",
"the",
"same",
"and",
"returns",
"appropriate",
"keys"
] |
aa0023eab7c896b71275bf342bc7f49735cbdbbf
|
https://github.com/daddyz/phonelib/blob/aa0023eab7c896b71275bf342bc7f49735cbdbbf/lib/phonelib/phone_analyzer_helper.rb#L172-L178
|
12,713
|
daddyz/phonelib
|
lib/phonelib/phone_analyzer_helper.rb
|
Phonelib.PhoneAnalyzerHelper.number_valid_and_possible?
|
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
valid = !not_valid && possible && number_match?(number, v_regex)
[valid && possible, possible]
end
|
ruby
|
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
valid = !not_valid && possible && number_match?(number, v_regex)
[valid && possible, possible]
end
|
[
"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",
"valid",
"=",
"!",
"not_valid",
"&&",
"possible",
"&&",
"number_match?",
"(",
"number",
",",
"v_regex",
")",
"[",
"valid",
"&&",
"possible",
",",
"possible",
"]",
"end"
] |
Checks if passed number matches valid and possible patterns
==== Attributes
* +number+ - phone number for validation
* +p_regex+ - possible regex pattern for validation
* +v_regex+ - valid regex pattern for validation
* +not_valid+ - specifies that number is not valid by general desc pattern
|
[
"Checks",
"if",
"passed",
"number",
"matches",
"valid",
"and",
"possible",
"patterns"
] |
aa0023eab7c896b71275bf342bc7f49735cbdbbf
|
https://github.com/daddyz/phonelib/blob/aa0023eab7c896b71275bf342bc7f49735cbdbbf/lib/phonelib/phone_analyzer_helper.rb#L188-L195
|
12,714
|
daddyz/phonelib
|
lib/phonelib/phone_analyzer_helper.rb
|
Phonelib.PhoneAnalyzerHelper.number_match?
|
def number_match?(number, regex)
match = number.match(cr("^(?:#{regex})$"))
match && match.to_s.length == number.length
end
|
ruby
|
def number_match?(number, regex)
match = number.match(cr("^(?:#{regex})$"))
match && match.to_s.length == number.length
end
|
[
"def",
"number_match?",
"(",
"number",
",",
"regex",
")",
"match",
"=",
"number",
".",
"match",
"(",
"cr",
"(",
"\"^(?:#{regex})$\"",
")",
")",
"match",
"&&",
"match",
".",
"to_s",
".",
"length",
"==",
"number",
".",
"length",
"end"
] |
Checks number against regex and compares match length
==== Attributes
* +number+ - phone number for validation
* +regex+ - regex for perfoming a validation
|
[
"Checks",
"number",
"against",
"regex",
"and",
"compares",
"match",
"length"
] |
aa0023eab7c896b71275bf342bc7f49735cbdbbf
|
https://github.com/daddyz/phonelib/blob/aa0023eab7c896b71275bf342bc7f49735cbdbbf/lib/phonelib/phone_analyzer_helper.rb#L203-L206
|
12,715
|
daddyz/phonelib
|
lib/phonelib/phone.rb
|
Phonelib.Phone.local_number
|
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')
.gsub(/\$\d/) { |el| format_match[el[1].to_i] }
else
national
end
end
|
ruby
|
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')
.gsub(/\$\d/) { |el| format_match[el[1].to_i] }
else
national
end
end
|
[
"def",
"local_number",
"return",
"national",
"unless",
"possible?",
"format_match",
",",
"format_string",
"=",
"formatting_data",
"if",
"format_string",
"=~",
"/",
"\\$",
"/",
"&&",
"format_match",
"format_string",
".",
"gsub",
"(",
"/",
"\\$",
"/",
",",
"'$2'",
")",
".",
"gsub",
"(",
"/",
"\\$",
"\\d",
"/",
")",
"{",
"|",
"el",
"|",
"format_match",
"[",
"el",
"[",
"1",
"]",
".",
"to_i",
"]",
"}",
"else",
"national",
"end",
"end"
] |
returns local number
@return [String] local number
|
[
"returns",
"local",
"number"
] |
aa0023eab7c896b71275bf342bc7f49735cbdbbf
|
https://github.com/daddyz/phonelib/blob/aa0023eab7c896b71275bf342bc7f49735cbdbbf/lib/phonelib/phone.rb#L140-L150
|
12,716
|
daddyz/phonelib
|
lib/phonelib/phone.rb
|
Phonelib.Phone.valid_for_country?
|
def valid_for_country?(country)
country = country.to_s.upcase
tdata = analyze(sanitized, passed_country(country))
tdata.find do |iso2, data|
country == iso2 && data[:valid].any?
end.is_a? Array
end
|
ruby
|
def valid_for_country?(country)
country = country.to_s.upcase
tdata = analyze(sanitized, passed_country(country))
tdata.find do |iso2, data|
country == iso2 && data[:valid].any?
end.is_a? Array
end
|
[
"def",
"valid_for_country?",
"(",
"country",
")",
"country",
"=",
"country",
".",
"to_s",
".",
"upcase",
"tdata",
"=",
"analyze",
"(",
"sanitized",
",",
"passed_country",
"(",
"country",
")",
")",
"tdata",
".",
"find",
"do",
"|",
"iso2",
",",
"data",
"|",
"country",
"==",
"iso2",
"&&",
"data",
"[",
":valid",
"]",
".",
"any?",
"end",
".",
"is_a?",
"Array",
"end"
] |
Returns whether a current parsed phone number is valid for specified
country
@param country [String|Symbol] ISO code of country (2 letters) like 'US',
'us' or :us for United States
@return [Boolean] parsed phone number is valid
|
[
"Returns",
"whether",
"a",
"current",
"parsed",
"phone",
"number",
"is",
"valid",
"for",
"specified",
"country"
] |
aa0023eab7c896b71275bf342bc7f49735cbdbbf
|
https://github.com/daddyz/phonelib/blob/aa0023eab7c896b71275bf342bc7f49735cbdbbf/lib/phonelib/phone.rb#L157-L163
|
12,717
|
daddyz/phonelib
|
lib/phonelib/data_importer_helper.rb
|
Phonelib.DataImporterHelper.save_data_file
|
def save_data_file
File.open(file_path(Phonelib::Core::FILE_MAIN_DATA), 'wb+') do |f|
Marshal.dump(@data, f)
end
end
|
ruby
|
def save_data_file
File.open(file_path(Phonelib::Core::FILE_MAIN_DATA), 'wb+') do |f|
Marshal.dump(@data, f)
end
end
|
[
"def",
"save_data_file",
"File",
".",
"open",
"(",
"file_path",
"(",
"Phonelib",
"::",
"Core",
"::",
"FILE_MAIN_DATA",
")",
",",
"'wb+'",
")",
"do",
"|",
"f",
"|",
"Marshal",
".",
"dump",
"(",
"@data",
",",
"f",
")",
"end",
"end"
] |
method saves parsed data to data files
|
[
"method",
"saves",
"parsed",
"data",
"to",
"data",
"files"
] |
aa0023eab7c896b71275bf342bc7f49735cbdbbf
|
https://github.com/daddyz/phonelib/blob/aa0023eab7c896b71275bf342bc7f49735cbdbbf/lib/phonelib/data_importer_helper.rb#L14-L18
|
12,718
|
daddyz/phonelib
|
lib/phonelib/data_importer_helper.rb
|
Phonelib.DataImporterHelper.save_extended_data_file
|
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
}
File.open(file_path(Phonelib::Core::FILE_EXT_DATA), 'wb+') do |f|
Marshal.dump(extended, f)
end
puts 'DATA SAVED'
end
|
ruby
|
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
}
File.open(file_path(Phonelib::Core::FILE_EXT_DATA), 'wb+') do |f|
Marshal.dump(extended, f)
end
puts 'DATA SAVED'
end
|
[
"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",
"}",
"File",
".",
"open",
"(",
"file_path",
"(",
"Phonelib",
"::",
"Core",
"::",
"FILE_EXT_DATA",
")",
",",
"'wb+'",
")",
"do",
"|",
"f",
"|",
"Marshal",
".",
"dump",
"(",
"extended",
",",
"f",
")",
"end",
"puts",
"'DATA SAVED'",
"end"
] |
method saves extended data file
|
[
"method",
"saves",
"extended",
"data",
"file"
] |
aa0023eab7c896b71275bf342bc7f49735cbdbbf
|
https://github.com/daddyz/phonelib/blob/aa0023eab7c896b71275bf342bc7f49735cbdbbf/lib/phonelib/data_importer_helper.rb#L21-L33
|
12,719
|
daddyz/phonelib
|
lib/phonelib/data_importer_helper.rb
|
Phonelib.DataImporterHelper.fill_prefixes
|
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 = prefix[0].to_i
prefixes[pr] = fill_prefixes(key, value, prefix[1..-1], prefixes[pr])
end
prefixes
end
|
ruby
|
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 = prefix[0].to_i
prefixes[pr] = fill_prefixes(key, value, prefix[1..-1], prefixes[pr])
end
prefixes
end
|
[
"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",
"=",
"prefix",
"[",
"0",
"]",
".",
"to_i",
"prefixes",
"[",
"pr",
"]",
"=",
"fill_prefixes",
"(",
"key",
",",
"value",
",",
"prefix",
"[",
"1",
"..",
"-",
"1",
"]",
",",
"prefixes",
"[",
"pr",
"]",
")",
"end",
"prefixes",
"end"
] |
method updates prefixes hash recursively
|
[
"method",
"updates",
"prefixes",
"hash",
"recursively"
] |
aa0023eab7c896b71275bf342bc7f49735cbdbbf
|
https://github.com/daddyz/phonelib/blob/aa0023eab7c896b71275bf342bc7f49735cbdbbf/lib/phonelib/data_importer_helper.rb#L36-L47
|
12,720
|
daddyz/phonelib
|
lib/phonelib/data_importer_helper.rb
|
Phonelib.DataImporterHelper.parse_raw_file
|
def parse_raw_file(file)
data = {}
File.readlines(file).each do |line|
line = str_clean line, false
next if line.empty? || line[0] == '#'
prefix, line_data = line.split('|')
data[prefix] = line_data && line_data.strip.split('&')
end
data
end
|
ruby
|
def parse_raw_file(file)
data = {}
File.readlines(file).each do |line|
line = str_clean line, false
next if line.empty? || line[0] == '#'
prefix, line_data = line.split('|')
data[prefix] = line_data && line_data.strip.split('&')
end
data
end
|
[
"def",
"parse_raw_file",
"(",
"file",
")",
"data",
"=",
"{",
"}",
"File",
".",
"readlines",
"(",
"file",
")",
".",
"each",
"do",
"|",
"line",
"|",
"line",
"=",
"str_clean",
"line",
",",
"false",
"next",
"if",
"line",
".",
"empty?",
"||",
"line",
"[",
"0",
"]",
"==",
"'#'",
"prefix",
",",
"line_data",
"=",
"line",
".",
"split",
"(",
"'|'",
")",
"data",
"[",
"prefix",
"]",
"=",
"line_data",
"&&",
"line_data",
".",
"strip",
".",
"split",
"(",
"'&'",
")",
"end",
"data",
"end"
] |
method parses raw data file
|
[
"method",
"parses",
"raw",
"data",
"file"
] |
aa0023eab7c896b71275bf342bc7f49735cbdbbf
|
https://github.com/daddyz/phonelib/blob/aa0023eab7c896b71275bf342bc7f49735cbdbbf/lib/phonelib/data_importer_helper.rb#L98-L107
|
12,721
|
daddyz/phonelib
|
lib/phonelib/data_importer_helper.rb
|
Phonelib.DataImporterHelper.main_from_xml
|
def main_from_xml(file)
xml_data = File.read(file)
xml_data.force_encoding('utf-8')
doc = Nokogiri::XML(xml_data)
doc.elements.first.elements.first
end
|
ruby
|
def main_from_xml(file)
xml_data = File.read(file)
xml_data.force_encoding('utf-8')
doc = Nokogiri::XML(xml_data)
doc.elements.first.elements.first
end
|
[
"def",
"main_from_xml",
"(",
"file",
")",
"xml_data",
"=",
"File",
".",
"read",
"(",
"file",
")",
"xml_data",
".",
"force_encoding",
"(",
"'utf-8'",
")",
"doc",
"=",
"Nokogiri",
"::",
"XML",
"(",
"xml_data",
")",
"doc",
".",
"elements",
".",
"first",
".",
"elements",
".",
"first",
"end"
] |
get main body from parsed xml document
|
[
"get",
"main",
"body",
"from",
"parsed",
"xml",
"document"
] |
aa0023eab7c896b71275bf342bc7f49735cbdbbf
|
https://github.com/daddyz/phonelib/blob/aa0023eab7c896b71275bf342bc7f49735cbdbbf/lib/phonelib/data_importer_helper.rb#L110-L116
|
12,722
|
daddyz/phonelib
|
lib/phonelib/phone_formatter.rb
|
Phonelib.PhoneFormatter.national
|
def national(formatted = true)
return @national_number unless valid?
format_match, format_string = formatting_data
if format_match
out = format_string.gsub(/\$\d/) { |el| format_match[el[1].to_i] }
formatted ? out : out.gsub(/[^0-9]/, '')
else
@national_number
end
end
|
ruby
|
def national(formatted = true)
return @national_number unless valid?
format_match, format_string = formatting_data
if format_match
out = format_string.gsub(/\$\d/) { |el| format_match[el[1].to_i] }
formatted ? out : out.gsub(/[^0-9]/, '')
else
@national_number
end
end
|
[
"def",
"national",
"(",
"formatted",
"=",
"true",
")",
"return",
"@national_number",
"unless",
"valid?",
"format_match",
",",
"format_string",
"=",
"formatting_data",
"if",
"format_match",
"out",
"=",
"format_string",
".",
"gsub",
"(",
"/",
"\\$",
"\\d",
"/",
")",
"{",
"|",
"el",
"|",
"format_match",
"[",
"el",
"[",
"1",
"]",
".",
"to_i",
"]",
"}",
"formatted",
"?",
"out",
":",
"out",
".",
"gsub",
"(",
"/",
"/",
",",
"''",
")",
"else",
"@national_number",
"end",
"end"
] |
Returns formatted national number
@param formatted [Boolean] whether to return numbers only or formatted
@return [String] formatted national number
|
[
"Returns",
"formatted",
"national",
"number"
] |
aa0023eab7c896b71275bf342bc7f49735cbdbbf
|
https://github.com/daddyz/phonelib/blob/aa0023eab7c896b71275bf342bc7f49735cbdbbf/lib/phonelib/phone_formatter.rb#L7-L17
|
12,723
|
daddyz/phonelib
|
lib/phonelib/phone_formatter.rb
|
Phonelib.PhoneFormatter.raw_national
|
def raw_national
return nil if sanitized.nil? || sanitized.empty?
if valid?
@national_number
elsif country_code && sanitized.start_with?(country_code)
sanitized[country_code.size..-1]
else
sanitized
end
end
|
ruby
|
def raw_national
return nil if sanitized.nil? || sanitized.empty?
if valid?
@national_number
elsif country_code && sanitized.start_with?(country_code)
sanitized[country_code.size..-1]
else
sanitized
end
end
|
[
"def",
"raw_national",
"return",
"nil",
"if",
"sanitized",
".",
"nil?",
"||",
"sanitized",
".",
"empty?",
"if",
"valid?",
"@national_number",
"elsif",
"country_code",
"&&",
"sanitized",
".",
"start_with?",
"(",
"country_code",
")",
"sanitized",
"[",
"country_code",
".",
"size",
"..",
"-",
"1",
"]",
"else",
"sanitized",
"end",
"end"
] |
Returns the raw national number that was defined during parsing
@return [String] raw national number
|
[
"Returns",
"the",
"raw",
"national",
"number",
"that",
"was",
"defined",
"during",
"parsing"
] |
aa0023eab7c896b71275bf342bc7f49735cbdbbf
|
https://github.com/daddyz/phonelib/blob/aa0023eab7c896b71275bf342bc7f49735cbdbbf/lib/phonelib/phone_formatter.rb#L21-L30
|
12,724
|
daddyz/phonelib
|
lib/phonelib/phone_formatter.rb
|
Phonelib.PhoneFormatter.international
|
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]
national = @national_number
if (matches = @national_number.match(cr(fmt[Core::PATTERN])))
fmt = fmt[:intl_format] || fmt[:format]
national = fmt.gsub(/\$\d/) { |el| matches[el[1].to_i] } unless fmt == 'NA'
end
"#{prefix}#{country_code} #{national}"
end
|
ruby
|
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]
national = @national_number
if (matches = @national_number.match(cr(fmt[Core::PATTERN])))
fmt = fmt[:intl_format] || fmt[:format]
national = fmt.gsub(/\$\d/) { |el| matches[el[1].to_i] } unless fmt == 'NA'
end
"#{prefix}#{country_code} #{national}"
end
|
[
"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",
"]",
"national",
"=",
"@national_number",
"if",
"(",
"matches",
"=",
"@national_number",
".",
"match",
"(",
"cr",
"(",
"fmt",
"[",
"Core",
"::",
"PATTERN",
"]",
")",
")",
")",
"fmt",
"=",
"fmt",
"[",
":intl_format",
"]",
"||",
"fmt",
"[",
":format",
"]",
"national",
"=",
"fmt",
".",
"gsub",
"(",
"/",
"\\$",
"\\d",
"/",
")",
"{",
"|",
"el",
"|",
"matches",
"[",
"el",
"[",
"1",
"]",
".",
"to_i",
"]",
"}",
"unless",
"fmt",
"==",
"'NA'",
"end",
"\"#{prefix}#{country_code} #{national}\"",
"end"
] |
Returns e164 formatted phone number. Method can receive single string parameter that will be defined as prefix
@param formatted [Boolean] whether to return numbers only or formatted
@param prefix [String] prefix to be placed before the number, "+" by default
@return [String] formatted international number
|
[
"Returns",
"e164",
"formatted",
"phone",
"number",
".",
"Method",
"can",
"receive",
"single",
"string",
"parameter",
"that",
"will",
"be",
"defined",
"as",
"prefix"
] |
aa0023eab7c896b71275bf342bc7f49735cbdbbf
|
https://github.com/daddyz/phonelib/blob/aa0023eab7c896b71275bf342bc7f49735cbdbbf/lib/phonelib/phone_formatter.rb#L43-L57
|
12,725
|
daddyz/phonelib
|
lib/phonelib/phone_formatter.rb
|
Phonelib.PhoneFormatter.area_code
|
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] == Core::AREA_CODE_MOBILE_TOKENS[country]
take_group = 2
end
format_match[take_group]
end
|
ruby
|
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] == Core::AREA_CODE_MOBILE_TOKENS[country]
take_group = 2
end
format_match[take_group]
end
|
[
"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",
"]",
"==",
"Core",
"::",
"AREA_CODE_MOBILE_TOKENS",
"[",
"country",
"]",
"take_group",
"=",
"2",
"end",
"format_match",
"[",
"take_group",
"]",
"end"
] |
returns area code of parsed number
@return [String|nil] parsed phone area code if available
|
[
"returns",
"area",
"code",
"of",
"parsed",
"number"
] |
aa0023eab7c896b71275bf342bc7f49735cbdbbf
|
https://github.com/daddyz/phonelib/blob/aa0023eab7c896b71275bf342bc7f49735cbdbbf/lib/phonelib/phone_formatter.rb#L89-L99
|
12,726
|
ruby/psych
|
lib/psych/scalar_scanner.rb
|
Psych.ScalarScanner.tokenize
|
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).
when /^[^\d\.:-]?[A-Za-z_\s!@#\$%\^&\*\(\)\{\}\<\>\|\/\\~;=]+/, /\n/
if string.length > 5
@string_cache[string] = true
return string
end
case string
when /^[^ytonf~]/i
@string_cache[string] = true
string
when '~', /^null$/i
nil
when /^(yes|true|on)$/i
true
when /^(no|false|off)$/i
false
else
@string_cache[string] = true
string
end
when TIME
begin
parse_time string
rescue ArgumentError
string
end
when /^\d{4}-(?:1[012]|0\d|\d)-(?:[12]\d|3[01]|0\d|\d)$/
require 'date'
begin
class_loader.date.strptime(string, '%Y-%m-%d')
rescue ArgumentError
string
end
when /^\.inf$/i
Float::INFINITY
when /^-\.inf$/i
-Float::INFINITY
when /^\.nan$/i
Float::NAN
when /^:./
if string =~ /^:(["'])(.*)\1/
@symbol_cache[string] = class_loader.symbolize($2.sub(/^:/, ''))
else
@symbol_cache[string] = class_loader.symbolize(string.sub(/^:/, ''))
end
when /^[-+]?[0-9][0-9_]*(:[0-5]?[0-9]){1,2}$/
i = 0
string.split(':').each_with_index do |n,e|
i += (n.to_i * 60 ** (e - 2).abs)
end
i
when /^[-+]?[0-9][0-9_]*(:[0-5]?[0-9]){1,2}\.[0-9_]*$/
i = 0
string.split(':').each_with_index do |n,e|
i += (n.to_f * 60 ** (e - 2).abs)
end
i
when FLOAT
if string =~ /\A[-+]?\.\Z/
@string_cache[string] = true
string
else
Float(string.gsub(/[,_]|\.([Ee]|$)/, '\1'))
end
else
int = parse_int string.gsub(/[,_]/, '')
return int if int
@string_cache[string] = true
string
end
end
|
ruby
|
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).
when /^[^\d\.:-]?[A-Za-z_\s!@#\$%\^&\*\(\)\{\}\<\>\|\/\\~;=]+/, /\n/
if string.length > 5
@string_cache[string] = true
return string
end
case string
when /^[^ytonf~]/i
@string_cache[string] = true
string
when '~', /^null$/i
nil
when /^(yes|true|on)$/i
true
when /^(no|false|off)$/i
false
else
@string_cache[string] = true
string
end
when TIME
begin
parse_time string
rescue ArgumentError
string
end
when /^\d{4}-(?:1[012]|0\d|\d)-(?:[12]\d|3[01]|0\d|\d)$/
require 'date'
begin
class_loader.date.strptime(string, '%Y-%m-%d')
rescue ArgumentError
string
end
when /^\.inf$/i
Float::INFINITY
when /^-\.inf$/i
-Float::INFINITY
when /^\.nan$/i
Float::NAN
when /^:./
if string =~ /^:(["'])(.*)\1/
@symbol_cache[string] = class_loader.symbolize($2.sub(/^:/, ''))
else
@symbol_cache[string] = class_loader.symbolize(string.sub(/^:/, ''))
end
when /^[-+]?[0-9][0-9_]*(:[0-5]?[0-9]){1,2}$/
i = 0
string.split(':').each_with_index do |n,e|
i += (n.to_i * 60 ** (e - 2).abs)
end
i
when /^[-+]?[0-9][0-9_]*(:[0-5]?[0-9]){1,2}\.[0-9_]*$/
i = 0
string.split(':').each_with_index do |n,e|
i += (n.to_f * 60 ** (e - 2).abs)
end
i
when FLOAT
if string =~ /\A[-+]?\.\Z/
@string_cache[string] = true
string
else
Float(string.gsub(/[,_]|\.([Ee]|$)/, '\1'))
end
else
int = parse_int string.gsub(/[,_]/, '')
return int if int
@string_cache[string] = true
string
end
end
|
[
"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).",
"when",
"/",
"\\d",
"\\.",
"\\s",
"\\$",
"\\^",
"\\*",
"\\(",
"\\)",
"\\{",
"\\}",
"\\<",
"\\>",
"\\|",
"\\/",
"\\\\",
"/",
",",
"/",
"\\n",
"/",
"if",
"string",
".",
"length",
">",
"5",
"@string_cache",
"[",
"string",
"]",
"=",
"true",
"return",
"string",
"end",
"case",
"string",
"when",
"/",
"/i",
"@string_cache",
"[",
"string",
"]",
"=",
"true",
"string",
"when",
"'~'",
",",
"/",
"/i",
"nil",
"when",
"/",
"/i",
"true",
"when",
"/",
"/i",
"false",
"else",
"@string_cache",
"[",
"string",
"]",
"=",
"true",
"string",
"end",
"when",
"TIME",
"begin",
"parse_time",
"string",
"rescue",
"ArgumentError",
"string",
"end",
"when",
"/",
"\\d",
"\\d",
"\\d",
"\\d",
"\\d",
"\\d",
"/",
"require",
"'date'",
"begin",
"class_loader",
".",
"date",
".",
"strptime",
"(",
"string",
",",
"'%Y-%m-%d'",
")",
"rescue",
"ArgumentError",
"string",
"end",
"when",
"/",
"\\.",
"/i",
"Float",
"::",
"INFINITY",
"when",
"/",
"\\.",
"/i",
"-",
"Float",
"::",
"INFINITY",
"when",
"/",
"\\.",
"/i",
"Float",
"::",
"NAN",
"when",
"/",
"/",
"if",
"string",
"=~",
"/",
"\\1",
"/",
"@symbol_cache",
"[",
"string",
"]",
"=",
"class_loader",
".",
"symbolize",
"(",
"$2",
".",
"sub",
"(",
"/",
"/",
",",
"''",
")",
")",
"else",
"@symbol_cache",
"[",
"string",
"]",
"=",
"class_loader",
".",
"symbolize",
"(",
"string",
".",
"sub",
"(",
"/",
"/",
",",
"''",
")",
")",
"end",
"when",
"/",
"/",
"i",
"=",
"0",
"string",
".",
"split",
"(",
"':'",
")",
".",
"each_with_index",
"do",
"|",
"n",
",",
"e",
"|",
"i",
"+=",
"(",
"n",
".",
"to_i",
"*",
"60",
"**",
"(",
"e",
"-",
"2",
")",
".",
"abs",
")",
"end",
"i",
"when",
"/",
"\\.",
"/",
"i",
"=",
"0",
"string",
".",
"split",
"(",
"':'",
")",
".",
"each_with_index",
"do",
"|",
"n",
",",
"e",
"|",
"i",
"+=",
"(",
"n",
".",
"to_f",
"*",
"60",
"**",
"(",
"e",
"-",
"2",
")",
".",
"abs",
")",
"end",
"i",
"when",
"FLOAT",
"if",
"string",
"=~",
"/",
"\\A",
"\\.",
"\\Z",
"/",
"@string_cache",
"[",
"string",
"]",
"=",
"true",
"string",
"else",
"Float",
"(",
"string",
".",
"gsub",
"(",
"/",
"\\.",
"/",
",",
"'\\1'",
")",
")",
"end",
"else",
"int",
"=",
"parse_int",
"string",
".",
"gsub",
"(",
"/",
"/",
",",
"''",
")",
"return",
"int",
"if",
"int",
"@string_cache",
"[",
"string",
"]",
"=",
"true",
"string",
"end",
"end"
] |
Create a new scanner
Tokenize +string+ returning the Ruby object
|
[
"Create",
"a",
"new",
"scanner",
"Tokenize",
"+",
"string",
"+",
"returning",
"the",
"Ruby",
"object"
] |
f3a37e6bc1c2a98bfc9fafc389ea05622c744af9
|
https://github.com/ruby/psych/blob/f3a37e6bc1c2a98bfc9fafc389ea05622c744af9/lib/psych/scalar_scanner.rb#L32-L111
|
12,727
|
ruby/psych
|
lib/psych/scalar_scanner.rb
|
Psych.ScalarScanner.parse_time
|
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 { |x| x.to_i }
us = (md[2] ? Rational("0.#{md[2]}") : 0) * 1000000
time = klass.utc(yy, m, dd, hh, mm, ss, us)
return time if 'Z' == md[3]
return klass.at(time.to_i, us) unless md[3]
tz = md[3].match(/^([+\-]?\d{1,2})\:?(\d{1,2})?$/)[1..-1].compact.map { |digit| Integer(digit, 10) }
offset = tz.first * 3600
if offset < 0
offset -= ((tz[1] || 0) * 60)
else
offset += ((tz[1] || 0) * 60)
end
klass.new(yy, m, dd, hh, mm, ss+us/(1_000_000r), offset)
end
|
ruby
|
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 { |x| x.to_i }
us = (md[2] ? Rational("0.#{md[2]}") : 0) * 1000000
time = klass.utc(yy, m, dd, hh, mm, ss, us)
return time if 'Z' == md[3]
return klass.at(time.to_i, us) unless md[3]
tz = md[3].match(/^([+\-]?\d{1,2})\:?(\d{1,2})?$/)[1..-1].compact.map { |digit| Integer(digit, 10) }
offset = tz.first * 3600
if offset < 0
offset -= ((tz[1] || 0) * 60)
else
offset += ((tz[1] || 0) * 60)
end
klass.new(yy, m, dd, hh, mm, ss+us/(1_000_000r), offset)
end
|
[
"def",
"parse_time",
"string",
"klass",
"=",
"class_loader",
".",
"load",
"'Time'",
"date",
",",
"time",
"=",
"(",
"string",
".",
"split",
"(",
"/",
"/",
",",
"2",
")",
")",
"(",
"yy",
",",
"m",
",",
"dd",
")",
"=",
"date",
".",
"match",
"(",
"/",
"\\d",
"\\d",
"\\d",
"/",
")",
".",
"captures",
".",
"map",
"{",
"|",
"x",
"|",
"x",
".",
"to_i",
"}",
"md",
"=",
"time",
".",
"match",
"(",
"/",
"\\d",
"\\d",
"\\d",
"\\.",
"\\d",
"\\s",
"\\d",
"\\d",
"\\d",
"/",
")",
"(",
"hh",
",",
"mm",
",",
"ss",
")",
"=",
"md",
"[",
"1",
"]",
".",
"split",
"(",
"':'",
")",
".",
"map",
"{",
"|",
"x",
"|",
"x",
".",
"to_i",
"}",
"us",
"=",
"(",
"md",
"[",
"2",
"]",
"?",
"Rational",
"(",
"\"0.#{md[2]}\"",
")",
":",
"0",
")",
"*",
"1000000",
"time",
"=",
"klass",
".",
"utc",
"(",
"yy",
",",
"m",
",",
"dd",
",",
"hh",
",",
"mm",
",",
"ss",
",",
"us",
")",
"return",
"time",
"if",
"'Z'",
"==",
"md",
"[",
"3",
"]",
"return",
"klass",
".",
"at",
"(",
"time",
".",
"to_i",
",",
"us",
")",
"unless",
"md",
"[",
"3",
"]",
"tz",
"=",
"md",
"[",
"3",
"]",
".",
"match",
"(",
"/",
"\\-",
"\\d",
"\\:",
"\\d",
"/",
")",
"[",
"1",
"..",
"-",
"1",
"]",
".",
"compact",
".",
"map",
"{",
"|",
"digit",
"|",
"Integer",
"(",
"digit",
",",
"10",
")",
"}",
"offset",
"=",
"tz",
".",
"first",
"*",
"3600",
"if",
"offset",
"<",
"0",
"offset",
"-=",
"(",
"(",
"tz",
"[",
"1",
"]",
"||",
"0",
")",
"*",
"60",
")",
"else",
"offset",
"+=",
"(",
"(",
"tz",
"[",
"1",
"]",
"||",
"0",
")",
"*",
"60",
")",
"end",
"klass",
".",
"new",
"(",
"yy",
",",
"m",
",",
"dd",
",",
"hh",
",",
"mm",
",",
"ss",
"+",
"us",
"/",
"(",
"1_000_000",
"r",
")",
",",
"offset",
")",
"end"
] |
Parse and return a Time from +string+
|
[
"Parse",
"and",
"return",
"a",
"Time",
"from",
"+",
"string",
"+"
] |
f3a37e6bc1c2a98bfc9fafc389ea05622c744af9
|
https://github.com/ruby/psych/blob/f3a37e6bc1c2a98bfc9fafc389ea05622c744af9/lib/psych/scalar_scanner.rb#L122-L147
|
12,728
|
ruby/psych
|
lib/psych/tree_builder.rb
|
Psych.TreeBuilder.start_document
|
def start_document version, tag_directives, implicit
n = Nodes::Document.new version, tag_directives, implicit
set_start_location(n)
@last.children << n
push n
end
|
ruby
|
def start_document version, tag_directives, implicit
n = Nodes::Document.new version, tag_directives, implicit
set_start_location(n)
@last.children << n
push n
end
|
[
"def",
"start_document",
"version",
",",
"tag_directives",
",",
"implicit",
"n",
"=",
"Nodes",
"::",
"Document",
".",
"new",
"version",
",",
"tag_directives",
",",
"implicit",
"set_start_location",
"(",
"n",
")",
"@last",
".",
"children",
"<<",
"n",
"push",
"n",
"end"
] |
Handles start_document events with +version+, +tag_directives+,
and +implicit+ styling.
See Psych::Handler#start_document
|
[
"Handles",
"start_document",
"events",
"with",
"+",
"version",
"+",
"+",
"tag_directives",
"+",
"and",
"+",
"implicit",
"+",
"styling",
"."
] |
f3a37e6bc1c2a98bfc9fafc389ea05622c744af9
|
https://github.com/ruby/psych/blob/f3a37e6bc1c2a98bfc9fafc389ea05622c744af9/lib/psych/tree_builder.rb#L65-L70
|
12,729
|
ruby/psych
|
lib/psych/tree_builder.rb
|
Psych.TreeBuilder.end_document
|
def end_document implicit_end = !streaming?
@last.implicit_end = implicit_end
n = pop
set_end_location(n)
n
end
|
ruby
|
def end_document implicit_end = !streaming?
@last.implicit_end = implicit_end
n = pop
set_end_location(n)
n
end
|
[
"def",
"end_document",
"implicit_end",
"=",
"!",
"streaming?",
"@last",
".",
"implicit_end",
"=",
"implicit_end",
"n",
"=",
"pop",
"set_end_location",
"(",
"n",
")",
"n",
"end"
] |
Handles end_document events with +version+, +tag_directives+,
and +implicit+ styling.
See Psych::Handler#start_document
|
[
"Handles",
"end_document",
"events",
"with",
"+",
"version",
"+",
"+",
"tag_directives",
"+",
"and",
"+",
"implicit",
"+",
"styling",
"."
] |
f3a37e6bc1c2a98bfc9fafc389ea05622c744af9
|
https://github.com/ruby/psych/blob/f3a37e6bc1c2a98bfc9fafc389ea05622c744af9/lib/psych/tree_builder.rb#L77-L82
|
12,730
|
etewiah/property_web_builder
|
app/controllers/pwb/api/v1/translations_controller.rb
|
Pwb.Api::V1::TranslationsController.delete_translation_values
|
def delete_translation_values
field_key = FieldKey.find_by_global_key(params[:i18n_key])
field_key.visible = false
# not convinced it makes sense to delete the associated translations
# phrases = I18n::Backend::ActiveRecord::Translation.where(:key => params[:i18n_key])
# phrases.destroy_all
field_key.save!
render json: { success: true }
end
|
ruby
|
def delete_translation_values
field_key = FieldKey.find_by_global_key(params[:i18n_key])
field_key.visible = false
# not convinced it makes sense to delete the associated translations
# phrases = I18n::Backend::ActiveRecord::Translation.where(:key => params[:i18n_key])
# phrases.destroy_all
field_key.save!
render json: { success: true }
end
|
[
"def",
"delete_translation_values",
"field_key",
"=",
"FieldKey",
".",
"find_by_global_key",
"(",
"params",
"[",
":i18n_key",
"]",
")",
"field_key",
".",
"visible",
"=",
"false",
"# not convinced it makes sense to delete the associated translations",
"# phrases = I18n::Backend::ActiveRecord::Translation.where(:key => params[:i18n_key])",
"# phrases.destroy_all",
"field_key",
".",
"save!",
"render",
"json",
":",
"{",
"success",
":",
"true",
"}",
"end"
] |
deletes the field_key referencing the translation
|
[
"deletes",
"the",
"field_key",
"referencing",
"the",
"translation"
] |
fba4e6d4ffa7bc1f4d3b50dfa5a6a9fbfee23f21
|
https://github.com/etewiah/property_web_builder/blob/fba4e6d4ffa7bc1f4d3b50dfa5a6a9fbfee23f21/app/controllers/pwb/api/v1/translations_controller.rb#L49-L59
|
12,731
|
etewiah/property_web_builder
|
app/controllers/pwb/api/v1/translations_controller.rb
|
Pwb.Api::V1::TranslationsController.create_for_locale
|
def create_for_locale
field_key = FieldKey.find_by_global_key(params[:i18n_key])
phrase = I18n::Backend::ActiveRecord::Translation.find_or_create_by(
key: field_key.global_key,
locale: params[:locale]
)
unless phrase.value.present?
I18n.backend.reload!
phrase.value = params[:i18n_value]
phrase.save!
end
render json: { success: true }
end
|
ruby
|
def create_for_locale
field_key = FieldKey.find_by_global_key(params[:i18n_key])
phrase = I18n::Backend::ActiveRecord::Translation.find_or_create_by(
key: field_key.global_key,
locale: params[:locale]
)
unless phrase.value.present?
I18n.backend.reload!
phrase.value = params[:i18n_value]
phrase.save!
end
render json: { success: true }
end
|
[
"def",
"create_for_locale",
"field_key",
"=",
"FieldKey",
".",
"find_by_global_key",
"(",
"params",
"[",
":i18n_key",
"]",
")",
"phrase",
"=",
"I18n",
"::",
"Backend",
"::",
"ActiveRecord",
"::",
"Translation",
".",
"find_or_create_by",
"(",
"key",
":",
"field_key",
".",
"global_key",
",",
"locale",
":",
"params",
"[",
":locale",
"]",
")",
"unless",
"phrase",
".",
"value",
".",
"present?",
"I18n",
".",
"backend",
".",
"reload!",
"phrase",
".",
"value",
"=",
"params",
"[",
":i18n_value",
"]",
"phrase",
".",
"save!",
"end",
"render",
"json",
":",
"{",
"success",
":",
"true",
"}",
"end"
] |
below for adding new locale to an existing translation
|
[
"below",
"for",
"adding",
"new",
"locale",
"to",
"an",
"existing",
"translation"
] |
fba4e6d4ffa7bc1f4d3b50dfa5a6a9fbfee23f21
|
https://github.com/etewiah/property_web_builder/blob/fba4e6d4ffa7bc1f4d3b50dfa5a6a9fbfee23f21/app/controllers/pwb/api/v1/translations_controller.rb#L109-L121
|
12,732
|
etewiah/property_web_builder
|
app/controllers/pwb/search_controller.rb
|
Pwb.SearchController.buy
|
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_contents.each do |page_content|
# @content_to_show.push page_content.content.raw
# end
end
# @page_title = I18n.t("searchForProperties")
# in erb template for this action, I have js that will render search_results template
# for properties - like search_ajax action does
@operation_type = "for_sale"
# above used to decide if link to result should be to buy or rent path
@properties = Prop.visible.for_sale.limit 45
# ordering happens clientside
# .order('price_sale_current_cents ASC').limit 35
@prices_from_collection = @current_website.sale_price_options_from
@prices_till_collection = @current_website.sale_price_options_till
# @prices_collection = @current_website.sale_price_options_from
# %W(#{''} 25,000 50,000 75,000 100,000 150,000 250,000 500,000 1,000,000 2,000,000 5,000,000 )
# ..
set_common_search_inputs
set_select_picker_texts
apply_search_filter filtering_params(params)
set_map_markers
# below allows setting in form of any input values that might have been passed by param
@search_defaults = params[:search].present? ? params[:search] : {}
# {"property_type" => ""}
# below won't sort right away as the list of results is loaded by js
# and so won't be ready for sorting when below is called - but will wire up for sorting button
# initial client sort called by INMOAPP.sortSearchResults();
js 'Main/Search#sort' # trigger client-side paloma script
render "/pwb/search/buy"
end
|
ruby
|
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_contents.each do |page_content|
# @content_to_show.push page_content.content.raw
# end
end
# @page_title = I18n.t("searchForProperties")
# in erb template for this action, I have js that will render search_results template
# for properties - like search_ajax action does
@operation_type = "for_sale"
# above used to decide if link to result should be to buy or rent path
@properties = Prop.visible.for_sale.limit 45
# ordering happens clientside
# .order('price_sale_current_cents ASC').limit 35
@prices_from_collection = @current_website.sale_price_options_from
@prices_till_collection = @current_website.sale_price_options_till
# @prices_collection = @current_website.sale_price_options_from
# %W(#{''} 25,000 50,000 75,000 100,000 150,000 250,000 500,000 1,000,000 2,000,000 5,000,000 )
# ..
set_common_search_inputs
set_select_picker_texts
apply_search_filter filtering_params(params)
set_map_markers
# below allows setting in form of any input values that might have been passed by param
@search_defaults = params[:search].present? ? params[:search] : {}
# {"property_type" => ""}
# below won't sort right away as the list of results is loaded by js
# and so won't be ready for sorting when below is called - but will wire up for sorting button
# initial client sort called by INMOAPP.sortSearchResults();
js 'Main/Search#sort' # trigger client-side paloma script
render "/pwb/search/buy"
end
|
[
"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_contents.each do |page_content|",
"# @content_to_show.push page_content.content.raw",
"# end",
"end",
"# @page_title = I18n.t(\"searchForProperties\")",
"# in erb template for this action, I have js that will render search_results template",
"# for properties - like search_ajax action does",
"@operation_type",
"=",
"\"for_sale\"",
"# above used to decide if link to result should be to buy or rent path",
"@properties",
"=",
"Prop",
".",
"visible",
".",
"for_sale",
".",
"limit",
"45",
"# ordering happens clientside",
"# .order('price_sale_current_cents ASC').limit 35",
"@prices_from_collection",
"=",
"@current_website",
".",
"sale_price_options_from",
"@prices_till_collection",
"=",
"@current_website",
".",
"sale_price_options_till",
"# @prices_collection = @current_website.sale_price_options_from",
"# %W(#{''} 25,000 50,000 75,000 100,000 150,000 250,000 500,000 1,000,000 2,000,000 5,000,000 )",
"# ..",
"set_common_search_inputs",
"set_select_picker_texts",
"apply_search_filter",
"filtering_params",
"(",
"params",
")",
"set_map_markers",
"# below allows setting in form of any input values that might have been passed by param",
"@search_defaults",
"=",
"params",
"[",
":search",
"]",
".",
"present?",
"?",
"params",
"[",
":search",
"]",
":",
"{",
"}",
"# {\"property_type\" => \"\"}",
"# below won't sort right away as the list of results is loaded by js",
"# and so won't be ready for sorting when below is called - but will wire up for sorting button",
"# initial client sort called by INMOAPP.sortSearchResults();",
"js",
"'Main/Search#sort'",
"# trigger client-side paloma script",
"render",
"\"/pwb/search/buy\"",
"end"
] |
ordering of results happens client-side with paloma search.js
|
[
"ordering",
"of",
"results",
"happens",
"client",
"-",
"side",
"with",
"paloma",
"search",
".",
"js"
] |
fba4e6d4ffa7bc1f4d3b50dfa5a6a9fbfee23f21
|
https://github.com/etewiah/property_web_builder/blob/fba4e6d4ffa7bc1f4d3b50dfa5a6a9fbfee23f21/app/controllers/pwb/search_controller.rb#L33-L75
|
12,733
|
etewiah/property_web_builder
|
app/models/pwb/prop.rb
|
Pwb.Prop.set_features=
|
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
features.find_or_create_by( feature_key: feature_key)
else
features.where( feature_key: feature_key).delete_all
end
end
end
|
ruby
|
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
features.find_or_create_by( feature_key: feature_key)
else
features.where( feature_key: feature_key).delete_all
end
end
end
|
[
"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",
"features",
".",
"find_or_create_by",
"(",
"feature_key",
":",
"feature_key",
")",
"else",
"features",
".",
"where",
"(",
"feature_key",
":",
"feature_key",
")",
".",
"delete_all",
"end",
"end",
"end"
] |
Setter- called by update_extras in properties controller
expects a hash with keys like "cl.casafactory.fieldLabels.extras.alarma"
each with a value of true or false
|
[
"Setter",
"-",
"called",
"by",
"update_extras",
"in",
"properties",
"controller",
"expects",
"a",
"hash",
"with",
"keys",
"like",
"cl",
".",
"casafactory",
".",
"fieldLabels",
".",
"extras",
".",
"alarma",
"each",
"with",
"a",
"value",
"of",
"true",
"or",
"false"
] |
fba4e6d4ffa7bc1f4d3b50dfa5a6a9fbfee23f21
|
https://github.com/etewiah/property_web_builder/blob/fba4e6d4ffa7bc1f4d3b50dfa5a6a9fbfee23f21/app/models/pwb/prop.rb#L113-L123
|
12,734
|
etewiah/property_web_builder
|
app/models/pwb/prop.rb
|
Pwb.Prop.contextual_price_with_currency
|
def contextual_price_with_currency(rent_or_sale)
contextual_price = self.contextual_price rent_or_sale
if contextual_price.zero?
return nil
else
return contextual_price.format(no_cents: true)
end
# return contextual_price.zero? ? nil : contextual_price.format(:no_cents => true)
end
|
ruby
|
def contextual_price_with_currency(rent_or_sale)
contextual_price = self.contextual_price rent_or_sale
if contextual_price.zero?
return nil
else
return contextual_price.format(no_cents: true)
end
# return contextual_price.zero? ? nil : contextual_price.format(:no_cents => true)
end
|
[
"def",
"contextual_price_with_currency",
"(",
"rent_or_sale",
")",
"contextual_price",
"=",
"self",
".",
"contextual_price",
"rent_or_sale",
"if",
"contextual_price",
".",
"zero?",
"return",
"nil",
"else",
"return",
"contextual_price",
".",
"format",
"(",
"no_cents",
":",
"true",
")",
"end",
"# return contextual_price.zero? ? nil : contextual_price.format(:no_cents => true)",
"end"
] |
will return nil if price is 0
|
[
"will",
"return",
"nil",
"if",
"price",
"is",
"0"
] |
fba4e6d4ffa7bc1f4d3b50dfa5a6a9fbfee23f21
|
https://github.com/etewiah/property_web_builder/blob/fba4e6d4ffa7bc1f4d3b50dfa5a6a9fbfee23f21/app/models/pwb/prop.rb#L211-L220
|
12,735
|
etewiah/property_web_builder
|
app/controllers/pwb/api/v1/web_contents_controller.rb
|
Pwb.Api::V1::WebContentsController.update_photo
|
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 exist
content = Content.find_by_key(content_tag) || Content.create({ key: content_tag, tag: 'appearance' })
photo = ContentPhoto.create
if content_tag == "logo"
# TODO: This is a workaround
# need to have a way of determining content that should only have
# one photo and enforcing that
content.content_photos.destroy_all
end
content.content_photos.push photo
end
# TODO: - handle where no photo or content_tag..
end
if params[:file]
photo.image = params[:file]
end
photo.save!
photo.reload
render json: photo.to_json
end
|
ruby
|
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 exist
content = Content.find_by_key(content_tag) || Content.create({ key: content_tag, tag: 'appearance' })
photo = ContentPhoto.create
if content_tag == "logo"
# TODO: This is a workaround
# need to have a way of determining content that should only have
# one photo and enforcing that
content.content_photos.destroy_all
end
content.content_photos.push photo
end
# TODO: - handle where no photo or content_tag..
end
if params[:file]
photo.image = params[:file]
end
photo.save!
photo.reload
render json: photo.to_json
end
|
[
"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 exist",
"content",
"=",
"Content",
".",
"find_by_key",
"(",
"content_tag",
")",
"||",
"Content",
".",
"create",
"(",
"{",
"key",
":",
"content_tag",
",",
"tag",
":",
"'appearance'",
"}",
")",
"photo",
"=",
"ContentPhoto",
".",
"create",
"if",
"content_tag",
"==",
"\"logo\"",
"# TODO: This is a workaround",
"# need to have a way of determining content that should only have",
"# one photo and enforcing that",
"content",
".",
"content_photos",
".",
"destroy_all",
"end",
"content",
".",
"content_photos",
".",
"push",
"photo",
"end",
"# TODO: - handle where no photo or content_tag..",
"end",
"if",
"params",
"[",
":file",
"]",
"photo",
".",
"image",
"=",
"params",
"[",
":file",
"]",
"end",
"photo",
".",
"save!",
"photo",
".",
"reload",
"render",
"json",
":",
"photo",
".",
"to_json",
"end"
] |
below is used by logo_photo and about_us_photo,
where only one photo is allowed
|
[
"below",
"is",
"used",
"by",
"logo_photo",
"and",
"about_us_photo",
"where",
"only",
"one",
"photo",
"is",
"allowed"
] |
fba4e6d4ffa7bc1f4d3b50dfa5a6a9fbfee23f21
|
https://github.com/etewiah/property_web_builder/blob/fba4e6d4ffa7bc1f4d3b50dfa5a6a9fbfee23f21/app/controllers/pwb/api/v1/web_contents_controller.rb#L9-L35
|
12,736
|
etewiah/property_web_builder
|
app/controllers/pwb/api/v1/web_contents_controller.rb
|
Pwb.Api::V1::WebContentsController.create_content_with_photo
|
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.tenant_id = current_tenant_model.id
if params[:file]
photo.image = params[:file]
end
photo.save!
new_content.content_photos.push photo
# http://typeoneerror.com/labs/jsonapi-resources-ember-data/
# resource for model
resource = Api::V1::WebContentResource.new(new_content, nil)
# serializer for resource
serializer = JSONAPI::ResourceSerializer.new(Api::V1::WebContentResource)
# jsonapi-compliant hash (ready to be send to render)
photo.reload
# above needed to ensure image_url is available
# might need below if upload in prod is slow..
# upload_confirmed = false
# tries = 0
# until upload_confirmed
# if photo.image_url.present?
# upload_confirmed = true
# else
# sleep 1
# photo.reload
# tries += 1
# if tries > 5
# upload_confirmed = true
# end
# end
# end
render json: serializer.serialize_to_hash(resource)
# return render json: new_content.to_json
# return render :json => { :error => "Sorry...", :status => "444", :data => "ssss" }, :status => 422
end
|
ruby
|
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.tenant_id = current_tenant_model.id
if params[:file]
photo.image = params[:file]
end
photo.save!
new_content.content_photos.push photo
# http://typeoneerror.com/labs/jsonapi-resources-ember-data/
# resource for model
resource = Api::V1::WebContentResource.new(new_content, nil)
# serializer for resource
serializer = JSONAPI::ResourceSerializer.new(Api::V1::WebContentResource)
# jsonapi-compliant hash (ready to be send to render)
photo.reload
# above needed to ensure image_url is available
# might need below if upload in prod is slow..
# upload_confirmed = false
# tries = 0
# until upload_confirmed
# if photo.image_url.present?
# upload_confirmed = true
# else
# sleep 1
# photo.reload
# tries += 1
# if tries > 5
# upload_confirmed = true
# end
# end
# end
render json: serializer.serialize_to_hash(resource)
# return render json: new_content.to_json
# return render :json => { :error => "Sorry...", :status => "444", :data => "ssss" }, :status => 422
end
|
[
"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.tenant_id = current_tenant_model.id",
"if",
"params",
"[",
":file",
"]",
"photo",
".",
"image",
"=",
"params",
"[",
":file",
"]",
"end",
"photo",
".",
"save!",
"new_content",
".",
"content_photos",
".",
"push",
"photo",
"# http://typeoneerror.com/labs/jsonapi-resources-ember-data/",
"# resource for model",
"resource",
"=",
"Api",
"::",
"V1",
"::",
"WebContentResource",
".",
"new",
"(",
"new_content",
",",
"nil",
")",
"# serializer for resource",
"serializer",
"=",
"JSONAPI",
"::",
"ResourceSerializer",
".",
"new",
"(",
"Api",
"::",
"V1",
"::",
"WebContentResource",
")",
"# jsonapi-compliant hash (ready to be send to render)",
"photo",
".",
"reload",
"# above needed to ensure image_url is available",
"# might need below if upload in prod is slow..",
"# upload_confirmed = false",
"# tries = 0",
"# until upload_confirmed",
"# if photo.image_url.present?",
"# upload_confirmed = true",
"# else",
"# sleep 1",
"# photo.reload",
"# tries += 1",
"# if tries > 5",
"# upload_confirmed = true",
"# end",
"# end",
"# end",
"render",
"json",
":",
"serializer",
".",
"serialize_to_hash",
"(",
"resource",
")",
"# return render json: new_content.to_json",
"# return render :json => { :error => \"Sorry...\", :status => \"444\", :data => \"ssss\" }, :status => 422",
"end"
] |
below used when uploading carousel images
|
[
"below",
"used",
"when",
"uploading",
"carousel",
"images"
] |
fba4e6d4ffa7bc1f4d3b50dfa5a6a9fbfee23f21
|
https://github.com/etewiah/property_web_builder/blob/fba4e6d4ffa7bc1f4d3b50dfa5a6a9fbfee23f21/app/controllers/pwb/api/v1/web_contents_controller.rb#L38-L85
|
12,737
|
etewiah/property_web_builder
|
app/services/pwb/page_part_manager.rb
|
Pwb.PagePartManager.seed_container_block_content
|
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 identifies a fragment
# page_part_key = page_part.page_part_key
# container for json to be attached to page details
locale_block_content_json = {"blocks" => {}}
# {"blocks"=>{"title_a"=>{"content"=>"about our agency"}, "content_a"=>{"content"=>""}}}
page_part_editor_setup["editorBlocks"].each do |configColBlocks|
configColBlocks.each do |configRowBlock|
row_block_label = configRowBlock["label"]
row_block_content = ""
# find the content for current block from within the seed content
if seed_content[row_block_label]
if configRowBlock["isImage"]
photo = seed_fragment_photo row_block_label, seed_content[row_block_label]
if photo.present? && photo.optimized_image_url.present?
# optimized_image_url is defined in content_photo and will
# return cloudinary url or filesystem url depending on settings
row_block_content = photo.optimized_image_url
else
row_block_content = "http://via.placeholder.com/350x250"
end
else
row_block_content = seed_content[row_block_label]
end
end
locale_block_content_json["blocks"][row_block_label] = {"content" => row_block_content}
end
end
# # save the block contents (in associated page_part model)
# updated_details = container.set_page_part_block_contents page_part_key, locale, locale_block_content_json
# # retrieve the contents saved above and use to rebuild html for that page_part
# # (and save it in associated page_content model)
# fragment_html = container.rebuild_page_content page_part_key, locale
update_page_part_content locale, locale_block_content_json
p " #{page_part_key} content set for #{locale}."
end
|
ruby
|
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 identifies a fragment
# page_part_key = page_part.page_part_key
# container for json to be attached to page details
locale_block_content_json = {"blocks" => {}}
# {"blocks"=>{"title_a"=>{"content"=>"about our agency"}, "content_a"=>{"content"=>""}}}
page_part_editor_setup["editorBlocks"].each do |configColBlocks|
configColBlocks.each do |configRowBlock|
row_block_label = configRowBlock["label"]
row_block_content = ""
# find the content for current block from within the seed content
if seed_content[row_block_label]
if configRowBlock["isImage"]
photo = seed_fragment_photo row_block_label, seed_content[row_block_label]
if photo.present? && photo.optimized_image_url.present?
# optimized_image_url is defined in content_photo and will
# return cloudinary url or filesystem url depending on settings
row_block_content = photo.optimized_image_url
else
row_block_content = "http://via.placeholder.com/350x250"
end
else
row_block_content = seed_content[row_block_label]
end
end
locale_block_content_json["blocks"][row_block_label] = {"content" => row_block_content}
end
end
# # save the block contents (in associated page_part model)
# updated_details = container.set_page_part_block_contents page_part_key, locale, locale_block_content_json
# # retrieve the contents saved above and use to rebuild html for that page_part
# # (and save it in associated page_content model)
# fragment_html = container.rebuild_page_content page_part_key, locale
update_page_part_content locale, locale_block_content_json
p " #{page_part_key} content set for #{locale}."
end
|
[
"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 identifies a fragment",
"# page_part_key = page_part.page_part_key",
"# container for json to be attached to page details",
"locale_block_content_json",
"=",
"{",
"\"blocks\"",
"=>",
"{",
"}",
"}",
"# {\"blocks\"=>{\"title_a\"=>{\"content\"=>\"about our agency\"}, \"content_a\"=>{\"content\"=>\"\"}}}",
"page_part_editor_setup",
"[",
"\"editorBlocks\"",
"]",
".",
"each",
"do",
"|",
"configColBlocks",
"|",
"configColBlocks",
".",
"each",
"do",
"|",
"configRowBlock",
"|",
"row_block_label",
"=",
"configRowBlock",
"[",
"\"label\"",
"]",
"row_block_content",
"=",
"\"\"",
"# find the content for current block from within the seed content",
"if",
"seed_content",
"[",
"row_block_label",
"]",
"if",
"configRowBlock",
"[",
"\"isImage\"",
"]",
"photo",
"=",
"seed_fragment_photo",
"row_block_label",
",",
"seed_content",
"[",
"row_block_label",
"]",
"if",
"photo",
".",
"present?",
"&&",
"photo",
".",
"optimized_image_url",
".",
"present?",
"# optimized_image_url is defined in content_photo and will",
"# return cloudinary url or filesystem url depending on settings",
"row_block_content",
"=",
"photo",
".",
"optimized_image_url",
"else",
"row_block_content",
"=",
"\"http://via.placeholder.com/350x250\"",
"end",
"else",
"row_block_content",
"=",
"seed_content",
"[",
"row_block_label",
"]",
"end",
"end",
"locale_block_content_json",
"[",
"\"blocks\"",
"]",
"[",
"row_block_label",
"]",
"=",
"{",
"\"content\"",
"=>",
"row_block_content",
"}",
"end",
"end",
"# # save the block contents (in associated page_part model)",
"# updated_details = container.set_page_part_block_contents page_part_key, locale, locale_block_content_json",
"# # retrieve the contents saved above and use to rebuild html for that page_part",
"# # (and save it in associated page_content model)",
"# fragment_html = container.rebuild_page_content page_part_key, locale",
"update_page_part_content",
"locale",
",",
"locale_block_content_json",
"p",
"\" #{page_part_key} content set for #{locale}.\"",
"end"
] |
seed_content is ...
|
[
"seed_content",
"is",
"..."
] |
fba4e6d4ffa7bc1f4d3b50dfa5a6a9fbfee23f21
|
https://github.com/etewiah/property_web_builder/blob/fba4e6d4ffa7bc1f4d3b50dfa5a6a9fbfee23f21/app/services/pwb/page_part_manager.rb#L56-L97
|
12,738
|
etewiah/property_web_builder
|
app/services/pwb/page_part_manager.rb
|
Pwb.PagePartManager.set_page_part_block_contents
|
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
# - retrieving what has just been saved will return it as JSON
fragment_details = page_part.block_contents[locale]
end
fragment_details
end
|
ruby
|
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
# - retrieving what has just been saved will return it as JSON
fragment_details = page_part.block_contents[locale]
end
fragment_details
end
|
[
"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",
"# - retrieving what has just been saved will return it as JSON",
"fragment_details",
"=",
"page_part",
".",
"block_contents",
"[",
"locale",
"]",
"end",
"fragment_details",
"end"
] |
set block contents
on page_part model
|
[
"set",
"block",
"contents",
"on",
"page_part",
"model"
] |
fba4e6d4ffa7bc1f4d3b50dfa5a6a9fbfee23f21
|
https://github.com/etewiah/property_web_builder/blob/fba4e6d4ffa7bc1f4d3b50dfa5a6a9fbfee23f21/app/services/pwb/page_part_manager.rb#L138-L149
|
12,739
|
etewiah/property_web_builder
|
app/services/pwb/page_part_manager.rb
|
Pwb.PagePartManager.rebuild_page_content
|
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)
new_fragment_html = l_template.render('page_part' => page_part.block_contents[locale]["blocks"] )
# p "#{page_part_key} content for #{self.slug} page parsed."
# save in content model associated with page
page_fragment_content = find_or_create_content
# container.contents.find_or_create_by(page_part_key: page_part_key)
content_html_col = "raw_" + locale + "="
# above is the col used by globalize gem to store localized data
# page_fragment_content[content_html_col] = new_fragment_html
page_fragment_content.send content_html_col, new_fragment_html
page_fragment_content.save!
# set page_part_key value on join model
page_content_join_model = get_join_model
# page_fragment_content.page_contents.find_by_page_id self.id
page_content_join_model.page_part_key = page_part_key
page_content_join_model.save!
else
new_fragment_html = ""
end
new_fragment_html
end
|
ruby
|
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)
new_fragment_html = l_template.render('page_part' => page_part.block_contents[locale]["blocks"] )
# p "#{page_part_key} content for #{self.slug} page parsed."
# save in content model associated with page
page_fragment_content = find_or_create_content
# container.contents.find_or_create_by(page_part_key: page_part_key)
content_html_col = "raw_" + locale + "="
# above is the col used by globalize gem to store localized data
# page_fragment_content[content_html_col] = new_fragment_html
page_fragment_content.send content_html_col, new_fragment_html
page_fragment_content.save!
# set page_part_key value on join model
page_content_join_model = get_join_model
# page_fragment_content.page_contents.find_by_page_id self.id
page_content_join_model.page_part_key = page_part_key
page_content_join_model.save!
else
new_fragment_html = ""
end
new_fragment_html
end
|
[
"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",
")",
"new_fragment_html",
"=",
"l_template",
".",
"render",
"(",
"'page_part'",
"=>",
"page_part",
".",
"block_contents",
"[",
"locale",
"]",
"[",
"\"blocks\"",
"]",
")",
"# p \"#{page_part_key} content for #{self.slug} page parsed.\"",
"# save in content model associated with page",
"page_fragment_content",
"=",
"find_or_create_content",
"# container.contents.find_or_create_by(page_part_key: page_part_key)",
"content_html_col",
"=",
"\"raw_\"",
"+",
"locale",
"+",
"\"=\"",
"# above is the col used by globalize gem to store localized data",
"# page_fragment_content[content_html_col] = new_fragment_html",
"page_fragment_content",
".",
"send",
"content_html_col",
",",
"new_fragment_html",
"page_fragment_content",
".",
"save!",
"# set page_part_key value on join model",
"page_content_join_model",
"=",
"get_join_model",
"# page_fragment_content.page_contents.find_by_page_id self.id",
"page_content_join_model",
".",
"page_part_key",
"=",
"page_part_key",
"page_content_join_model",
".",
"save!",
"else",
"new_fragment_html",
"=",
"\"\"",
"end",
"new_fragment_html",
"end"
] |
Will retrieve saved page_part blocks and use that along with template
to rebuild page_content html
|
[
"Will",
"retrieve",
"saved",
"page_part",
"blocks",
"and",
"use",
"that",
"along",
"with",
"template",
"to",
"rebuild",
"page_content",
"html"
] |
fba4e6d4ffa7bc1f4d3b50dfa5a6a9fbfee23f21
|
https://github.com/etewiah/property_web_builder/blob/fba4e6d4ffa7bc1f4d3b50dfa5a6a9fbfee23f21/app/services/pwb/page_part_manager.rb#L153-L183
|
12,740
|
etewiah/property_web_builder
|
app/services/pwb/page_part_manager.rb
|
Pwb.PagePartManager.seed_fragment_photo
|
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: page_part_key)
# join_model.save!
# page_fragment_content = contents.find_or_create_by(page_part_key: page_part_key)
page_fragment_content = find_or_create_content
photo = page_fragment_content.content_photos.find_by_block_key(block_label)
if photo.present?
return photo
else
photo = page_fragment_content.content_photos.create(block_key: block_label)
end
if ENV["RAILS_ENV"] == "test"
# don't create photos for tests
return nil
end
begin
# if photo_file.is_a?(String)
# photo.image = photo_file
photo.image = Pwb::Engine.root.join(photo_file).open
photo.save!
print "#{slug}--#{page_part_key} image created: #{photo.optimized_image_url}\n"
# reload the record to ensure that url is available
photo.reload
print "#{slug}--#{page_part_key} image created: #{photo.optimized_image_url}(after reload..)"
rescue Exception => e
# log exception to console
print e
end
photo
end
|
ruby
|
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: page_part_key)
# join_model.save!
# page_fragment_content = contents.find_or_create_by(page_part_key: page_part_key)
page_fragment_content = find_or_create_content
photo = page_fragment_content.content_photos.find_by_block_key(block_label)
if photo.present?
return photo
else
photo = page_fragment_content.content_photos.create(block_key: block_label)
end
if ENV["RAILS_ENV"] == "test"
# don't create photos for tests
return nil
end
begin
# if photo_file.is_a?(String)
# photo.image = photo_file
photo.image = Pwb::Engine.root.join(photo_file).open
photo.save!
print "#{slug}--#{page_part_key} image created: #{photo.optimized_image_url}\n"
# reload the record to ensure that url is available
photo.reload
print "#{slug}--#{page_part_key} image created: #{photo.optimized_image_url}(after reload..)"
rescue Exception => e
# log exception to console
print e
end
photo
end
|
[
"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: page_part_key)",
"# join_model.save!",
"# page_fragment_content = contents.find_or_create_by(page_part_key: page_part_key)",
"page_fragment_content",
"=",
"find_or_create_content",
"photo",
"=",
"page_fragment_content",
".",
"content_photos",
".",
"find_by_block_key",
"(",
"block_label",
")",
"if",
"photo",
".",
"present?",
"return",
"photo",
"else",
"photo",
"=",
"page_fragment_content",
".",
"content_photos",
".",
"create",
"(",
"block_key",
":",
"block_label",
")",
"end",
"if",
"ENV",
"[",
"\"RAILS_ENV\"",
"]",
"==",
"\"test\"",
"# don't create photos for tests",
"return",
"nil",
"end",
"begin",
"# if photo_file.is_a?(String)",
"# photo.image = photo_file",
"photo",
".",
"image",
"=",
"Pwb",
"::",
"Engine",
".",
"root",
".",
"join",
"(",
"photo_file",
")",
".",
"open",
"photo",
".",
"save!",
"print",
"\"#{slug}--#{page_part_key} image created: #{photo.optimized_image_url}\\n\"",
"# reload the record to ensure that url is available",
"photo",
".",
"reload",
"print",
"\"#{slug}--#{page_part_key} image created: #{photo.optimized_image_url}(after reload..)\"",
"rescue",
"Exception",
"=>",
"e",
"# log exception to console",
"print",
"e",
"end",
"photo",
"end"
] |
when seeding I only need to ensure that a photo exists for the fragment
so will return existing photo if it can be found
|
[
"when",
"seeding",
"I",
"only",
"need",
"to",
"ensure",
"that",
"a",
"photo",
"exists",
"for",
"the",
"fragment",
"so",
"will",
"return",
"existing",
"photo",
"if",
"it",
"can",
"be",
"found"
] |
fba4e6d4ffa7bc1f4d3b50dfa5a6a9fbfee23f21
|
https://github.com/etewiah/property_web_builder/blob/fba4e6d4ffa7bc1f4d3b50dfa5a6a9fbfee23f21/app/services/pwb/page_part_manager.rb#L187-L223
|
12,741
|
etewiah/property_web_builder
|
app/models/pwb/website.rb
|
Pwb.Website.get_element_class
|
def get_element_class(element_name)
style_details = style_variables_for_theme["vic"] || Pwb::PresetStyle.default_values
style_associations = style_details["associations"] || []
style_associations[element_name] || ""
end
|
ruby
|
def get_element_class(element_name)
style_details = style_variables_for_theme["vic"] || Pwb::PresetStyle.default_values
style_associations = style_details["associations"] || []
style_associations[element_name] || ""
end
|
[
"def",
"get_element_class",
"(",
"element_name",
")",
"style_details",
"=",
"style_variables_for_theme",
"[",
"\"vic\"",
"]",
"||",
"Pwb",
"::",
"PresetStyle",
".",
"default_values",
"style_associations",
"=",
"style_details",
"[",
"\"associations\"",
"]",
"||",
"[",
"]",
"style_associations",
"[",
"element_name",
"]",
"||",
"\"\"",
"end"
] |
spt 2017 - above 2 will be redundant once vic becomes default layout
below used when rendering to decide which class names
to use for which elements
|
[
"spt",
"2017",
"-",
"above",
"2",
"will",
"be",
"redundant",
"once",
"vic",
"becomes",
"default",
"layout",
"below",
"used",
"when",
"rendering",
"to",
"decide",
"which",
"class",
"names",
"to",
"use",
"for",
"which",
"elements"
] |
fba4e6d4ffa7bc1f4d3b50dfa5a6a9fbfee23f21
|
https://github.com/etewiah/property_web_builder/blob/fba4e6d4ffa7bc1f4d3b50dfa5a6a9fbfee23f21/app/models/pwb/website.rb#L152-L156
|
12,742
|
etewiah/property_web_builder
|
app/models/pwb/website.rb
|
Pwb.Website.style_settings_from_preset=
|
def style_settings_from_preset=(preset_style_name)
preset_style = Pwb::PresetStyle.where(name: preset_style_name).first
if preset_style
style_variables_for_theme["vic"] = preset_style.attributes.as_json
end
end
|
ruby
|
def style_settings_from_preset=(preset_style_name)
preset_style = Pwb::PresetStyle.where(name: preset_style_name).first
if preset_style
style_variables_for_theme["vic"] = preset_style.attributes.as_json
end
end
|
[
"def",
"style_settings_from_preset",
"=",
"(",
"preset_style_name",
")",
"preset_style",
"=",
"Pwb",
"::",
"PresetStyle",
".",
"where",
"(",
"name",
":",
"preset_style_name",
")",
".",
"first",
"if",
"preset_style",
"style_variables_for_theme",
"[",
"\"vic\"",
"]",
"=",
"preset_style",
".",
"attributes",
".",
"as_json",
"end",
"end"
] |
allow setting of styles to a preset config from admin UI
|
[
"allow",
"setting",
"of",
"styles",
"to",
"a",
"preset",
"config",
"from",
"admin",
"UI"
] |
fba4e6d4ffa7bc1f4d3b50dfa5a6a9fbfee23f21
|
https://github.com/etewiah/property_web_builder/blob/fba4e6d4ffa7bc1f4d3b50dfa5a6a9fbfee23f21/app/models/pwb/website.rb#L172-L177
|
12,743
|
piotrmurach/tty-prompt
|
lib/tty/prompt.rb
|
TTY.Prompt.invoke_question
|
def invoke_question(object, message, *args, &block)
options = Utils.extract_options!(args)
options[:messages] = self.class.messages
question = object.new(self, options)
question.(message, &block)
end
|
ruby
|
def invoke_question(object, message, *args, &block)
options = Utils.extract_options!(args)
options[:messages] = self.class.messages
question = object.new(self, options)
question.(message, &block)
end
|
[
"def",
"invoke_question",
"(",
"object",
",",
"message",
",",
"*",
"args",
",",
"&",
"block",
")",
"options",
"=",
"Utils",
".",
"extract_options!",
"(",
"args",
")",
"options",
"[",
":messages",
"]",
"=",
"self",
".",
"class",
".",
"messages",
"question",
"=",
"object",
".",
"new",
"(",
"self",
",",
"options",
")",
"question",
".",
"(",
"message",
",",
"block",
")",
"end"
] |
Initialize a Prompt
@param [Hash] options
@option options [IO] :input
the input stream
@option options [IO] :output
the output stream
@option options [Hash] :env
the environment variables
@option options [String] :prefix
the prompt prefix, by default empty
@option options [Boolean] :enable_color
enable color support, true by default
@option options [String] :active_color
the color used for selected option
@option options [String] :help_color
the color used for help text
@option options [String] :error_color
the color used for displaying error messages
@option options [Symbol] :interrupt
handling of Ctrl+C key out of :signal, :exit, :noop
@option options [Boolean] :track_history
disable line history tracking, true by default
@option options [Hash] :symbols
the symbols displayed in prompts such as :pointer, :cross
@api public
Invoke a question type of prompt
@example
prompt = TTY::Prompt.new
prompt.invoke_question(Question, "Your name? ")
@return [String]
@api public
|
[
"Initialize",
"a",
"Prompt"
] |
b1ff627afff98fa6477e5ef3ac4a718c52eff05a
|
https://github.com/piotrmurach/tty-prompt/blob/b1ff627afff98fa6477e5ef3ac4a718c52eff05a/lib/tty/prompt.rb#L164-L169
|
12,744
|
piotrmurach/tty-prompt
|
lib/tty/prompt.rb
|
TTY.Prompt.invoke_select
|
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[0].is_a?(Hash)
Utils.extract_options!(args)
else
args.flatten
end
list = object.new(self, options)
list.(question, choices, &block)
end
|
ruby
|
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[0].is_a?(Hash)
Utils.extract_options!(args)
else
args.flatten
end
list = object.new(self, options)
list.(question, choices, &block)
end
|
[
"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",
"[",
"0",
"]",
".",
"is_a?",
"(",
"Hash",
")",
"Utils",
".",
"extract_options!",
"(",
"args",
")",
"else",
"args",
".",
"flatten",
"end",
"list",
"=",
"object",
".",
"new",
"(",
"self",
",",
"options",
")",
"list",
".",
"(",
"question",
",",
"choices",
",",
"block",
")",
"end"
] |
Invoke a list type of prompt
@example
prompt = TTY::Prompt.new
editors = %w(emacs nano vim)
prompt.invoke_select(EnumList, "Select editor: ", editors)
@return [String]
@api public
|
[
"Invoke",
"a",
"list",
"type",
"of",
"prompt"
] |
b1ff627afff98fa6477e5ef3ac4a718c52eff05a
|
https://github.com/piotrmurach/tty-prompt/blob/b1ff627afff98fa6477e5ef3ac4a718c52eff05a/lib/tty/prompt.rb#L223-L239
|
12,745
|
piotrmurach/tty-prompt
|
lib/tty/prompt.rb
|
TTY.Prompt.yes?
|
def yes?(message, *args, &block)
defaults = { default: true }
options = Utils.extract_options!(args)
options.merge!(defaults.reject { |k, _| options.key?(k) })
question = ConfirmQuestion.new(self, options)
question.call(message, &block)
end
|
ruby
|
def yes?(message, *args, &block)
defaults = { default: true }
options = Utils.extract_options!(args)
options.merge!(defaults.reject { |k, _| options.key?(k) })
question = ConfirmQuestion.new(self, options)
question.call(message, &block)
end
|
[
"def",
"yes?",
"(",
"message",
",",
"*",
"args",
",",
"&",
"block",
")",
"defaults",
"=",
"{",
"default",
":",
"true",
"}",
"options",
"=",
"Utils",
".",
"extract_options!",
"(",
"args",
")",
"options",
".",
"merge!",
"(",
"defaults",
".",
"reject",
"{",
"|",
"k",
",",
"_",
"|",
"options",
".",
"key?",
"(",
"k",
")",
"}",
")",
"question",
"=",
"ConfirmQuestion",
".",
"new",
"(",
"self",
",",
"options",
")",
"question",
".",
"call",
"(",
"message",
",",
"block",
")",
"end"
] |
A shortcut method to ask the user positive question and return
true for 'yes' reply, false for 'no'.
@example
prompt = TTY::Prompt.new
prompt.yes?('Are you human?')
# => Are you human? (Y/n)
@return [Boolean]
@api public
|
[
"A",
"shortcut",
"method",
"to",
"ask",
"the",
"user",
"positive",
"question",
"and",
"return",
"true",
"for",
"yes",
"reply",
"false",
"for",
"no",
"."
] |
b1ff627afff98fa6477e5ef3ac4a718c52eff05a
|
https://github.com/piotrmurach/tty-prompt/blob/b1ff627afff98fa6477e5ef3ac4a718c52eff05a/lib/tty/prompt.rb#L329-L336
|
12,746
|
piotrmurach/tty-prompt
|
lib/tty/prompt.rb
|
TTY.Prompt.slider
|
def slider(question, *args, &block)
options = Utils.extract_options!(args)
slider = Slider.new(self, options)
slider.call(question, &block)
end
|
ruby
|
def slider(question, *args, &block)
options = Utils.extract_options!(args)
slider = Slider.new(self, options)
slider.call(question, &block)
end
|
[
"def",
"slider",
"(",
"question",
",",
"*",
"args",
",",
"&",
"block",
")",
"options",
"=",
"Utils",
".",
"extract_options!",
"(",
"args",
")",
"slider",
"=",
"Slider",
".",
"new",
"(",
"self",
",",
"options",
")",
"slider",
".",
"call",
"(",
"question",
",",
"block",
")",
"end"
] |
Ask a question with a range slider
@example
prompt = TTY::Prompt.new
prompt.slider('What size?', min: 32, max: 54, step: 2)
@param [String] question
the question to ask
@return [String]
@api public
|
[
"Ask",
"a",
"question",
"with",
"a",
"range",
"slider"
] |
b1ff627afff98fa6477e5ef3ac4a718c52eff05a
|
https://github.com/piotrmurach/tty-prompt/blob/b1ff627afff98fa6477e5ef3ac4a718c52eff05a/lib/tty/prompt.rb#L393-L397
|
12,747
|
piotrmurach/tty-prompt
|
lib/tty/prompt.rb
|
TTY.Prompt.say
|
def say(message = '', options = {})
message = message.to_s
return if message.empty?
statement = Statement.new(self, options)
statement.call(message)
end
|
ruby
|
def say(message = '', options = {})
message = message.to_s
return if message.empty?
statement = Statement.new(self, options)
statement.call(message)
end
|
[
"def",
"say",
"(",
"message",
"=",
"''",
",",
"options",
"=",
"{",
"}",
")",
"message",
"=",
"message",
".",
"to_s",
"return",
"if",
"message",
".",
"empty?",
"statement",
"=",
"Statement",
".",
"new",
"(",
"self",
",",
"options",
")",
"statement",
".",
"call",
"(",
"message",
")",
"end"
] |
Print statement out. If the supplied message ends with a space or
tab character, a new line will not be appended.
@example
say("Simple things.", color: :red)
@param [String] message
@return [String]
@api public
|
[
"Print",
"statement",
"out",
".",
"If",
"the",
"supplied",
"message",
"ends",
"with",
"a",
"space",
"or",
"tab",
"character",
"a",
"new",
"line",
"will",
"not",
"be",
"appended",
"."
] |
b1ff627afff98fa6477e5ef3ac4a718c52eff05a
|
https://github.com/piotrmurach/tty-prompt/blob/b1ff627afff98fa6477e5ef3ac4a718c52eff05a/lib/tty/prompt.rb#L410-L416
|
12,748
|
piotrmurach/tty-prompt
|
lib/tty/prompt.rb
|
TTY.Prompt.debug
|
def debug(*messages)
longest = messages.max_by(&:length).size
width = TTY::Screen.width - longest
print cursor.save
messages.each_with_index do |msg, i|
print cursor.move_to(width, i)
print cursor.clear_line_after
print msg
end
print cursor.restore
end
|
ruby
|
def debug(*messages)
longest = messages.max_by(&:length).size
width = TTY::Screen.width - longest
print cursor.save
messages.each_with_index do |msg, i|
print cursor.move_to(width, i)
print cursor.clear_line_after
print msg
end
print cursor.restore
end
|
[
"def",
"debug",
"(",
"*",
"messages",
")",
"longest",
"=",
"messages",
".",
"max_by",
"(",
":length",
")",
".",
"size",
"width",
"=",
"TTY",
"::",
"Screen",
".",
"width",
"-",
"longest",
"print",
"cursor",
".",
"save",
"messages",
".",
"each_with_index",
"do",
"|",
"msg",
",",
"i",
"|",
"print",
"cursor",
".",
"move_to",
"(",
"width",
",",
"i",
")",
"print",
"cursor",
".",
"clear_line_after",
"print",
"msg",
"end",
"print",
"cursor",
".",
"restore",
"end"
] |
Print debug information in terminal top right corner
@example
prompt.debug "info1", "info2"
@param [Array] messages
@retrun [nil]
@api public
|
[
"Print",
"debug",
"information",
"in",
"terminal",
"top",
"right",
"corner"
] |
b1ff627afff98fa6477e5ef3ac4a718c52eff05a
|
https://github.com/piotrmurach/tty-prompt/blob/b1ff627afff98fa6477e5ef3ac4a718c52eff05a/lib/tty/prompt.rb#L476-L486
|
12,749
|
piotrmurach/tty-prompt
|
lib/tty/prompt.rb
|
TTY.Prompt.suggest
|
def suggest(message, possibilities, options = {})
suggestion = Suggestion.new(options)
say(suggestion.suggest(message, possibilities))
end
|
ruby
|
def suggest(message, possibilities, options = {})
suggestion = Suggestion.new(options)
say(suggestion.suggest(message, possibilities))
end
|
[
"def",
"suggest",
"(",
"message",
",",
"possibilities",
",",
"options",
"=",
"{",
"}",
")",
"suggestion",
"=",
"Suggestion",
".",
"new",
"(",
"options",
")",
"say",
"(",
"suggestion",
".",
"suggest",
"(",
"message",
",",
"possibilities",
")",
")",
"end"
] |
Takes the string provided by the user and compare it with other possible
matches to suggest an unambigous string
@example
prompt.suggest('sta', ['status', 'stage', 'commit', 'branch'])
# => "status, stage"
@param [String] message
@param [Array] possibilities
@param [Hash] options
@option options [String] :indent
The number of spaces for indentation
@option options [String] :single_text
The text for a single suggestion
@option options [String] :plural_text
The text for multiple suggestions
@return [String]
@api public
|
[
"Takes",
"the",
"string",
"provided",
"by",
"the",
"user",
"and",
"compare",
"it",
"with",
"other",
"possible",
"matches",
"to",
"suggest",
"an",
"unambigous",
"string"
] |
b1ff627afff98fa6477e5ef3ac4a718c52eff05a
|
https://github.com/piotrmurach/tty-prompt/blob/b1ff627afff98fa6477e5ef3ac4a718c52eff05a/lib/tty/prompt.rb#L510-L513
|
12,750
|
piotrmurach/tty-prompt
|
lib/tty/prompt.rb
|
TTY.Prompt.collect
|
def collect(options = {}, &block)
collector = AnswersCollector.new(self, options)
collector.call(&block)
end
|
ruby
|
def collect(options = {}, &block)
collector = AnswersCollector.new(self, options)
collector.call(&block)
end
|
[
"def",
"collect",
"(",
"options",
"=",
"{",
"}",
",",
"&",
"block",
")",
"collector",
"=",
"AnswersCollector",
".",
"new",
"(",
"self",
",",
"options",
")",
"collector",
".",
"call",
"(",
"block",
")",
"end"
] |
Gathers more than one aswer
@example
prompt.collect do
key(:name).ask('Name?')
end
@return [Hash]
the collection of answers
@api public
|
[
"Gathers",
"more",
"than",
"one",
"aswer"
] |
b1ff627afff98fa6477e5ef3ac4a718c52eff05a
|
https://github.com/piotrmurach/tty-prompt/blob/b1ff627afff98fa6477e5ef3ac4a718c52eff05a/lib/tty/prompt.rb#L526-L529
|
12,751
|
piotrmurach/tty-prompt
|
lib/tty/prompt/utils.rb
|
TTY.Utils.extract_options
|
def extract_options(args)
options = args.last
options.respond_to?(:to_hash) ? options.to_hash.dup : {}
end
|
ruby
|
def extract_options(args)
options = args.last
options.respond_to?(:to_hash) ? options.to_hash.dup : {}
end
|
[
"def",
"extract_options",
"(",
"args",
")",
"options",
"=",
"args",
".",
"last",
"options",
".",
"respond_to?",
"(",
":to_hash",
")",
"?",
"options",
".",
"to_hash",
".",
"dup",
":",
"{",
"}",
"end"
] |
Extract options hash from array argument
@param [Array[Object]] args
@api public
|
[
"Extract",
"options",
"hash",
"from",
"array",
"argument"
] |
b1ff627afff98fa6477e5ef3ac4a718c52eff05a
|
https://github.com/piotrmurach/tty-prompt/blob/b1ff627afff98fa6477e5ef3ac4a718c52eff05a/lib/tty/prompt/utils.rb#L14-L17
|
12,752
|
piotrmurach/tty-prompt
|
lib/tty/prompt/utils.rb
|
TTY.Utils.blank?
|
def blank?(value)
value.nil? ||
value.respond_to?(:empty?) && value.empty? ||
BLANK_REGEX === value
end
|
ruby
|
def blank?(value)
value.nil? ||
value.respond_to?(:empty?) && value.empty? ||
BLANK_REGEX === value
end
|
[
"def",
"blank?",
"(",
"value",
")",
"value",
".",
"nil?",
"||",
"value",
".",
"respond_to?",
"(",
":empty?",
")",
"&&",
"value",
".",
"empty?",
"||",
"BLANK_REGEX",
"===",
"value",
"end"
] |
Check if value is nil or an empty string
@param [Object] value
the value to check
@return [Boolean]
@api public
|
[
"Check",
"if",
"value",
"is",
"nil",
"or",
"an",
"empty",
"string"
] |
b1ff627afff98fa6477e5ef3ac4a718c52eff05a
|
https://github.com/piotrmurach/tty-prompt/blob/b1ff627afff98fa6477e5ef3ac4a718c52eff05a/lib/tty/prompt/utils.rb#L31-L35
|
12,753
|
rails/spring
|
lib/spring/application.rb
|
Spring.Application.shush_backtraces
|
def shush_backtraces
Kernel.module_eval do
old_raise = Kernel.method(:raise)
remove_method :raise
define_method :raise do |*args|
begin
old_raise.call(*args)
ensure
if $!
lib = File.expand_path("..", __FILE__)
$!.backtrace.reject! { |line| line.start_with?(lib) }
end
end
end
private :raise
end
end
|
ruby
|
def shush_backtraces
Kernel.module_eval do
old_raise = Kernel.method(:raise)
remove_method :raise
define_method :raise do |*args|
begin
old_raise.call(*args)
ensure
if $!
lib = File.expand_path("..", __FILE__)
$!.backtrace.reject! { |line| line.start_with?(lib) }
end
end
end
private :raise
end
end
|
[
"def",
"shush_backtraces",
"Kernel",
".",
"module_eval",
"do",
"old_raise",
"=",
"Kernel",
".",
"method",
"(",
":raise",
")",
"remove_method",
":raise",
"define_method",
":raise",
"do",
"|",
"*",
"args",
"|",
"begin",
"old_raise",
".",
"call",
"(",
"args",
")",
"ensure",
"if",
"$!",
"lib",
"=",
"File",
".",
"expand_path",
"(",
"\"..\"",
",",
"__FILE__",
")",
"$!",
".",
"backtrace",
".",
"reject!",
"{",
"|",
"line",
"|",
"line",
".",
"start_with?",
"(",
"lib",
")",
"}",
"end",
"end",
"end",
"private",
":raise",
"end",
"end"
] |
This feels very naughty
|
[
"This",
"feels",
"very",
"naughty"
] |
e7a36afa436fcc59b6945f68dbc08f1076e65585
|
https://github.com/rails/spring/blob/e7a36afa436fcc59b6945f68dbc08f1076e65585/lib/spring/application.rb#L291-L307
|
12,754
|
rails/spring
|
lib/spring/json.rb
|
Spring.OkJson.decode
|
def decode(s)
ts = lex(s)
v, ts = textparse(ts)
if ts.length > 0
raise Error, 'trailing garbage'
end
v
end
|
ruby
|
def decode(s)
ts = lex(s)
v, ts = textparse(ts)
if ts.length > 0
raise Error, 'trailing garbage'
end
v
end
|
[
"def",
"decode",
"(",
"s",
")",
"ts",
"=",
"lex",
"(",
"s",
")",
"v",
",",
"ts",
"=",
"textparse",
"(",
"ts",
")",
"if",
"ts",
".",
"length",
">",
"0",
"raise",
"Error",
",",
"'trailing garbage'",
"end",
"v",
"end"
] |
Decodes a json document in string s and
returns the corresponding ruby value.
String s must be valid UTF-8. If you have
a string in some other encoding, convert
it first.
String values in the resulting structure
will be UTF-8.
|
[
"Decodes",
"a",
"json",
"document",
"in",
"string",
"s",
"and",
"returns",
"the",
"corresponding",
"ruby",
"value",
".",
"String",
"s",
"must",
"be",
"valid",
"UTF",
"-",
"8",
".",
"If",
"you",
"have",
"a",
"string",
"in",
"some",
"other",
"encoding",
"convert",
"it",
"first",
"."
] |
e7a36afa436fcc59b6945f68dbc08f1076e65585
|
https://github.com/rails/spring/blob/e7a36afa436fcc59b6945f68dbc08f1076e65585/lib/spring/json.rb#L68-L75
|
12,755
|
rails/spring
|
lib/spring/json.rb
|
Spring.OkJson.objparse
|
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
ts = eat(',', ts)
k, v, ts = pairparse(ts)
obj[k] = v
if ts[0][0] == '}'
return obj, ts[1..-1]
end
end
end
|
ruby
|
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
ts = eat(',', ts)
k, v, ts = pairparse(ts)
obj[k] = v
if ts[0][0] == '}'
return obj, ts[1..-1]
end
end
end
|
[
"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",
"ts",
"=",
"eat",
"(",
"','",
",",
"ts",
")",
"k",
",",
"v",
",",
"ts",
"=",
"pairparse",
"(",
"ts",
")",
"obj",
"[",
"k",
"]",
"=",
"v",
"if",
"ts",
"[",
"0",
"]",
"[",
"0",
"]",
"==",
"'}'",
"return",
"obj",
",",
"ts",
"[",
"1",
"..",
"-",
"1",
"]",
"end",
"end",
"end"
] |
Parses an "object" in the sense of RFC 4627.
Returns the parsed value and any trailing tokens.
|
[
"Parses",
"an",
"object",
"in",
"the",
"sense",
"of",
"RFC",
"4627",
".",
"Returns",
"the",
"parsed",
"value",
"and",
"any",
"trailing",
"tokens",
"."
] |
e7a36afa436fcc59b6945f68dbc08f1076e65585
|
https://github.com/rails/spring/blob/e7a36afa436fcc59b6945f68dbc08f1076e65585/lib/spring/json.rb#L154-L179
|
12,756
|
rails/spring
|
lib/spring/json.rb
|
Spring.OkJson.pairparse
|
def pairparse(ts)
(typ, _, k), ts = ts[0], ts[1..-1]
if typ != :str
raise Error, "unexpected #{k.inspect}"
end
ts = eat(':', ts)
v, ts = valparse(ts)
[k, v, ts]
end
|
ruby
|
def pairparse(ts)
(typ, _, k), ts = ts[0], ts[1..-1]
if typ != :str
raise Error, "unexpected #{k.inspect}"
end
ts = eat(':', ts)
v, ts = valparse(ts)
[k, v, ts]
end
|
[
"def",
"pairparse",
"(",
"ts",
")",
"(",
"typ",
",",
"_",
",",
"k",
")",
",",
"ts",
"=",
"ts",
"[",
"0",
"]",
",",
"ts",
"[",
"1",
"..",
"-",
"1",
"]",
"if",
"typ",
"!=",
":str",
"raise",
"Error",
",",
"\"unexpected #{k.inspect}\"",
"end",
"ts",
"=",
"eat",
"(",
"':'",
",",
"ts",
")",
"v",
",",
"ts",
"=",
"valparse",
"(",
"ts",
")",
"[",
"k",
",",
"v",
",",
"ts",
"]",
"end"
] |
Parses a "member" in the sense of RFC 4627.
Returns the parsed values and any trailing tokens.
|
[
"Parses",
"a",
"member",
"in",
"the",
"sense",
"of",
"RFC",
"4627",
".",
"Returns",
"the",
"parsed",
"values",
"and",
"any",
"trailing",
"tokens",
"."
] |
e7a36afa436fcc59b6945f68dbc08f1076e65585
|
https://github.com/rails/spring/blob/e7a36afa436fcc59b6945f68dbc08f1076e65585/lib/spring/json.rb#L184-L192
|
12,757
|
rails/spring
|
lib/spring/json.rb
|
Spring.OkJson.arrparse
|
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
ts = eat(',', ts)
v, ts = valparse(ts)
arr << v
if ts[0][0] == ']'
return arr, ts[1..-1]
end
end
end
|
ruby
|
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
ts = eat(',', ts)
v, ts = valparse(ts)
arr << v
if ts[0][0] == ']'
return arr, ts[1..-1]
end
end
end
|
[
"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",
"ts",
"=",
"eat",
"(",
"','",
",",
"ts",
")",
"v",
",",
"ts",
"=",
"valparse",
"(",
"ts",
")",
"arr",
"<<",
"v",
"if",
"ts",
"[",
"0",
"]",
"[",
"0",
"]",
"==",
"']'",
"return",
"arr",
",",
"ts",
"[",
"1",
"..",
"-",
"1",
"]",
"end",
"end",
"end"
] |
Parses an "array" in the sense of RFC 4627.
Returns the parsed value and any trailing tokens.
|
[
"Parses",
"an",
"array",
"in",
"the",
"sense",
"of",
"RFC",
"4627",
".",
"Returns",
"the",
"parsed",
"value",
"and",
"any",
"trailing",
"tokens",
"."
] |
e7a36afa436fcc59b6945f68dbc08f1076e65585
|
https://github.com/rails/spring/blob/e7a36afa436fcc59b6945f68dbc08f1076e65585/lib/spring/json.rb#L197-L222
|
12,758
|
rails/spring
|
lib/spring/json.rb
|
Spring.OkJson.tok
|
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)
when ?f then falsetok(s)
when ?" then strtok(s)
when Spc, ?\t, ?\n, ?\r then [:space, s[0,1], s[0,1]]
else
numtok(s)
end
end
|
ruby
|
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)
when ?f then falsetok(s)
when ?" then strtok(s)
when Spc, ?\t, ?\n, ?\r then [:space, s[0,1], s[0,1]]
else
numtok(s)
end
end
|
[
"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",
")",
"when",
"?f",
"then",
"falsetok",
"(",
"s",
")",
"when",
"?\"",
"then",
"strtok",
"(",
"s",
")",
"when",
"Spc",
",",
"?\\t",
",",
"?\\n",
",",
"?\\r",
"then",
"[",
":space",
",",
"s",
"[",
"0",
",",
"1",
"]",
",",
"s",
"[",
"0",
",",
"1",
"]",
"]",
"else",
"numtok",
"(",
"s",
")",
"end",
"end"
] |
Scans the first token in s and
returns a 3-element list, or nil
if s does not begin with a valid token.
The first list element is one of
'{', '}', ':', ',', '[', ']',
:val, :str, and :space.
The second element is the lexeme.
The third element is the value of the
token for :val and :str, otherwise
it is the lexeme.
|
[
"Scans",
"the",
"first",
"token",
"in",
"s",
"and",
"returns",
"a",
"3",
"-",
"element",
"list",
"or",
"nil",
"if",
"s",
"does",
"not",
"begin",
"with",
"a",
"valid",
"token",
"."
] |
e7a36afa436fcc59b6945f68dbc08f1076e65585
|
https://github.com/rails/spring/blob/e7a36afa436fcc59b6945f68dbc08f1076e65585/lib/spring/json.rb#L264-L280
|
12,759
|
rails/spring
|
lib/spring/json.rb
|
Spring.OkJson.unquote
|
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 Error, "string literal ends with a \"\\\": \"#{q}\""
end
case q[r]
when ?",?\\,?/,?'
a[w] = q[r]
r += 1
w += 1
when ?b,?f,?n,?r,?t
a[w] = Unesc[q[r]]
r += 1
w += 1
when ?u
r += 1
uchar = begin
hexdec4(q[r,4])
rescue RuntimeError => e
raise Error, "invalid escape sequence \\u#{q[r,4]}: #{e}"
end
r += 4
if surrogate? uchar
if q.length >= r+6
uchar1 = hexdec4(q[r+2,4])
uchar = subst(uchar, uchar1)
if uchar != Ucharerr
# A valid pair; consume.
r += 6
end
end
end
if rubydoesenc?
a[w] = '' << uchar
w += 1
else
w += ucharenc(a, w, uchar)
end
else
raise Error, "invalid escape char #{q[r]} in \"#{q}\""
end
elsif c == ?" || c < Spc
raise Error, "invalid character in string literal \"#{q}\""
else
# Copy anything else byte-for-byte.
# Valid UTF-8 will remain valid UTF-8.
# Invalid UTF-8 will remain invalid UTF-8.
# In ruby >= 1.9, c is a codepoint, not a byte,
# in which case this is still what we want.
a[w] = c
r += 1
w += 1
end
end
a[0,w]
end
|
ruby
|
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 Error, "string literal ends with a \"\\\": \"#{q}\""
end
case q[r]
when ?",?\\,?/,?'
a[w] = q[r]
r += 1
w += 1
when ?b,?f,?n,?r,?t
a[w] = Unesc[q[r]]
r += 1
w += 1
when ?u
r += 1
uchar = begin
hexdec4(q[r,4])
rescue RuntimeError => e
raise Error, "invalid escape sequence \\u#{q[r,4]}: #{e}"
end
r += 4
if surrogate? uchar
if q.length >= r+6
uchar1 = hexdec4(q[r+2,4])
uchar = subst(uchar, uchar1)
if uchar != Ucharerr
# A valid pair; consume.
r += 6
end
end
end
if rubydoesenc?
a[w] = '' << uchar
w += 1
else
w += ucharenc(a, w, uchar)
end
else
raise Error, "invalid escape char #{q[r]} in \"#{q}\""
end
elsif c == ?" || c < Spc
raise Error, "invalid character in string literal \"#{q}\""
else
# Copy anything else byte-for-byte.
# Valid UTF-8 will remain valid UTF-8.
# Invalid UTF-8 will remain invalid UTF-8.
# In ruby >= 1.9, c is a codepoint, not a byte,
# in which case this is still what we want.
a[w] = c
r += 1
w += 1
end
end
a[0,w]
end
|
[
"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",
"Error",
",",
"\"string literal ends with a \\\"\\\\\\\": \\\"#{q}\\\"\"",
"end",
"case",
"q",
"[",
"r",
"]",
"when",
"?\"",
",",
"?\\\\",
",",
"?/",
",",
"?'",
"a",
"[",
"w",
"]",
"=",
"q",
"[",
"r",
"]",
"r",
"+=",
"1",
"w",
"+=",
"1",
"when",
"?b",
",",
"?f",
",",
"?n",
",",
"?r",
",",
"?t",
"a",
"[",
"w",
"]",
"=",
"Unesc",
"[",
"q",
"[",
"r",
"]",
"]",
"r",
"+=",
"1",
"w",
"+=",
"1",
"when",
"?u",
"r",
"+=",
"1",
"uchar",
"=",
"begin",
"hexdec4",
"(",
"q",
"[",
"r",
",",
"4",
"]",
")",
"rescue",
"RuntimeError",
"=>",
"e",
"raise",
"Error",
",",
"\"invalid escape sequence \\\\u#{q[r,4]}: #{e}\"",
"end",
"r",
"+=",
"4",
"if",
"surrogate?",
"uchar",
"if",
"q",
".",
"length",
">=",
"r",
"+",
"6",
"uchar1",
"=",
"hexdec4",
"(",
"q",
"[",
"r",
"+",
"2",
",",
"4",
"]",
")",
"uchar",
"=",
"subst",
"(",
"uchar",
",",
"uchar1",
")",
"if",
"uchar",
"!=",
"Ucharerr",
"# A valid pair; consume.",
"r",
"+=",
"6",
"end",
"end",
"end",
"if",
"rubydoesenc?",
"a",
"[",
"w",
"]",
"=",
"''",
"<<",
"uchar",
"w",
"+=",
"1",
"else",
"w",
"+=",
"ucharenc",
"(",
"a",
",",
"w",
",",
"uchar",
")",
"end",
"else",
"raise",
"Error",
",",
"\"invalid escape char #{q[r]} in \\\"#{q}\\\"\"",
"end",
"elsif",
"c",
"==",
"?\"",
"||",
"c",
"<",
"Spc",
"raise",
"Error",
",",
"\"invalid character in string literal \\\"#{q}\\\"\"",
"else",
"# Copy anything else byte-for-byte.",
"# Valid UTF-8 will remain valid UTF-8.",
"# Invalid UTF-8 will remain invalid UTF-8.",
"# In ruby >= 1.9, c is a codepoint, not a byte,",
"# in which case this is still what we want.",
"a",
"[",
"w",
"]",
"=",
"c",
"r",
"+=",
"1",
"w",
"+=",
"1",
"end",
"end",
"a",
"[",
"0",
",",
"w",
"]",
"end"
] |
Converts a quoted json string literal q into a UTF-8-encoded string.
The rules are different than for Ruby, so we cannot use eval.
Unquote will raise an error if q contains control characters.
|
[
"Converts",
"a",
"quoted",
"json",
"string",
"literal",
"q",
"into",
"a",
"UTF",
"-",
"8",
"-",
"encoded",
"string",
".",
"The",
"rules",
"are",
"different",
"than",
"for",
"Ruby",
"so",
"we",
"cannot",
"use",
"eval",
".",
"Unquote",
"will",
"raise",
"an",
"error",
"if",
"q",
"contains",
"control",
"characters",
"."
] |
e7a36afa436fcc59b6945f68dbc08f1076e65585
|
https://github.com/rails/spring/blob/e7a36afa436fcc59b6945f68dbc08f1076e65585/lib/spring/json.rb#L325-L391
|
12,760
|
rails/spring
|
lib/spring/json.rb
|
Spring.OkJson.ucharenc
|
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+2] = (Utagx | (u&Umaskx)).chr
3
else
a[i+0] = (Utag4 | ((u>>18)&0xff)).chr
a[i+1] = (Utagx | ((u>>12)&Umaskx)).chr
a[i+2] = (Utagx | ((u>>6)&Umaskx)).chr
a[i+3] = (Utagx | (u&Umaskx)).chr
4
end
end
|
ruby
|
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+2] = (Utagx | (u&Umaskx)).chr
3
else
a[i+0] = (Utag4 | ((u>>18)&0xff)).chr
a[i+1] = (Utagx | ((u>>12)&Umaskx)).chr
a[i+2] = (Utagx | ((u>>6)&Umaskx)).chr
a[i+3] = (Utagx | (u&Umaskx)).chr
4
end
end
|
[
"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",
"+",
"2",
"]",
"=",
"(",
"Utagx",
"|",
"(",
"u",
"Umaskx",
")",
")",
".",
"chr",
"3",
"else",
"a",
"[",
"i",
"+",
"0",
"]",
"=",
"(",
"Utag4",
"|",
"(",
"(",
"u",
">>",
"18",
")",
"&",
"0xff",
")",
")",
".",
"chr",
"a",
"[",
"i",
"+",
"1",
"]",
"=",
"(",
"Utagx",
"|",
"(",
"(",
"u",
">>",
"12",
")",
"&",
"Umaskx",
")",
")",
".",
"chr",
"a",
"[",
"i",
"+",
"2",
"]",
"=",
"(",
"Utagx",
"|",
"(",
"(",
"u",
">>",
"6",
")",
"&",
"Umaskx",
")",
")",
".",
"chr",
"a",
"[",
"i",
"+",
"3",
"]",
"=",
"(",
"Utagx",
"|",
"(",
"u",
"Umaskx",
")",
")",
".",
"chr",
"4",
"end",
"end"
] |
Encodes unicode character u as UTF-8
bytes in string a at position i.
Returns the number of bytes written.
|
[
"Encodes",
"unicode",
"character",
"u",
"as",
"UTF",
"-",
"8",
"bytes",
"in",
"string",
"a",
"at",
"position",
"i",
".",
"Returns",
"the",
"number",
"of",
"bytes",
"written",
"."
] |
e7a36afa436fcc59b6945f68dbc08f1076e65585
|
https://github.com/rails/spring/blob/e7a36afa436fcc59b6945f68dbc08f1076e65585/lib/spring/json.rb#L397-L417
|
12,761
|
rails/spring
|
lib/spring/application_manager.rb
|
Spring.ApplicationManager.run
|
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, Errno::EPIPE => e
log "#{e} while reading from child; returning no pid"
nil
ensure
client.close
end
|
ruby
|
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, Errno::EPIPE => e
log "#{e} while reading from child; returning no pid"
nil
ensure
client.close
end
|
[
"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",
",",
"Errno",
"::",
"EPIPE",
"=>",
"e",
"log",
"\"#{e} while reading from child; returning no pid\"",
"nil",
"ensure",
"client",
".",
"close",
"end"
] |
Returns the pid of the process running the command, or nil if the application process died.
|
[
"Returns",
"the",
"pid",
"of",
"the",
"process",
"running",
"the",
"command",
"or",
"nil",
"if",
"the",
"application",
"process",
"died",
"."
] |
e7a36afa436fcc59b6945f68dbc08f1076e65585
|
https://github.com/rails/spring/blob/e7a36afa436fcc59b6945f68dbc08f1076e65585/lib/spring/application_manager.rb#L59-L76
|
12,762
|
arsduo/koala
|
lib/koala/utils.rb
|
Koala.Utils.symbolize_hash
|
def symbolize_hash(hash)
return hash unless hash.is_a?(Hash)
hash.inject({}){ |memo,(key,value)| memo[key.to_sym] = symbolize_hash(value); memo }
end
|
ruby
|
def symbolize_hash(hash)
return hash unless hash.is_a?(Hash)
hash.inject({}){ |memo,(key,value)| memo[key.to_sym] = symbolize_hash(value); memo }
end
|
[
"def",
"symbolize_hash",
"(",
"hash",
")",
"return",
"hash",
"unless",
"hash",
".",
"is_a?",
"(",
"Hash",
")",
"hash",
".",
"inject",
"(",
"{",
"}",
")",
"{",
"|",
"memo",
",",
"(",
"key",
",",
"value",
")",
"|",
"memo",
"[",
"key",
".",
"to_sym",
"]",
"=",
"symbolize_hash",
"(",
"value",
")",
";",
"memo",
"}",
"end"
] |
Ensures that a hash uses symbols as opposed to strings
Useful for allowing either syntax for end users
|
[
"Ensures",
"that",
"a",
"hash",
"uses",
"symbols",
"as",
"opposed",
"to",
"strings",
"Useful",
"for",
"allowing",
"either",
"syntax",
"for",
"end",
"users"
] |
3c7037eea67062f05eccb16836bebec403ddbfec
|
https://github.com/arsduo/koala/blob/3c7037eea67062f05eccb16836bebec403ddbfec/lib/koala/utils.rb#L35-L39
|
12,763
|
chaps-io/public_activity
|
lib/public_activity/utility/view_helpers.rb
|
PublicActivity.ViewHelpers.single_content_for
|
def single_content_for(name, content = nil, &block)
@view_flow.set(name, ActiveSupport::SafeBuffer.new)
content_for(name, content, &block)
end
|
ruby
|
def single_content_for(name, content = nil, &block)
@view_flow.set(name, ActiveSupport::SafeBuffer.new)
content_for(name, content, &block)
end
|
[
"def",
"single_content_for",
"(",
"name",
",",
"content",
"=",
"nil",
",",
"&",
"block",
")",
"@view_flow",
".",
"set",
"(",
"name",
",",
"ActiveSupport",
"::",
"SafeBuffer",
".",
"new",
")",
"content_for",
"(",
"name",
",",
"content",
",",
"block",
")",
"end"
] |
Helper for setting content_for in activity partial, needed to
flush remains in between partial renders.
|
[
"Helper",
"for",
"setting",
"content_for",
"in",
"activity",
"partial",
"needed",
"to",
"flush",
"remains",
"in",
"between",
"partial",
"renders",
"."
] |
e4357cd14db67299e0cbbd656300f51b7069ea9b
|
https://github.com/chaps-io/public_activity/blob/e4357cd14db67299e0cbbd656300f51b7069ea9b/lib/public_activity/utility/view_helpers.rb#L21-L24
|
12,764
|
chaps-io/public_activity
|
lib/public_activity/common.rb
|
PublicActivity.Common.create_activity!
|
def create_activity!(*args)
return unless self.public_activity_enabled?
options = prepare_settings(*args)
if call_hook_safe(options[:key].split('.').last)
reset_activity_instance_options
return PublicActivity::Adapter.create_activity!(self, options)
end
end
|
ruby
|
def create_activity!(*args)
return unless self.public_activity_enabled?
options = prepare_settings(*args)
if call_hook_safe(options[:key].split('.').last)
reset_activity_instance_options
return PublicActivity::Adapter.create_activity!(self, options)
end
end
|
[
"def",
"create_activity!",
"(",
"*",
"args",
")",
"return",
"unless",
"self",
".",
"public_activity_enabled?",
"options",
"=",
"prepare_settings",
"(",
"args",
")",
"if",
"call_hook_safe",
"(",
"options",
"[",
":key",
"]",
".",
"split",
"(",
"'.'",
")",
".",
"last",
")",
"reset_activity_instance_options",
"return",
"PublicActivity",
"::",
"Adapter",
".",
"create_activity!",
"(",
"self",
",",
"options",
")",
"end",
"end"
] |
Directly saves activity to database. Works the same as create_activity
but throws validation error for each supported ORM.
@see #create_activity
|
[
"Directly",
"saves",
"activity",
"to",
"database",
".",
"Works",
"the",
"same",
"as",
"create_activity",
"but",
"throws",
"validation",
"error",
"for",
"each",
"supported",
"ORM",
"."
] |
e4357cd14db67299e0cbbd656300f51b7069ea9b
|
https://github.com/chaps-io/public_activity/blob/e4357cd14db67299e0cbbd656300f51b7069ea9b/lib/public_activity/common.rb#L266-L274
|
12,765
|
chaps-io/public_activity
|
lib/public_activity/common.rb
|
PublicActivity.Common.prepare_custom_fields
|
def prepare_custom_fields(options)
customs = self.class.activity_custom_fields_global.clone
customs.merge!(self.activity_custom_fields) if self.activity_custom_fields
customs.merge!(options)
customs.each do |k, v|
customs[k] = PublicActivity.resolve_value(self, v)
end
end
|
ruby
|
def prepare_custom_fields(options)
customs = self.class.activity_custom_fields_global.clone
customs.merge!(self.activity_custom_fields) if self.activity_custom_fields
customs.merge!(options)
customs.each do |k, v|
customs[k] = PublicActivity.resolve_value(self, v)
end
end
|
[
"def",
"prepare_custom_fields",
"(",
"options",
")",
"customs",
"=",
"self",
".",
"class",
".",
"activity_custom_fields_global",
".",
"clone",
"customs",
".",
"merge!",
"(",
"self",
".",
"activity_custom_fields",
")",
"if",
"self",
".",
"activity_custom_fields",
"customs",
".",
"merge!",
"(",
"options",
")",
"customs",
".",
"each",
"do",
"|",
"k",
",",
"v",
"|",
"customs",
"[",
"k",
"]",
"=",
"PublicActivity",
".",
"resolve_value",
"(",
"self",
",",
"v",
")",
"end",
"end"
] |
Prepares and resolves custom fields
users can pass to `tracked` method
@private
|
[
"Prepares",
"and",
"resolves",
"custom",
"fields",
"users",
"can",
"pass",
"to",
"tracked",
"method"
] |
e4357cd14db67299e0cbbd656300f51b7069ea9b
|
https://github.com/chaps-io/public_activity/blob/e4357cd14db67299e0cbbd656300f51b7069ea9b/lib/public_activity/common.rb#L307-L314
|
12,766
|
chaps-io/public_activity
|
lib/public_activity/common.rb
|
PublicActivity.Common.prepare_key
|
def prepare_key(action, options = {})
(
options[:key] ||
self.activity_key ||
((self.class.name.underscore.gsub('/', '_') + "." + action.to_s) if action)
).try(:to_s)
end
|
ruby
|
def prepare_key(action, options = {})
(
options[:key] ||
self.activity_key ||
((self.class.name.underscore.gsub('/', '_') + "." + action.to_s) if action)
).try(:to_s)
end
|
[
"def",
"prepare_key",
"(",
"action",
",",
"options",
"=",
"{",
"}",
")",
"(",
"options",
"[",
":key",
"]",
"||",
"self",
".",
"activity_key",
"||",
"(",
"(",
"self",
".",
"class",
".",
"name",
".",
"underscore",
".",
"gsub",
"(",
"'/'",
",",
"'_'",
")",
"+",
"\".\"",
"+",
"action",
".",
"to_s",
")",
"if",
"action",
")",
")",
".",
"try",
"(",
":to_s",
")",
"end"
] |
Helper method to serialize class name into relevant key
@return [String] the resulted key
@param [Symbol] or [String] the name of the operation to be done on class
@param [Hash] options to be used on key generation, defaults to {}
|
[
"Helper",
"method",
"to",
"serialize",
"class",
"name",
"into",
"relevant",
"key"
] |
e4357cd14db67299e0cbbd656300f51b7069ea9b
|
https://github.com/chaps-io/public_activity/blob/e4357cd14db67299e0cbbd656300f51b7069ea9b/lib/public_activity/common.rb#L343-L349
|
12,767
|
chaps-io/public_activity
|
lib/public_activity/renderable.rb
|
PublicActivity.Renderable.text
|
def text(params = {})
# TODO: some helper for key transformation for two supported formats
k = key.split('.')
k.unshift('activity') if k.first != 'activity'
k = k.join('.')
I18n.t(k, parameters.merge(params) || {})
end
|
ruby
|
def text(params = {})
# TODO: some helper for key transformation for two supported formats
k = key.split('.')
k.unshift('activity') if k.first != 'activity'
k = k.join('.')
I18n.t(k, parameters.merge(params) || {})
end
|
[
"def",
"text",
"(",
"params",
"=",
"{",
"}",
")",
"# TODO: some helper for key transformation for two supported formats",
"k",
"=",
"key",
".",
"split",
"(",
"'.'",
")",
"k",
".",
"unshift",
"(",
"'activity'",
")",
"if",
"k",
".",
"first",
"!=",
"'activity'",
"k",
"=",
"k",
".",
"join",
"(",
"'.'",
")",
"I18n",
".",
"t",
"(",
"k",
",",
"parameters",
".",
"merge",
"(",
"params",
")",
"||",
"{",
"}",
")",
"end"
] |
Virtual attribute returning text description of the activity
using the activity's key to translate using i18n.
|
[
"Virtual",
"attribute",
"returning",
"text",
"description",
"of",
"the",
"activity",
"using",
"the",
"activity",
"s",
"key",
"to",
"translate",
"using",
"i18n",
"."
] |
e4357cd14db67299e0cbbd656300f51b7069ea9b
|
https://github.com/chaps-io/public_activity/blob/e4357cd14db67299e0cbbd656300f51b7069ea9b/lib/public_activity/renderable.rb#L9-L16
|
12,768
|
chaps-io/public_activity
|
lib/public_activity/renderable.rb
|
PublicActivity.Renderable.render
|
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)
return context.render :text => text, :plain => text
else
partial_path = File.join(partial_root, params[:display].to_s)
end
end
context.render(
params.merge({
:partial => prepare_partial(partial_root, partial_path),
:layout => prepare_layout(layout_root, params.delete(:layout)),
:locals => prepare_locals(params)
})
)
end
|
ruby
|
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)
return context.render :text => text, :plain => text
else
partial_path = File.join(partial_root, params[:display].to_s)
end
end
context.render(
params.merge({
:partial => prepare_partial(partial_root, partial_path),
:layout => prepare_layout(layout_root, params.delete(:layout)),
:locals => prepare_locals(params)
})
)
end
|
[
"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",
"==",
":\"",
"\"",
"text",
"=",
"self",
".",
"text",
"(",
"params",
")",
"return",
"context",
".",
"render",
":text",
"=>",
"text",
",",
":plain",
"=>",
"text",
"else",
"partial_path",
"=",
"File",
".",
"join",
"(",
"partial_root",
",",
"params",
"[",
":display",
"]",
".",
"to_s",
")",
"end",
"end",
"context",
".",
"render",
"(",
"params",
".",
"merge",
"(",
"{",
":partial",
"=>",
"prepare_partial",
"(",
"partial_root",
",",
"partial_path",
")",
",",
":layout",
"=>",
"prepare_layout",
"(",
"layout_root",
",",
"params",
".",
"delete",
"(",
":layout",
")",
")",
",",
":locals",
"=>",
"prepare_locals",
"(",
"params",
")",
"}",
")",
")",
"end"
] |
Renders activity from views.
@param [ActionView::Base] context
@return [nil] nil
Renders activity to the given ActionView context with included
AV::Helpers::RenderingHelper (most commonly just ActionView::Base)
The *preferred* *way* of rendering activities is
to provide a template specifying how the rendering should be happening.
However, one may choose using _I18n_ based approach when developing
an application that supports plenty of languages.
If partial view exists that matches the *key* attribute
renders that partial with local variables set to contain both
Activity and activity_parameters (hash with indifferent access)
Otherwise, it outputs the I18n translation to the context
@example Render a list of all activities from a view (erb)
<ul>
<% for activity in PublicActivity::Activity.all %>
<li><%= render_activity(activity) %></li>
<% end %>
</ul>
= Layouts
You can supply a layout that will be used for activity partials
with :layout param.
Keep in mind that layouts for partials are also partials.
@example Supply a layout
# in views:
# All examples look for a layout in app/views/layouts/_activity.erb
render_activity @activity, :layout => "activity"
render_activity @activity, :layout => "layouts/activity"
render_activity @activity, :layout => :activity
# app/views/layouts/_activity.erb
<p><%= a.created_at %></p>
<%= yield %>
== Custom Layout Location
You can customize the layout directory by supplying :layout_root
or by using an absolute path.
@example Declare custom layout location
# Both examples look for a layout in "app/views/custom/_layout.erb"
render_activity @activity, :layout_root => "custom"
render_activity @activity, :layout => "/custom/layout"
= Creating a template
To use templates for formatting how the activity should render,
create a template based on activity key, for example:
Given a key _activity.article.create_, create directory tree
_app/views/public_activity/article/_ and create the _create_ partial there
Note that if a key consists of more than three parts splitted by commas, your
directory structure will have to be deeper, for example:
activity.article.comments.destroy => app/views/public_activity/articles/comments/_destroy.html.erb
== Custom Directory
You can override the default `public_directory` template root with the :root parameter
@example Custom template root
# look for templates inside of /app/views/custom instead of /app/views/public_directory
render_activity @activity, :root => "custom"
== Variables in templates
From within a template there are two variables at your disposal:
* activity (aliased as *a* for a shortcut)
* params (aliased as *p*) [converted into a HashWithIndifferentAccess]
@example Template for key: _activity.article.create_ (erb)
<p>
Article <strong><%= p[:name] %></strong>
was written by <em><%= p["author"] %></em>
<%= distance_of_time_in_words_to_now(a.created_at) %>
</p>
|
[
"Renders",
"activity",
"from",
"views",
"."
] |
e4357cd14db67299e0cbbd656300f51b7069ea9b
|
https://github.com/chaps-io/public_activity/blob/e4357cd14db67299e0cbbd656300f51b7069ea9b/lib/public_activity/renderable.rb#L98-L119
|
12,769
|
chaps-io/public_activity
|
lib/public_activity/renderable.rb
|
PublicActivity.Renderable.template_path
|
def template_path(key, partial_root)
path = key.split(".")
path.delete_at(0) if path[0] == "activity"
path.unshift partial_root
path.join("/")
end
|
ruby
|
def template_path(key, partial_root)
path = key.split(".")
path.delete_at(0) if path[0] == "activity"
path.unshift partial_root
path.join("/")
end
|
[
"def",
"template_path",
"(",
"key",
",",
"partial_root",
")",
"path",
"=",
"key",
".",
"split",
"(",
"\".\"",
")",
"path",
".",
"delete_at",
"(",
"0",
")",
"if",
"path",
"[",
"0",
"]",
"==",
"\"activity\"",
"path",
".",
"unshift",
"partial_root",
"path",
".",
"join",
"(",
"\"/\"",
")",
"end"
] |
Builds the path to template based on activity key
|
[
"Builds",
"the",
"path",
"to",
"template",
"based",
"on",
"activity",
"key"
] |
e4357cd14db67299e0cbbd656300f51b7069ea9b
|
https://github.com/chaps-io/public_activity/blob/e4357cd14db67299e0cbbd656300f51b7069ea9b/lib/public_activity/renderable.rb#L159-L164
|
12,770
|
restforce/restforce
|
lib/restforce/collection.rb
|
Restforce.Collection.each
|
def each
@raw_page['records'].each { |record| yield Restforce::Mash.build(record, @client) }
np = next_page
while np
np.current_page.each { |record| yield record }
np = np.next_page
end
end
|
ruby
|
def each
@raw_page['records'].each { |record| yield Restforce::Mash.build(record, @client) }
np = next_page
while np
np.current_page.each { |record| yield record }
np = np.next_page
end
end
|
[
"def",
"each",
"@raw_page",
"[",
"'records'",
"]",
".",
"each",
"{",
"|",
"record",
"|",
"yield",
"Restforce",
"::",
"Mash",
".",
"build",
"(",
"record",
",",
"@client",
")",
"}",
"np",
"=",
"next_page",
"while",
"np",
"np",
".",
"current_page",
".",
"each",
"{",
"|",
"record",
"|",
"yield",
"record",
"}",
"np",
"=",
"np",
".",
"next_page",
"end",
"end"
] |
Given a hash and client, will create an Enumerator that will lazily
request Salesforce for the next page of results.
Yield each value on each page.
|
[
"Given",
"a",
"hash",
"and",
"client",
"will",
"create",
"an",
"Enumerator",
"that",
"will",
"lazily",
"request",
"Salesforce",
"for",
"the",
"next",
"page",
"of",
"results",
".",
"Yield",
"each",
"value",
"on",
"each",
"page",
"."
] |
74cbc9c745320dbea5117e2e3cc8d54d66db6562
|
https://github.com/restforce/restforce/blob/74cbc9c745320dbea5117e2e3cc8d54d66db6562/lib/restforce/collection.rb#L15-L23
|
12,771
|
restforce/restforce
|
lib/restforce/middleware/authentication.rb
|
Restforce.Middleware::Authentication.encode_www_form
|
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)
v = CGI.escape(v.to_s)
"#{k}=#{v}"
end.join('&')
end
end
|
ruby
|
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)
v = CGI.escape(v.to_s)
"#{k}=#{v}"
end.join('&')
end
end
|
[
"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",
")",
"v",
"=",
"CGI",
".",
"escape",
"(",
"v",
".",
"to_s",
")",
"\"#{k}=#{v}\"",
"end",
".",
"join",
"(",
"'&'",
")",
"end",
"end"
] |
Featured detect form encoding.
URI in 1.8 does not include encode_www_form
|
[
"Featured",
"detect",
"form",
"encoding",
".",
"URI",
"in",
"1",
".",
"8",
"does",
"not",
"include",
"encode_www_form"
] |
74cbc9c745320dbea5117e2e3cc8d54d66db6562
|
https://github.com/restforce/restforce/blob/74cbc9c745320dbea5117e2e3cc8d54d66db6562/lib/restforce/middleware/authentication.rb#L70-L80
|
12,772
|
rmagick/rmagick
|
ext/RMagick/extconf.rb
|
RMagick.Extconf.have_enum_values
|
def have_enum_values(enum, values, headers = nil, &b)
values.each do |value|
have_enum_value(enum, value, headers, &b)
end
end
|
ruby
|
def have_enum_values(enum, values, headers = nil, &b)
values.each do |value|
have_enum_value(enum, value, headers, &b)
end
end
|
[
"def",
"have_enum_values",
"(",
"enum",
",",
"values",
",",
"headers",
"=",
"nil",
",",
"&",
"b",
")",
"values",
".",
"each",
"do",
"|",
"value",
"|",
"have_enum_value",
"(",
"enum",
",",
"value",
",",
"headers",
",",
"b",
")",
"end",
"end"
] |
Test for multiple values of the same enum type
|
[
"Test",
"for",
"multiple",
"values",
"of",
"the",
"same",
"enum",
"type"
] |
ef6688ed9d76bf123c2ea1a483eff8635051adb7
|
https://github.com/rmagick/rmagick/blob/ef6688ed9d76bf123c2ea1a483eff8635051adb7/ext/RMagick/extconf.rb#L136-L140
|
12,773
|
rmagick/rmagick
|
lib/rvg/rvg.rb
|
Magick.RVG.bgfill
|
def bgfill
if @background_fill.nil?
color = Magick::Pixel.new(0, 0, 0, Magick::TransparentOpacity)
else
color = @background_fill
color.opacity = (1.0 - @background_fill_opacity) * Magick::TransparentOpacity
end
color
end
|
ruby
|
def bgfill
if @background_fill.nil?
color = Magick::Pixel.new(0, 0, 0, Magick::TransparentOpacity)
else
color = @background_fill
color.opacity = (1.0 - @background_fill_opacity) * Magick::TransparentOpacity
end
color
end
|
[
"def",
"bgfill",
"if",
"@background_fill",
".",
"nil?",
"color",
"=",
"Magick",
"::",
"Pixel",
".",
"new",
"(",
"0",
",",
"0",
",",
"0",
",",
"Magick",
"::",
"TransparentOpacity",
")",
"else",
"color",
"=",
"@background_fill",
"color",
".",
"opacity",
"=",
"(",
"1.0",
"-",
"@background_fill_opacity",
")",
"*",
"Magick",
"::",
"TransparentOpacity",
"end",
"color",
"end"
] |
background_fill defaults to 'none'. If background_fill has been set to something
else, combine it with the background_fill_opacity.
|
[
"background_fill",
"defaults",
"to",
"none",
".",
"If",
"background_fill",
"has",
"been",
"set",
"to",
"something",
"else",
"combine",
"it",
"with",
"the",
"background_fill_opacity",
"."
] |
ef6688ed9d76bf123c2ea1a483eff8635051adb7
|
https://github.com/rmagick/rmagick/blob/ef6688ed9d76bf123c2ea1a483eff8635051adb7/lib/rvg/rvg.rb#L61-L69
|
12,774
|
rmagick/rmagick
|
lib/rvg/rvg.rb
|
Magick.RVG.background_image=
|
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 (got #{bg_image.class})" if bg_image && !bg_image.is_a?(Magick::Image)
@background_image = bg_image
end
|
ruby
|
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 (got #{bg_image.class})" if bg_image && !bg_image.is_a?(Magick::Image)
@background_image = bg_image
end
|
[
"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 (got #{bg_image.class})\"",
"if",
"bg_image",
"&&",
"!",
"bg_image",
".",
"is_a?",
"(",
"Magick",
"::",
"Image",
")",
"@background_image",
"=",
"bg_image",
"end"
] |
Sets an image to use as the canvas background. See background_position= for layout options.
|
[
"Sets",
"an",
"image",
"to",
"use",
"as",
"the",
"canvas",
"background",
".",
"See",
"background_position",
"=",
"for",
"layout",
"options",
"."
] |
ef6688ed9d76bf123c2ea1a483eff8635051adb7
|
https://github.com/rmagick/rmagick/blob/ef6688ed9d76bf123c2ea1a483eff8635051adb7/lib/rvg/rvg.rb#L140-L145
|
12,775
|
rmagick/rmagick
|
lib/rvg/rvg.rb
|
Magick.RVG.add_outermost_primitives
|
def add_outermost_primitives(gc) #:nodoc:
add_transform_primitives(gc)
gc.push
add_viewbox_primitives(@width, @height, gc)
add_style_primitives(gc)
@content.each { |element| element.add_primitives(gc) }
gc.pop
self
end
|
ruby
|
def add_outermost_primitives(gc) #:nodoc:
add_transform_primitives(gc)
gc.push
add_viewbox_primitives(@width, @height, gc)
add_style_primitives(gc)
@content.each { |element| element.add_primitives(gc) }
gc.pop
self
end
|
[
"def",
"add_outermost_primitives",
"(",
"gc",
")",
"#:nodoc:",
"add_transform_primitives",
"(",
"gc",
")",
"gc",
".",
"push",
"add_viewbox_primitives",
"(",
"@width",
",",
"@height",
",",
"gc",
")",
"add_style_primitives",
"(",
"gc",
")",
"@content",
".",
"each",
"{",
"|",
"element",
"|",
"element",
".",
"add_primitives",
"(",
"gc",
")",
"}",
"gc",
".",
"pop",
"self",
"end"
] |
Primitives for the outermost RVG object
|
[
"Primitives",
"for",
"the",
"outermost",
"RVG",
"object"
] |
ef6688ed9d76bf123c2ea1a483eff8635051adb7
|
https://github.com/rmagick/rmagick/blob/ef6688ed9d76bf123c2ea1a483eff8635051adb7/lib/rvg/rvg.rb#L260-L268
|
12,776
|
rmagick/rmagick
|
lib/rvg/rvg.rb
|
Magick.RVG.add_primitives
|
def add_primitives(gc) #:nodoc:
raise ArgumentError, 'RVG width or height undefined' if @width.nil? || @height.nil?
return self if @width.zero? || @height.zero?
gc.push
add_outermost_primitives(gc)
gc.pop
end
|
ruby
|
def add_primitives(gc) #:nodoc:
raise ArgumentError, 'RVG width or height undefined' if @width.nil? || @height.nil?
return self if @width.zero? || @height.zero?
gc.push
add_outermost_primitives(gc)
gc.pop
end
|
[
"def",
"add_primitives",
"(",
"gc",
")",
"#:nodoc:",
"raise",
"ArgumentError",
",",
"'RVG width or height undefined'",
"if",
"@width",
".",
"nil?",
"||",
"@height",
".",
"nil?",
"return",
"self",
"if",
"@width",
".",
"zero?",
"||",
"@height",
".",
"zero?",
"gc",
".",
"push",
"add_outermost_primitives",
"(",
"gc",
")",
"gc",
".",
"pop",
"end"
] |
Primitives for nested RVG objects
|
[
"Primitives",
"for",
"nested",
"RVG",
"objects"
] |
ef6688ed9d76bf123c2ea1a483eff8635051adb7
|
https://github.com/rmagick/rmagick/blob/ef6688ed9d76bf123c2ea1a483eff8635051adb7/lib/rvg/rvg.rb#L271-L278
|
12,777
|
rmagick/rmagick
|
lib/rmagick_internal.rb
|
Magick.Geometry.to_s
|
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.truncate == @height ? '%d' : '%.2f'
str << format(fmt, @height)
str << '%' if @flag == PercentGeometry
end
str << format('%+d%+d', @x, @y) if @x != 0 || @y != 0
str << FLAGS[@flag.to_i] if @flag != PercentGeometry
str
end
|
ruby
|
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.truncate == @height ? '%d' : '%.2f'
str << format(fmt, @height)
str << '%' if @flag == PercentGeometry
end
str << format('%+d%+d', @x, @y) if @x != 0 || @y != 0
str << FLAGS[@flag.to_i] if @flag != PercentGeometry
str
end
|
[
"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",
".",
"truncate",
"==",
"@height",
"?",
"'%d'",
":",
"'%.2f'",
"str",
"<<",
"format",
"(",
"fmt",
",",
"@height",
")",
"str",
"<<",
"'%'",
"if",
"@flag",
"==",
"PercentGeometry",
"end",
"str",
"<<",
"format",
"(",
"'%+d%+d'",
",",
"@x",
",",
"@y",
")",
"if",
"@x",
"!=",
"0",
"||",
"@y",
"!=",
"0",
"str",
"<<",
"FLAGS",
"[",
"@flag",
".",
"to_i",
"]",
"if",
"@flag",
"!=",
"PercentGeometry",
"str",
"end"
] |
Convert object to a geometry string
|
[
"Convert",
"object",
"to",
"a",
"geometry",
"string"
] |
ef6688ed9d76bf123c2ea1a483eff8635051adb7
|
https://github.com/rmagick/rmagick/blob/ef6688ed9d76bf123c2ea1a483eff8635051adb7/lib/rmagick_internal.rb#L130-L148
|
12,778
|
rmagick/rmagick
|
lib/rmagick_internal.rb
|
Magick.Draw.arc
|
def arc(start_x, start_y, end_x, end_y, start_degrees, end_degrees)
primitive 'arc ' + format('%g,%g %g,%g %g,%g',
start_x, start_y, end_x, end_y, start_degrees, end_degrees)
end
|
ruby
|
def arc(start_x, start_y, end_x, end_y, start_degrees, end_degrees)
primitive 'arc ' + format('%g,%g %g,%g %g,%g',
start_x, start_y, end_x, end_y, start_degrees, end_degrees)
end
|
[
"def",
"arc",
"(",
"start_x",
",",
"start_y",
",",
"end_x",
",",
"end_y",
",",
"start_degrees",
",",
"end_degrees",
")",
"primitive",
"'arc '",
"+",
"format",
"(",
"'%g,%g %g,%g %g,%g'",
",",
"start_x",
",",
"start_y",
",",
"end_x",
",",
"end_y",
",",
"start_degrees",
",",
"end_degrees",
")",
"end"
] |
Draw an arc.
|
[
"Draw",
"an",
"arc",
"."
] |
ef6688ed9d76bf123c2ea1a483eff8635051adb7
|
https://github.com/rmagick/rmagick/blob/ef6688ed9d76bf123c2ea1a483eff8635051adb7/lib/rmagick_internal.rb#L233-L236
|
12,779
|
rmagick/rmagick
|
lib/rmagick_internal.rb
|
Magick.Draw.circle
|
def circle(origin_x, origin_y, perim_x, perim_y)
primitive 'circle ' + format('%g,%g %g,%g', origin_x, origin_y, perim_x, perim_y)
end
|
ruby
|
def circle(origin_x, origin_y, perim_x, perim_y)
primitive 'circle ' + format('%g,%g %g,%g', origin_x, origin_y, perim_x, perim_y)
end
|
[
"def",
"circle",
"(",
"origin_x",
",",
"origin_y",
",",
"perim_x",
",",
"perim_y",
")",
"primitive",
"'circle '",
"+",
"format",
"(",
"'%g,%g %g,%g'",
",",
"origin_x",
",",
"origin_y",
",",
"perim_x",
",",
"perim_y",
")",
"end"
] |
Draw a circle
|
[
"Draw",
"a",
"circle"
] |
ef6688ed9d76bf123c2ea1a483eff8635051adb7
|
https://github.com/rmagick/rmagick/blob/ef6688ed9d76bf123c2ea1a483eff8635051adb7/lib/rmagick_internal.rb#L249-L251
|
12,780
|
rmagick/rmagick
|
lib/rmagick_internal.rb
|
Magick.Draw.clip_rule
|
def clip_rule(rule)
Kernel.raise ArgumentError, "Unknown clipping rule #{rule}" unless %w[evenodd nonzero].include?(rule.downcase)
primitive "clip-rule #{rule}"
end
|
ruby
|
def clip_rule(rule)
Kernel.raise ArgumentError, "Unknown clipping rule #{rule}" unless %w[evenodd nonzero].include?(rule.downcase)
primitive "clip-rule #{rule}"
end
|
[
"def",
"clip_rule",
"(",
"rule",
")",
"Kernel",
".",
"raise",
"ArgumentError",
",",
"\"Unknown clipping rule #{rule}\"",
"unless",
"%w[",
"evenodd",
"nonzero",
"]",
".",
"include?",
"(",
"rule",
".",
"downcase",
")",
"primitive",
"\"clip-rule #{rule}\"",
"end"
] |
Define the clipping rule.
|
[
"Define",
"the",
"clipping",
"rule",
"."
] |
ef6688ed9d76bf123c2ea1a483eff8635051adb7
|
https://github.com/rmagick/rmagick/blob/ef6688ed9d76bf123c2ea1a483eff8635051adb7/lib/rmagick_internal.rb#L259-L262
|
12,781
|
rmagick/rmagick
|
lib/rmagick_internal.rb
|
Magick.Draw.clip_units
|
def clip_units(unit)
Kernel.raise ArgumentError, "Unknown clip unit #{unit}" unless %w[userspace userspaceonuse objectboundingbox].include?(unit.downcase)
primitive "clip-units #{unit}"
end
|
ruby
|
def clip_units(unit)
Kernel.raise ArgumentError, "Unknown clip unit #{unit}" unless %w[userspace userspaceonuse objectboundingbox].include?(unit.downcase)
primitive "clip-units #{unit}"
end
|
[
"def",
"clip_units",
"(",
"unit",
")",
"Kernel",
".",
"raise",
"ArgumentError",
",",
"\"Unknown clip unit #{unit}\"",
"unless",
"%w[",
"userspace",
"userspaceonuse",
"objectboundingbox",
"]",
".",
"include?",
"(",
"unit",
".",
"downcase",
")",
"primitive",
"\"clip-units #{unit}\"",
"end"
] |
Define the clip units
|
[
"Define",
"the",
"clip",
"units"
] |
ef6688ed9d76bf123c2ea1a483eff8635051adb7
|
https://github.com/rmagick/rmagick/blob/ef6688ed9d76bf123c2ea1a483eff8635051adb7/lib/rmagick_internal.rb#L265-L268
|
12,782
|
rmagick/rmagick
|
lib/rmagick_internal.rb
|
Magick.Draw.color
|
def color(x, y, method)
Kernel.raise ArgumentError, "Unknown PaintMethod: #{method}" unless PAINT_METHOD_NAMES.key?(method.to_i)
primitive "color #{x},#{y},#{PAINT_METHOD_NAMES[method.to_i]}"
end
|
ruby
|
def color(x, y, method)
Kernel.raise ArgumentError, "Unknown PaintMethod: #{method}" unless PAINT_METHOD_NAMES.key?(method.to_i)
primitive "color #{x},#{y},#{PAINT_METHOD_NAMES[method.to_i]}"
end
|
[
"def",
"color",
"(",
"x",
",",
"y",
",",
"method",
")",
"Kernel",
".",
"raise",
"ArgumentError",
",",
"\"Unknown PaintMethod: #{method}\"",
"unless",
"PAINT_METHOD_NAMES",
".",
"key?",
"(",
"method",
".",
"to_i",
")",
"primitive",
"\"color #{x},#{y},#{PAINT_METHOD_NAMES[method.to_i]}\"",
"end"
] |
Set color in image according to specified colorization rule. Rule is one of
point, replace, floodfill, filltoborder,reset
|
[
"Set",
"color",
"in",
"image",
"according",
"to",
"specified",
"colorization",
"rule",
".",
"Rule",
"is",
"one",
"of",
"point",
"replace",
"floodfill",
"filltoborder",
"reset"
] |
ef6688ed9d76bf123c2ea1a483eff8635051adb7
|
https://github.com/rmagick/rmagick/blob/ef6688ed9d76bf123c2ea1a483eff8635051adb7/lib/rmagick_internal.rb#L272-L275
|
12,783
|
rmagick/rmagick
|
lib/rmagick_internal.rb
|
Magick.Draw.ellipse
|
def ellipse(origin_x, origin_y, width, height, arc_start, arc_end)
primitive 'ellipse ' + format('%g,%g %g,%g %g,%g',
origin_x, origin_y, width, height, arc_start, arc_end)
end
|
ruby
|
def ellipse(origin_x, origin_y, width, height, arc_start, arc_end)
primitive 'ellipse ' + format('%g,%g %g,%g %g,%g',
origin_x, origin_y, width, height, arc_start, arc_end)
end
|
[
"def",
"ellipse",
"(",
"origin_x",
",",
"origin_y",
",",
"width",
",",
"height",
",",
"arc_start",
",",
"arc_end",
")",
"primitive",
"'ellipse '",
"+",
"format",
"(",
"'%g,%g %g,%g %g,%g'",
",",
"origin_x",
",",
"origin_y",
",",
"width",
",",
"height",
",",
"arc_start",
",",
"arc_end",
")",
"end"
] |
Draw an ellipse
|
[
"Draw",
"an",
"ellipse"
] |
ef6688ed9d76bf123c2ea1a483eff8635051adb7
|
https://github.com/rmagick/rmagick/blob/ef6688ed9d76bf123c2ea1a483eff8635051adb7/lib/rmagick_internal.rb#L304-L307
|
12,784
|
rmagick/rmagick
|
lib/rmagick_internal.rb
|
Magick.Draw.interline_spacing
|
def interline_spacing(space)
begin
Float(space)
rescue ArgumentError
Kernel.raise ArgumentError, 'invalid value for interline_spacing'
rescue TypeError
Kernel.raise TypeError, "can't convert #{space.class} into Float"
end
primitive "interline-spacing #{space}"
end
|
ruby
|
def interline_spacing(space)
begin
Float(space)
rescue ArgumentError
Kernel.raise ArgumentError, 'invalid value for interline_spacing'
rescue TypeError
Kernel.raise TypeError, "can't convert #{space.class} into Float"
end
primitive "interline-spacing #{space}"
end
|
[
"def",
"interline_spacing",
"(",
"space",
")",
"begin",
"Float",
"(",
"space",
")",
"rescue",
"ArgumentError",
"Kernel",
".",
"raise",
"ArgumentError",
",",
"'invalid value for interline_spacing'",
"rescue",
"TypeError",
"Kernel",
".",
"raise",
"TypeError",
",",
"\"can't convert #{space.class} into Float\"",
"end",
"primitive",
"\"interline-spacing #{space}\"",
"end"
] |
IM 6.5.5-8 and later
|
[
"IM",
"6",
".",
"5",
".",
"5",
"-",
"8",
"and",
"later"
] |
ef6688ed9d76bf123c2ea1a483eff8635051adb7
|
https://github.com/rmagick/rmagick/blob/ef6688ed9d76bf123c2ea1a483eff8635051adb7/lib/rmagick_internal.rb#L369-L378
|
12,785
|
rmagick/rmagick
|
lib/rmagick_internal.rb
|
Magick.Draw.line
|
def line(start_x, start_y, end_x, end_y)
primitive 'line ' + format('%g,%g %g,%g', start_x, start_y, end_x, end_y)
end
|
ruby
|
def line(start_x, start_y, end_x, end_y)
primitive 'line ' + format('%g,%g %g,%g', start_x, start_y, end_x, end_y)
end
|
[
"def",
"line",
"(",
"start_x",
",",
"start_y",
",",
"end_x",
",",
"end_y",
")",
"primitive",
"'line '",
"+",
"format",
"(",
"'%g,%g %g,%g'",
",",
"start_x",
",",
"start_y",
",",
"end_x",
",",
"end_y",
")",
"end"
] |
Draw a line
|
[
"Draw",
"a",
"line"
] |
ef6688ed9d76bf123c2ea1a483eff8635051adb7
|
https://github.com/rmagick/rmagick/blob/ef6688ed9d76bf123c2ea1a483eff8635051adb7/lib/rmagick_internal.rb#L405-L407
|
12,786
|
rmagick/rmagick
|
lib/rmagick_internal.rb
|
Magick.Draw.opacity
|
def opacity(opacity)
if opacity.is_a?(Numeric)
Kernel.raise ArgumentError, 'opacity must be >= 0 and <= 1.0' if opacity < 0 || opacity > 1.0
end
primitive "opacity #{opacity}"
end
|
ruby
|
def opacity(opacity)
if opacity.is_a?(Numeric)
Kernel.raise ArgumentError, 'opacity must be >= 0 and <= 1.0' if opacity < 0 || opacity > 1.0
end
primitive "opacity #{opacity}"
end
|
[
"def",
"opacity",
"(",
"opacity",
")",
"if",
"opacity",
".",
"is_a?",
"(",
"Numeric",
")",
"Kernel",
".",
"raise",
"ArgumentError",
",",
"'opacity must be >= 0 and <= 1.0'",
"if",
"opacity",
"<",
"0",
"||",
"opacity",
">",
"1.0",
"end",
"primitive",
"\"opacity #{opacity}\"",
"end"
] |
Specify drawing fill and stroke opacities. If the value is a string
ending with a %, the number will be multiplied by 0.01.
|
[
"Specify",
"drawing",
"fill",
"and",
"stroke",
"opacities",
".",
"If",
"the",
"value",
"is",
"a",
"string",
"ending",
"with",
"a",
"%",
"the",
"number",
"will",
"be",
"multiplied",
"by",
"0",
".",
"01",
"."
] |
ef6688ed9d76bf123c2ea1a483eff8635051adb7
|
https://github.com/rmagick/rmagick/blob/ef6688ed9d76bf123c2ea1a483eff8635051adb7/lib/rmagick_internal.rb#L418-L423
|
12,787
|
rmagick/rmagick
|
lib/rmagick_internal.rb
|
Magick.Draw.pattern
|
def pattern(name, x, y, width, height)
push('defs')
push("pattern #{name} #{x} #{y} #{width} #{height}")
push('graphic-context')
yield
ensure
pop('graphic-context')
pop('pattern')
pop('defs')
end
|
ruby
|
def pattern(name, x, y, width, height)
push('defs')
push("pattern #{name} #{x} #{y} #{width} #{height}")
push('graphic-context')
yield
ensure
pop('graphic-context')
pop('pattern')
pop('defs')
end
|
[
"def",
"pattern",
"(",
"name",
",",
"x",
",",
"y",
",",
"width",
",",
"height",
")",
"push",
"(",
"'defs'",
")",
"push",
"(",
"\"pattern #{name} #{x} #{y} #{width} #{height}\"",
")",
"push",
"(",
"'graphic-context'",
")",
"yield",
"ensure",
"pop",
"(",
"'graphic-context'",
")",
"pop",
"(",
"'pattern'",
")",
"pop",
"(",
"'defs'",
")",
"end"
] |
Define a pattern. In the block, call primitive methods to
draw the pattern. Reference the pattern by using its name
as the argument to the 'fill' or 'stroke' methods
|
[
"Define",
"a",
"pattern",
".",
"In",
"the",
"block",
"call",
"primitive",
"methods",
"to",
"draw",
"the",
"pattern",
".",
"Reference",
"the",
"pattern",
"by",
"using",
"its",
"name",
"as",
"the",
"argument",
"to",
"the",
"fill",
"or",
"stroke",
"methods"
] |
ef6688ed9d76bf123c2ea1a483eff8635051adb7
|
https://github.com/rmagick/rmagick/blob/ef6688ed9d76bf123c2ea1a483eff8635051adb7/lib/rmagick_internal.rb#L435-L444
|
12,788
|
rmagick/rmagick
|
lib/rmagick_internal.rb
|
Magick.Draw.polygon
|
def polygon(*points)
if points.length.zero?
Kernel.raise ArgumentError, 'no points specified'
elsif points.length.odd?
Kernel.raise ArgumentError, 'odd number of points specified'
end
primitive 'polygon ' + points.join(',')
end
|
ruby
|
def polygon(*points)
if points.length.zero?
Kernel.raise ArgumentError, 'no points specified'
elsif points.length.odd?
Kernel.raise ArgumentError, 'odd number of points specified'
end
primitive 'polygon ' + points.join(',')
end
|
[
"def",
"polygon",
"(",
"*",
"points",
")",
"if",
"points",
".",
"length",
".",
"zero?",
"Kernel",
".",
"raise",
"ArgumentError",
",",
"'no points specified'",
"elsif",
"points",
".",
"length",
".",
"odd?",
"Kernel",
".",
"raise",
"ArgumentError",
",",
"'odd number of points specified'",
"end",
"primitive",
"'polygon '",
"+",
"points",
".",
"join",
"(",
"','",
")",
"end"
] |
Draw a polygon
|
[
"Draw",
"a",
"polygon"
] |
ef6688ed9d76bf123c2ea1a483eff8635051adb7
|
https://github.com/rmagick/rmagick/blob/ef6688ed9d76bf123c2ea1a483eff8635051adb7/lib/rmagick_internal.rb#L459-L466
|
12,789
|
rmagick/rmagick
|
lib/rmagick_internal.rb
|
Magick.Draw.rectangle
|
def rectangle(upper_left_x, upper_left_y, lower_right_x, lower_right_y)
primitive 'rectangle ' + format('%g,%g %g,%g',
upper_left_x, upper_left_y, lower_right_x, lower_right_y)
end
|
ruby
|
def rectangle(upper_left_x, upper_left_y, lower_right_x, lower_right_y)
primitive 'rectangle ' + format('%g,%g %g,%g',
upper_left_x, upper_left_y, lower_right_x, lower_right_y)
end
|
[
"def",
"rectangle",
"(",
"upper_left_x",
",",
"upper_left_y",
",",
"lower_right_x",
",",
"lower_right_y",
")",
"primitive",
"'rectangle '",
"+",
"format",
"(",
"'%g,%g %g,%g'",
",",
"upper_left_x",
",",
"upper_left_y",
",",
"lower_right_x",
",",
"lower_right_y",
")",
"end"
] |
Draw a rectangle
|
[
"Draw",
"a",
"rectangle"
] |
ef6688ed9d76bf123c2ea1a483eff8635051adb7
|
https://github.com/rmagick/rmagick/blob/ef6688ed9d76bf123c2ea1a483eff8635051adb7/lib/rmagick_internal.rb#L508-L511
|
12,790
|
rmagick/rmagick
|
lib/rmagick_internal.rb
|
Magick.Draw.roundrectangle
|
def roundrectangle(center_x, center_y, width, height, corner_width, corner_height)
primitive 'roundrectangle ' + format('%g,%g,%g,%g,%g,%g',
center_x, center_y, width, height, corner_width, corner_height)
end
|
ruby
|
def roundrectangle(center_x, center_y, width, height, corner_width, corner_height)
primitive 'roundrectangle ' + format('%g,%g,%g,%g,%g,%g',
center_x, center_y, width, height, corner_width, corner_height)
end
|
[
"def",
"roundrectangle",
"(",
"center_x",
",",
"center_y",
",",
"width",
",",
"height",
",",
"corner_width",
",",
"corner_height",
")",
"primitive",
"'roundrectangle '",
"+",
"format",
"(",
"'%g,%g,%g,%g,%g,%g'",
",",
"center_x",
",",
"center_y",
",",
"width",
",",
"height",
",",
"corner_width",
",",
"corner_height",
")",
"end"
] |
Draw a rectangle with rounded corners
|
[
"Draw",
"a",
"rectangle",
"with",
"rounded",
"corners"
] |
ef6688ed9d76bf123c2ea1a483eff8635051adb7
|
https://github.com/rmagick/rmagick/blob/ef6688ed9d76bf123c2ea1a483eff8635051adb7/lib/rmagick_internal.rb#L519-L522
|
12,791
|
rmagick/rmagick
|
lib/rmagick_internal.rb
|
Magick.Draw.stroke_dasharray
|
def stroke_dasharray(*list)
if list.length.zero?
primitive 'stroke-dasharray none'
else
list.each do |x|
Kernel.raise ArgumentError, "dash array elements must be > 0 (#{x} given)" if x <= 0
end
primitive "stroke-dasharray #{list.join(',')}"
end
end
|
ruby
|
def stroke_dasharray(*list)
if list.length.zero?
primitive 'stroke-dasharray none'
else
list.each do |x|
Kernel.raise ArgumentError, "dash array elements must be > 0 (#{x} given)" if x <= 0
end
primitive "stroke-dasharray #{list.join(',')}"
end
end
|
[
"def",
"stroke_dasharray",
"(",
"*",
"list",
")",
"if",
"list",
".",
"length",
".",
"zero?",
"primitive",
"'stroke-dasharray none'",
"else",
"list",
".",
"each",
"do",
"|",
"x",
"|",
"Kernel",
".",
"raise",
"ArgumentError",
",",
"\"dash array elements must be > 0 (#{x} given)\"",
"if",
"x",
"<=",
"0",
"end",
"primitive",
"\"stroke-dasharray #{list.join(',')}\"",
"end",
"end"
] |
Specify a stroke dash pattern
|
[
"Specify",
"a",
"stroke",
"dash",
"pattern"
] |
ef6688ed9d76bf123c2ea1a483eff8635051adb7
|
https://github.com/rmagick/rmagick/blob/ef6688ed9d76bf123c2ea1a483eff8635051adb7/lib/rmagick_internal.rb#L551-L560
|
12,792
|
rmagick/rmagick
|
lib/rmagick_internal.rb
|
Magick.Draw.text
|
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['\'']
text = '\'' + text + '\''
elsif !text['"']
text = '"' + text + '"'
elsif !(text['{'] || text['}'])
text = '{' + text + '}'
else
# escape existing braces, surround with braces
text = '{' + text.gsub(/[}]/) { |b| '\\' + b } + '}'
end
primitive "text #{x},#{y} #{text}"
end
|
ruby
|
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['\'']
text = '\'' + text + '\''
elsif !text['"']
text = '"' + text + '"'
elsif !(text['{'] || text['}'])
text = '{' + text + '}'
else
# escape existing braces, surround with braces
text = '{' + text.gsub(/[}]/) { |b| '\\' + b } + '}'
end
primitive "text #{x},#{y} #{text}"
end
|
[
"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",
"[",
"'\\''",
"]",
"text",
"=",
"'\\''",
"+",
"text",
"+",
"'\\''",
"elsif",
"!",
"text",
"[",
"'\"'",
"]",
"text",
"=",
"'\"'",
"+",
"text",
"+",
"'\"'",
"elsif",
"!",
"(",
"text",
"[",
"'{'",
"]",
"||",
"text",
"[",
"'}'",
"]",
")",
"text",
"=",
"'{'",
"+",
"text",
"+",
"'}'",
"else",
"# escape existing braces, surround with braces",
"text",
"=",
"'{'",
"+",
"text",
".",
"gsub",
"(",
"/",
"/",
")",
"{",
"|",
"b",
"|",
"'\\\\'",
"+",
"b",
"}",
"+",
"'}'",
"end",
"primitive",
"\"text #{x},#{y} #{text}\"",
"end"
] |
Draw text at position x,y. Add quotes to text that is not already quoted.
|
[
"Draw",
"text",
"at",
"position",
"x",
"y",
".",
"Add",
"quotes",
"to",
"text",
"that",
"is",
"not",
"already",
"quoted",
"."
] |
ef6688ed9d76bf123c2ea1a483eff8635051adb7
|
https://github.com/rmagick/rmagick/blob/ef6688ed9d76bf123c2ea1a483eff8635051adb7/lib/rmagick_internal.rb#L594-L609
|
12,793
|
rmagick/rmagick
|
lib/rmagick_internal.rb
|
Magick.Draw.text_align
|
def text_align(alignment)
Kernel.raise ArgumentError, "Unknown alignment constant: #{alignment}" unless ALIGN_TYPE_NAMES.key?(alignment.to_i)
primitive "text-align #{ALIGN_TYPE_NAMES[alignment.to_i]}"
end
|
ruby
|
def text_align(alignment)
Kernel.raise ArgumentError, "Unknown alignment constant: #{alignment}" unless ALIGN_TYPE_NAMES.key?(alignment.to_i)
primitive "text-align #{ALIGN_TYPE_NAMES[alignment.to_i]}"
end
|
[
"def",
"text_align",
"(",
"alignment",
")",
"Kernel",
".",
"raise",
"ArgumentError",
",",
"\"Unknown alignment constant: #{alignment}\"",
"unless",
"ALIGN_TYPE_NAMES",
".",
"key?",
"(",
"alignment",
".",
"to_i",
")",
"primitive",
"\"text-align #{ALIGN_TYPE_NAMES[alignment.to_i]}\"",
"end"
] |
Specify text alignment relative to a given point
|
[
"Specify",
"text",
"alignment",
"relative",
"to",
"a",
"given",
"point"
] |
ef6688ed9d76bf123c2ea1a483eff8635051adb7
|
https://github.com/rmagick/rmagick/blob/ef6688ed9d76bf123c2ea1a483eff8635051adb7/lib/rmagick_internal.rb#L612-L615
|
12,794
|
rmagick/rmagick
|
lib/rmagick_internal.rb
|
Magick.Draw.text_anchor
|
def text_anchor(anchor)
Kernel.raise ArgumentError, "Unknown anchor constant: #{anchor}" unless ANCHOR_TYPE_NAMES.key?(anchor.to_i)
primitive "text-anchor #{ANCHOR_TYPE_NAMES[anchor.to_i]}"
end
|
ruby
|
def text_anchor(anchor)
Kernel.raise ArgumentError, "Unknown anchor constant: #{anchor}" unless ANCHOR_TYPE_NAMES.key?(anchor.to_i)
primitive "text-anchor #{ANCHOR_TYPE_NAMES[anchor.to_i]}"
end
|
[
"def",
"text_anchor",
"(",
"anchor",
")",
"Kernel",
".",
"raise",
"ArgumentError",
",",
"\"Unknown anchor constant: #{anchor}\"",
"unless",
"ANCHOR_TYPE_NAMES",
".",
"key?",
"(",
"anchor",
".",
"to_i",
")",
"primitive",
"\"text-anchor #{ANCHOR_TYPE_NAMES[anchor.to_i]}\"",
"end"
] |
SVG-compatible version of text_align
|
[
"SVG",
"-",
"compatible",
"version",
"of",
"text_align"
] |
ef6688ed9d76bf123c2ea1a483eff8635051adb7
|
https://github.com/rmagick/rmagick/blob/ef6688ed9d76bf123c2ea1a483eff8635051adb7/lib/rmagick_internal.rb#L618-L621
|
12,795
|
rmagick/rmagick
|
lib/rmagick_internal.rb
|
Magick.Image.color_point
|
def color_point(x, y, fill)
f = copy
f.pixel_color(x, y, fill)
f
end
|
ruby
|
def color_point(x, y, fill)
f = copy
f.pixel_color(x, y, fill)
f
end
|
[
"def",
"color_point",
"(",
"x",
",",
"y",
",",
"fill",
")",
"f",
"=",
"copy",
"f",
".",
"pixel_color",
"(",
"x",
",",
"y",
",",
"fill",
")",
"f",
"end"
] |
Set the color at x,y
|
[
"Set",
"the",
"color",
"at",
"x",
"y"
] |
ef6688ed9d76bf123c2ea1a483eff8635051adb7
|
https://github.com/rmagick/rmagick/blob/ef6688ed9d76bf123c2ea1a483eff8635051adb7/lib/rmagick_internal.rb#L763-L767
|
12,796
|
rmagick/rmagick
|
lib/rmagick_internal.rb
|
Magick.Image.color_floodfill
|
def color_floodfill(x, y, fill)
target = pixel_color(x, y)
color_flood_fill(target, fill, x, y, Magick::FloodfillMethod)
end
|
ruby
|
def color_floodfill(x, y, fill)
target = pixel_color(x, y)
color_flood_fill(target, fill, x, y, Magick::FloodfillMethod)
end
|
[
"def",
"color_floodfill",
"(",
"x",
",",
"y",
",",
"fill",
")",
"target",
"=",
"pixel_color",
"(",
"x",
",",
"y",
")",
"color_flood_fill",
"(",
"target",
",",
"fill",
",",
"x",
",",
"y",
",",
"Magick",
"::",
"FloodfillMethod",
")",
"end"
] |
Set all pixels that have the same color as the pixel at x,y and
are neighbors to the fill color
|
[
"Set",
"all",
"pixels",
"that",
"have",
"the",
"same",
"color",
"as",
"the",
"pixel",
"at",
"x",
"y",
"and",
"are",
"neighbors",
"to",
"the",
"fill",
"color"
] |
ef6688ed9d76bf123c2ea1a483eff8635051adb7
|
https://github.com/rmagick/rmagick/blob/ef6688ed9d76bf123c2ea1a483eff8635051adb7/lib/rmagick_internal.rb#L771-L774
|
12,797
|
rmagick/rmagick
|
lib/rmagick_internal.rb
|
Magick.Image.color_fill_to_border
|
def color_fill_to_border(x, y, fill)
color_flood_fill(border_color, fill, x, y, Magick::FillToBorderMethod)
end
|
ruby
|
def color_fill_to_border(x, y, fill)
color_flood_fill(border_color, fill, x, y, Magick::FillToBorderMethod)
end
|
[
"def",
"color_fill_to_border",
"(",
"x",
",",
"y",
",",
"fill",
")",
"color_flood_fill",
"(",
"border_color",
",",
"fill",
",",
"x",
",",
"y",
",",
"Magick",
"::",
"FillToBorderMethod",
")",
"end"
] |
Set all pixels that are neighbors of x,y and are not the border color
to the fill color
|
[
"Set",
"all",
"pixels",
"that",
"are",
"neighbors",
"of",
"x",
"y",
"and",
"are",
"not",
"the",
"border",
"color",
"to",
"the",
"fill",
"color"
] |
ef6688ed9d76bf123c2ea1a483eff8635051adb7
|
https://github.com/rmagick/rmagick/blob/ef6688ed9d76bf123c2ea1a483eff8635051adb7/lib/rmagick_internal.rb#L778-L780
|
12,798
|
rmagick/rmagick
|
lib/rmagick_internal.rb
|
Magick.Image.each_pixel
|
def each_pixel
get_pixels(0, 0, columns, rows).each_with_index do |p, n|
yield(p, n % columns, n / columns)
end
self
end
|
ruby
|
def each_pixel
get_pixels(0, 0, columns, rows).each_with_index do |p, n|
yield(p, n % columns, n / columns)
end
self
end
|
[
"def",
"each_pixel",
"get_pixels",
"(",
"0",
",",
"0",
",",
"columns",
",",
"rows",
")",
".",
"each_with_index",
"do",
"|",
"p",
",",
"n",
"|",
"yield",
"(",
"p",
",",
"n",
"%",
"columns",
",",
"n",
"/",
"columns",
")",
"end",
"self",
"end"
] |
Thanks to Russell Norris!
|
[
"Thanks",
"to",
"Russell",
"Norris!"
] |
ef6688ed9d76bf123c2ea1a483eff8635051adb7
|
https://github.com/rmagick/rmagick/blob/ef6688ed9d76bf123c2ea1a483eff8635051adb7/lib/rmagick_internal.rb#L804-L809
|
12,799
|
rmagick/rmagick
|
lib/rmagick_internal.rb
|
Magick.Image.matte_fill_to_border
|
def matte_fill_to_border(x, y)
f = copy
f.opacity = Magick::OpaqueOpacity unless f.alpha?
f.matte_flood_fill(border_color, TransparentOpacity,
x, y, FillToBorderMethod)
end
|
ruby
|
def matte_fill_to_border(x, y)
f = copy
f.opacity = Magick::OpaqueOpacity unless f.alpha?
f.matte_flood_fill(border_color, TransparentOpacity,
x, y, FillToBorderMethod)
end
|
[
"def",
"matte_fill_to_border",
"(",
"x",
",",
"y",
")",
"f",
"=",
"copy",
"f",
".",
"opacity",
"=",
"Magick",
"::",
"OpaqueOpacity",
"unless",
"f",
".",
"alpha?",
"f",
".",
"matte_flood_fill",
"(",
"border_color",
",",
"TransparentOpacity",
",",
"x",
",",
"y",
",",
"FillToBorderMethod",
")",
"end"
] |
Make transparent any neighbor pixel that is not the border color.
|
[
"Make",
"transparent",
"any",
"neighbor",
"pixel",
"that",
"is",
"not",
"the",
"border",
"color",
"."
] |
ef6688ed9d76bf123c2ea1a483eff8635051adb7
|
https://github.com/rmagick/rmagick/blob/ef6688ed9d76bf123c2ea1a483eff8635051adb7/lib/rmagick_internal.rb#L935-L940
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.