2017-07-09 08:06:36 -04:00
# frozen_string_literal: true
2017-07-10 09:39:13 -04:00
2016-08-06 12:03:25 -04:00
require " abstract_unit "
require " active_support/inflector "
2009-04-22 20:41:28 -04:00
2016-08-06 12:03:25 -04:00
require " inflector_test_cases "
require " constantize_test_cases "
2005-02-14 20:45:35 -05:00
2012-01-05 20:12:46 -05:00
class InflectorTest < ActiveSupport :: TestCase
2007-09-27 06:19:48 -04:00
include InflectorTestCases
2011-09-22 15:17:42 -04:00
include ConstantizeTestCases
2007-01-28 10:52:45 -05:00
2015-06-14 23:46:18 -04:00
def setup
# Dups the singleton before each test, restoring the original inflections later.
#
# This helper is implemented by setting @__instance__ because in some tests
# there are module functions that access ActiveSupport::Inflector.inflections,
# so we need to replace the singleton itself.
@original_inflections = ActiveSupport :: Inflector :: Inflections . instance_variable_get ( :@__instance__ ) [ :en ]
ActiveSupport :: Inflector :: Inflections . instance_variable_set ( :@__instance__ , en : @original_inflections . dup )
end
def teardown
ActiveSupport :: Inflector :: Inflections . instance_variable_set ( :@__instance__ , en : @original_inflections )
end
2005-03-26 08:20:47 -05:00
def test_pluralize_plurals
2008-06-03 14:32:53 -04:00
assert_equal " plurals " , ActiveSupport :: Inflector . pluralize ( " plurals " )
assert_equal " Plurals " , ActiveSupport :: Inflector . pluralize ( " Plurals " )
2005-03-26 08:20:47 -05:00
end
2007-09-22 14:34:43 -04:00
def test_pluralize_empty_string
2008-06-03 14:32:53 -04:00
assert_equal " " , ActiveSupport :: Inflector . pluralize ( " " )
2007-09-22 14:34:43 -04:00
end
2010-12-22 03:08:20 -05:00
2016-12-30 22:58:52 -05:00
test " uncountability of ascii word " do
word = " HTTP "
2013-10-12 07:47:57 -04:00
ActiveSupport :: Inflector . inflections do | inflect |
2016-12-30 22:58:52 -05:00
inflect . uncountable word
2013-10-12 07:47:57 -04:00
end
2016-12-30 22:58:52 -05:00
assert_equal word , ActiveSupport :: Inflector . pluralize ( word )
assert_equal word , ActiveSupport :: Inflector . singularize ( word )
assert_equal ActiveSupport :: Inflector . pluralize ( word ) , ActiveSupport :: Inflector . singularize ( word )
ActiveSupport :: Inflector . inflections . uncountables . pop
end
test " uncountability of non-ascii word " do
word = " 猫 "
ActiveSupport :: Inflector . inflections do | inflect |
inflect . uncountable word
end
assert_equal word , ActiveSupport :: Inflector . pluralize ( word )
assert_equal word , ActiveSupport :: Inflector . singularize ( word )
assert_equal ActiveSupport :: Inflector . pluralize ( word ) , ActiveSupport :: Inflector . singularize ( word )
2013-10-12 07:47:57 -04:00
ActiveSupport :: Inflector . inflections . uncountables . pop
end
2010-11-30 13:48:25 -05:00
ActiveSupport :: Inflector . inflections . uncountable . each do | word |
define_method " test_uncountability_of_ #{ word } " do
assert_equal word , ActiveSupport :: Inflector . singularize ( word )
assert_equal word , ActiveSupport :: Inflector . pluralize ( word )
assert_equal ActiveSupport :: Inflector . pluralize ( word ) , ActiveSupport :: Inflector . singularize ( word )
end
end
2010-12-22 03:08:20 -05:00
2010-11-30 13:48:25 -05:00
def test_uncountable_word_is_not_greedy
2015-06-14 23:46:18 -04:00
uncountable_word = " ors "
countable_word = " sponsor "
2010-12-22 03:08:20 -05:00
2015-06-14 23:46:18 -04:00
ActiveSupport :: Inflector . inflections . uncountable << uncountable_word
2010-12-22 03:08:20 -05:00
2015-06-14 23:46:18 -04:00
assert_equal uncountable_word , ActiveSupport :: Inflector . singularize ( uncountable_word )
assert_equal uncountable_word , ActiveSupport :: Inflector . pluralize ( uncountable_word )
assert_equal ActiveSupport :: Inflector . pluralize ( uncountable_word ) , ActiveSupport :: Inflector . singularize ( uncountable_word )
2010-11-30 13:48:25 -05:00
2015-06-14 23:46:18 -04:00
assert_equal " sponsor " , ActiveSupport :: Inflector . singularize ( countable_word )
assert_equal " sponsors " , ActiveSupport :: Inflector . pluralize ( countable_word )
assert_equal " sponsor " , ActiveSupport :: Inflector . singularize ( ActiveSupport :: Inflector . pluralize ( countable_word ) )
2010-11-30 13:48:25 -05:00
end
2007-09-22 14:34:43 -04:00
2005-03-26 08:20:47 -05:00
SingularToPlural . each do | singular , plural |
2011-02-28 17:17:38 -05:00
define_method " test_pluralize_singular_ #{ singular } " do
2008-06-03 14:32:53 -04:00
assert_equal ( plural , ActiveSupport :: Inflector . pluralize ( singular ) )
assert_equal ( plural . capitalize , ActiveSupport :: Inflector . pluralize ( singular . capitalize ) )
2004-12-29 16:03:21 -05:00
end
end
2005-03-26 08:20:47 -05:00
SingularToPlural . each do | singular , plural |
2011-02-28 17:17:38 -05:00
define_method " test_singularize_plural_ #{ plural } " do
2008-06-03 14:32:53 -04:00
assert_equal ( singular , ActiveSupport :: Inflector . singularize ( plural ) )
assert_equal ( singular . capitalize , ActiveSupport :: Inflector . singularize ( plural . capitalize ) )
2004-12-29 16:03:21 -05:00
end
end
2011-02-28 17:17:38 -05:00
2011-02-07 21:39:46 -05:00
SingularToPlural . each do | singular , plural |
2011-02-28 17:17:38 -05:00
define_method " test_pluralize_plural_ #{ plural } " do
2011-02-07 21:39:46 -05:00
assert_equal ( plural , ActiveSupport :: Inflector . pluralize ( plural ) )
assert_equal ( plural . capitalize , ActiveSupport :: Inflector . pluralize ( plural . capitalize ) )
end
2012-02-24 18:06:17 -05:00
2012-01-27 03:20:13 -05:00
define_method " test_singularize_singular_ #{ singular } " do
assert_equal ( singular , ActiveSupport :: Inflector . singularize ( singular ) )
assert_equal ( singular . capitalize , ActiveSupport :: Inflector . singularize ( singular . capitalize ) )
end
end
2012-02-24 18:06:17 -05:00
2008-08-23 13:33:07 -04:00
def test_overwrite_previous_inflectors
2015-06-14 23:46:18 -04:00
assert_equal ( " series " , ActiveSupport :: Inflector . singularize ( " series " ) )
ActiveSupport :: Inflector . inflections . singular " series " , " serie "
assert_equal ( " serie " , ActiveSupport :: Inflector . singularize ( " series " ) )
2008-08-23 13:33:07 -04:00
end
2013-08-03 08:51:17 -04:00
MixtureToTitleCase . each_with_index do | ( before , titleized ) , index |
define_method " test_titleize_mixture_to_title_case_ #{ index } " do
assert_equal ( titleized , ActiveSupport :: Inflector . titleize ( before ) , " mixture \
to TitleCase failed for #{before}")
2005-10-19 16:20:11 -04:00
end
end
2016-08-07 08:27:47 -04:00
MixtureToTitleCaseWithKeepIdSuffix . each_with_index do | ( before , titleized ) , index |
define_method " test_titleize_with_keep_id_suffix_mixture_to_title_case_ #{ index } " do
assert_equal ( titleized , ActiveSupport :: Inflector . titleize ( before , keep_id_suffix : true ) ,
" mixture to TitleCase with keep_id_suffix failed for #{ before } " )
end
end
2004-12-29 16:03:21 -05:00
def test_camelize
CamelToUnderscore . each do | camel , underscore |
2008-06-03 14:32:53 -04:00
assert_equal ( camel , ActiveSupport :: Inflector . camelize ( underscore ) )
2004-12-29 16:03:21 -05:00
end
end
2008-08-22 08:31:13 -04:00
def test_camelize_with_lower_downcases_the_first_letter
2016-08-06 12:03:25 -04:00
assert_equal ( " capital " , ActiveSupport :: Inflector . camelize ( " Capital " , false ) )
2008-08-22 08:31:13 -04:00
end
2011-06-09 04:10:49 -04:00
def test_camelize_with_underscores
2016-08-06 12:03:25 -04:00
assert_equal ( " CamelCase " , ActiveSupport :: Inflector . camelize ( " Camel_Case " ) )
2011-06-09 04:10:49 -04:00
end
def test_acronyms
ActiveSupport :: Inflector . inflections do | inflect |
inflect . acronym ( " API " )
inflect . acronym ( " HTML " )
inflect . acronym ( " HTTP " )
inflect . acronym ( " RESTful " )
inflect . acronym ( " W3C " )
inflect . acronym ( " PhD " )
inflect . acronym ( " RoR " )
inflect . acronym ( " SSL " )
end
# camelize underscore humanize titleize
[
[ " API " , " api " , " API " , " API " ] ,
[ " APIController " , " api_controller " , " API controller " , " API Controller " ] ,
[ " Nokogiri::HTML " , " nokogiri/html " , " Nokogiri/HTML " , " Nokogiri/HTML " ] ,
[ " HTTPAPI " , " http_api " , " HTTP API " , " HTTP API " ] ,
[ " HTTP::Get " , " http/get " , " HTTP/get " , " HTTP/Get " ] ,
[ " SSLError " , " ssl_error " , " SSL error " , " SSL Error " ] ,
[ " RESTful " , " restful " , " RESTful " , " RESTful " ] ,
[ " RESTfulController " , " restful_controller " , " RESTful controller " , " RESTful Controller " ] ,
2014-09-05 15:26:25 -04:00
[ " Nested::RESTful " , " nested/restful " , " Nested/RESTful " , " Nested/RESTful " ] ,
2011-06-09 04:10:49 -04:00
[ " IHeartW3C " , " i_heart_w3c " , " I heart W3C " , " I Heart W3C " ] ,
[ " PhDRequired " , " phd_required " , " PhD required " , " PhD Required " ] ,
[ " IRoRU " , " i_ror_u " , " I RoR u " , " I RoR U " ] ,
[ " RESTfulHTTPAPI " , " restful_http_api " , " RESTful HTTP API " , " RESTful HTTP API " ] ,
2014-10-03 17:45:40 -04:00
[ " HTTP::RESTful " , " http/restful " , " HTTP/RESTful " , " HTTP/RESTful " ] ,
[ " HTTP::RESTfulAPI " , " http/restful_api " , " HTTP/RESTful API " , " HTTP/RESTful API " ] ,
[ " APIRESTful " , " api_restful " , " API RESTful " , " API RESTful " ] ,
2011-06-09 04:10:49 -04:00
# misdirection
[ " Capistrano " , " capistrano " , " Capistrano " , " Capistrano " ] ,
[ " CapiController " , " capi_controller " , " Capi controller " , " Capi Controller " ] ,
[ " HttpsApis " , " https_apis " , " Https apis " , " Https Apis " ] ,
[ " Html5 " , " html5 " , " Html5 " , " Html5 " ] ,
[ " Restfully " , " restfully " , " Restfully " , " Restfully " ] ,
[ " RoRails " , " ro_rails " , " Ro rails " , " Ro Rails " ]
] . each do | camel , under , human , title |
assert_equal ( camel , ActiveSupport :: Inflector . camelize ( under ) )
assert_equal ( camel , ActiveSupport :: Inflector . camelize ( camel ) )
assert_equal ( under , ActiveSupport :: Inflector . underscore ( under ) )
assert_equal ( under , ActiveSupport :: Inflector . underscore ( camel ) )
assert_equal ( title , ActiveSupport :: Inflector . titleize ( under ) )
assert_equal ( title , ActiveSupport :: Inflector . titleize ( camel ) )
assert_equal ( human , ActiveSupport :: Inflector . humanize ( under ) )
end
end
def test_acronym_override
ActiveSupport :: Inflector . inflections do | inflect |
inflect . acronym ( " API " )
inflect . acronym ( " LegacyApi " )
end
assert_equal ( " LegacyApi " , ActiveSupport :: Inflector . camelize ( " legacyapi " ) )
assert_equal ( " LegacyAPI " , ActiveSupport :: Inflector . camelize ( " legacy_api " ) )
assert_equal ( " SomeLegacyApi " , ActiveSupport :: Inflector . camelize ( " some_legacyapi " ) )
assert_equal ( " Nonlegacyapi " , ActiveSupport :: Inflector . camelize ( " nonlegacyapi " ) )
end
def test_acronyms_camelize_lower
ActiveSupport :: Inflector . inflections do | inflect |
inflect . acronym ( " API " )
inflect . acronym ( " HTML " )
end
assert_equal ( " htmlAPI " , ActiveSupport :: Inflector . camelize ( " html_api " , false ) )
assert_equal ( " htmlAPI " , ActiveSupport :: Inflector . camelize ( " htmlAPI " , false ) )
assert_equal ( " htmlAPI " , ActiveSupport :: Inflector . camelize ( " HTMLAPI " , false ) )
end
def test_underscore_acronym_sequence
ActiveSupport :: Inflector . inflections do | inflect |
inflect . acronym ( " API " )
2012-07-14 17:01:28 -04:00
inflect . acronym ( " JSON " )
2011-06-09 04:10:49 -04:00
inflect . acronym ( " HTML " )
end
2012-07-14 17:01:28 -04:00
assert_equal ( " json_html_api " , ActiveSupport :: Inflector . underscore ( " JSONHTMLAPI " ) )
2011-06-09 04:10:49 -04:00
end
2004-12-29 16:03:21 -05:00
def test_underscore
CamelToUnderscore . each do | camel , underscore |
2008-06-03 14:32:53 -04:00
assert_equal ( underscore , ActiveSupport :: Inflector . underscore ( camel ) )
2004-12-29 16:03:21 -05:00
end
2005-09-13 03:44:20 -04:00
CamelToUnderscoreWithoutReverse . each do | camel , underscore |
2008-06-03 14:32:53 -04:00
assert_equal ( underscore , ActiveSupport :: Inflector . underscore ( camel ) )
2005-09-13 03:44:20 -04:00
end
2004-12-29 16:03:21 -05:00
end
2005-02-14 20:45:35 -05:00
def test_camelize_with_module
CamelWithModuleToUnderscoreWithSlash . each do | camel , underscore |
2008-06-03 14:32:53 -04:00
assert_equal ( camel , ActiveSupport :: Inflector . camelize ( underscore ) )
2005-02-14 20:45:35 -05:00
end
end
2006-07-08 14:14:49 -04:00
2005-02-14 20:45:35 -05:00
def test_underscore_with_slashes
CamelWithModuleToUnderscoreWithSlash . each do | camel , underscore |
2008-06-03 14:32:53 -04:00
assert_equal ( underscore , ActiveSupport :: Inflector . underscore ( camel ) )
2005-02-14 20:45:35 -05:00
end
end
2004-12-29 16:03:21 -05:00
def test_demodulize
2008-06-03 14:32:53 -04:00
assert_equal " Account " , ActiveSupport :: Inflector . demodulize ( " MyApplication::Billing::Account " )
2011-10-29 04:07:54 -04:00
assert_equal " Account " , ActiveSupport :: Inflector . demodulize ( " Account " )
2014-04-11 08:27:16 -04:00
assert_equal " Account " , ActiveSupport :: Inflector . demodulize ( " ::Account " )
2011-10-29 04:07:54 -04:00
assert_equal " " , ActiveSupport :: Inflector . demodulize ( " " )
2004-12-29 16:03:21 -05:00
end
2011-10-29 21:03:35 -04:00
def test_deconstantize
assert_equal " MyApplication::Billing " , ActiveSupport :: Inflector . deconstantize ( " MyApplication::Billing::Account " )
assert_equal " ::MyApplication::Billing " , ActiveSupport :: Inflector . deconstantize ( " ::MyApplication::Billing::Account " )
assert_equal " MyApplication " , ActiveSupport :: Inflector . deconstantize ( " MyApplication::Billing " )
assert_equal " ::MyApplication " , ActiveSupport :: Inflector . deconstantize ( " ::MyApplication::Billing " )
assert_equal " " , ActiveSupport :: Inflector . deconstantize ( " Account " )
assert_equal " " , ActiveSupport :: Inflector . deconstantize ( " ::Account " )
assert_equal " " , ActiveSupport :: Inflector . deconstantize ( " " )
end
2004-12-29 16:03:21 -05:00
def test_foreign_key
ClassNameToForeignKeyWithUnderscore . each do | klass , foreign_key |
2008-06-03 14:32:53 -04:00
assert_equal ( foreign_key , ActiveSupport :: Inflector . foreign_key ( klass ) )
2004-12-29 16:03:21 -05:00
end
ClassNameToForeignKeyWithoutUnderscore . each do | klass , foreign_key |
2008-06-03 14:32:53 -04:00
assert_equal ( foreign_key , ActiveSupport :: Inflector . foreign_key ( klass , false ) )
2004-12-29 16:03:21 -05:00
end
end
def test_tableize
ClassNameToTableName . each do | class_name , table_name |
2008-06-03 14:32:53 -04:00
assert_equal ( table_name , ActiveSupport :: Inflector . tableize ( class_name ) )
2004-12-29 16:03:21 -05:00
end
end
2008-09-10 01:26:50 -04:00
def test_parameterize
StringToParameterized . each do | some_string , parameterized_string |
assert_equal ( parameterized_string , ActiveSupport :: Inflector . parameterize ( some_string ) )
end
end
2008-11-26 20:59:35 -05:00
def test_parameterize_and_normalize
StringToParameterizedAndNormalized . each do | some_string , parameterized_string |
assert_equal ( parameterized_string , ActiveSupport :: Inflector . parameterize ( some_string ) )
end
end
2008-09-12 08:45:11 -04:00
def test_parameterize_with_custom_separator
2011-06-03 19:07:28 -04:00
StringToParameterizeWithUnderscore . each do | some_string , parameterized_string |
2016-08-06 12:03:25 -04:00
assert_equal ( parameterized_string , ActiveSupport :: Inflector . parameterize ( some_string , separator : " _ " ) )
2015-10-07 08:16:38 -04:00
end
end
2009-03-10 17:36:46 -04:00
def test_parameterize_with_multi_character_separator
StringToParameterized . each do | some_string , parameterized_string |
2016-08-06 12:03:25 -04:00
assert_equal ( parameterized_string . gsub ( " - " , " __sep__ " ) , ActiveSupport :: Inflector . parameterize ( some_string , separator : " __sep__ " ) )
2015-10-07 08:16:38 -04:00
end
end
2004-12-29 16:03:21 -05:00
def test_classify
ClassNameToTableName . each do | class_name , table_name |
2008-06-03 14:32:53 -04:00
assert_equal ( class_name , ActiveSupport :: Inflector . classify ( table_name ) )
assert_equal ( class_name , ActiveSupport :: Inflector . classify ( " table_prefix. " + table_name ) )
2004-12-29 16:03:21 -05:00
end
end
2006-05-22 11:17:45 -04:00
2011-09-08 14:49:08 -04:00
def test_classify_with_symbol
assert_nothing_raised do
2016-08-06 12:03:25 -04:00
assert_equal " FooBar " , ActiveSupport :: Inflector . classify ( :foo_bars )
2011-09-08 14:49:08 -04:00
end
end
2007-01-28 10:52:45 -05:00
def test_classify_with_leading_schema_name
2016-08-06 12:03:25 -04:00
assert_equal " FooBar " , ActiveSupport :: Inflector . classify ( " schema.foo_bar " )
2007-01-28 10:52:45 -05:00
end
2005-01-17 14:53:42 -05:00
def test_humanize
UnderscoreToHuman . each do | underscore , human |
2008-06-03 14:32:53 -04:00
assert_equal ( human , ActiveSupport :: Inflector . humanize ( underscore ) )
2005-01-17 14:53:42 -05:00
end
end
2006-07-08 14:14:49 -04:00
2013-11-06 15:57:21 -05:00
def test_humanize_without_capitalize
UnderscoreToHumanWithoutCapitalize . each do | underscore , human |
assert_equal ( human , ActiveSupport :: Inflector . humanize ( underscore , capitalize : false ) )
end
end
2016-08-07 08:27:47 -04:00
def test_humanize_with_keep_id_suffix
UnderscoreToHumanWithKeepIdSuffix . each do | underscore , human |
assert_equal ( human , ActiveSupport :: Inflector . humanize ( underscore , keep_id_suffix : true ) )
end
end
2008-07-02 08:25:17 -04:00
def test_humanize_by_rule
ActiveSupport :: Inflector . inflections do | inflect |
inflect . human ( / _cnt$ /i , '\1_count' )
inflect . human ( / ^prefx_ /i , '\1' )
end
assert_equal ( " Jargon count " , ActiveSupport :: Inflector . humanize ( " jargon_cnt " ) )
assert_equal ( " Request " , ActiveSupport :: Inflector . humanize ( " prefx_request " ) )
end
def test_humanize_by_string
ActiveSupport :: Inflector . inflections do | inflect |
inflect . human ( " col_rpted_bugs " , " Reported bugs " )
end
assert_equal ( " Reported bugs " , ActiveSupport :: Inflector . humanize ( " col_rpted_bugs " ) )
assert_equal ( " Col rpted bugs " , ActiveSupport :: Inflector . humanize ( " COL_rpted_bugs " ) )
end
2005-02-14 20:45:35 -05:00
def test_constantize
2011-09-22 15:17:42 -04:00
run_constantize_tests_on do | string |
ActiveSupport :: Inflector . constantize ( string )
end
2005-11-15 19:56:16 -05:00
end
2012-02-24 18:06:17 -05:00
2011-09-22 15:17:42 -04:00
def test_safe_constantize
run_safe_constantize_tests_on do | string |
ActiveSupport :: Inflector . safe_constantize ( string )
end
2005-02-14 20:45:35 -05:00
end
2005-07-17 06:02:23 -04:00
def test_ordinal
2011-07-14 11:16:28 -04:00
OrdinalNumbers . each do | number , ordinalized |
assert_equal ( ordinalized , number + ActiveSupport :: Inflector . ordinal ( number ) )
end
end
def test_ordinalize
2005-07-17 06:02:23 -04:00
OrdinalNumbers . each do | number , ordinalized |
2008-06-03 14:32:53 -04:00
assert_equal ( ordinalized , ActiveSupport :: Inflector . ordinalize ( number ) )
2005-07-17 06:02:23 -04:00
end
end
2006-03-07 21:56:25 -05:00
def test_dasherize
UnderscoresToDashes . each do | underscored , dasherized |
2008-06-03 14:32:53 -04:00
assert_equal ( dasherized , ActiveSupport :: Inflector . dasherize ( underscored ) )
2006-03-07 21:56:25 -05:00
end
end
2006-03-15 16:05:10 -05:00
def test_underscore_as_reverse_of_dasherize
2013-03-17 14:49:57 -04:00
UnderscoresToDashes . each_key do | underscored |
2008-06-03 14:32:53 -04:00
assert_equal ( underscored , ActiveSupport :: Inflector . underscore ( ActiveSupport :: Inflector . dasherize ( underscored ) ) )
2006-03-15 16:05:10 -05:00
end
end
2006-03-19 22:32:28 -05:00
def test_underscore_to_lower_camel
UnderscoreToLowerCamel . each do | underscored , lower_camel |
2008-06-03 14:32:53 -04:00
assert_equal ( lower_camel , ActiveSupport :: Inflector . camelize ( underscored , false ) )
2006-03-19 22:32:28 -05:00
end
end
2008-06-03 14:32:53 -04:00
2011-09-08 14:49:08 -04:00
def test_symbol_to_lower_camel
SymbolToLowerCamel . each do | symbol , lower_camel |
assert_equal ( lower_camel , ActiveSupport :: Inflector . camelize ( symbol , false ) )
end
end
2008-07-02 08:25:17 -04:00
%w{ plurals singulars uncountables humans } . each do | inflection_type |
2010-05-19 15:37:41 -04:00
class_eval <<-RUBY, __FILE__, __LINE__ + 1
2007-01-23 00:32:08 -05:00
def test_clear_ #{inflection_type}
2015-06-14 23:46:18 -04:00
ActiveSupport :: Inflector . inflections . clear : #{inflection_type}
assert ActiveSupport :: Inflector . inflections . #{inflection_type}.empty?, \"#{inflection_type} inflections should be empty after clear :#{inflection_type}\"
2007-01-23 00:32:08 -05:00
end
2010-05-19 15:37:41 -04:00
RUBY
2007-01-23 00:32:08 -05:00
end
2008-06-03 14:32:53 -04:00
Make ActiveSupport::Inflector locale aware and multilingual
The Inflector is currently not very supportive of internationalized
websites. If a user wants to singularize and/or pluralize words based on
any locale other than English, they must define each case in locale
files. Rather than create large locale files with mappings between
singular and plural words, why not allow the Inflector to accept a
locale?
This patch makes ActiveSupport::Inflector locale aware and uses `:en`` unless
otherwise specified. Users will still be provided a list of English (:en)
inflections, but they may additionally define inflection rules for other
locales. Each list is kept separately and permanently. There is no reason to
limit users to one list of inflections:
ActiveSupport::Inflector.inflections(:es) do |inflect|
inflect.plural(/$/, 's')
inflect.plural(/([^aeéiou])$/i, '\1es')
inflect.plural(/([aeiou]s)$/i, '\1')
inflect.plural(/z$/i, 'ces')
inflect.plural(/á([sn])$/i, 'a\1es')
inflect.plural(/é([sn])$/i, 'e\1es')
inflect.plural(/í([sn])$/i, 'i\1es')
inflect.plural(/ó([sn])$/i, 'o\1es')
inflect.plural(/ú([sn])$/i, 'u\1es')
inflect.singular(/s$/, '')
inflect.singular(/es$/, '')
inflect.irregular('el', 'los')
end
'ley'.pluralize(:es) # => "leyes"
'ley'.pluralize(:en) # => "leys"
'avión'.pluralize(:es) # => "aviones"
'avión'.pluralize(:en) # => "avións"
A multilingual Inflector should be of use to anybody that is tasked with
internationalizing their Rails application.
Signed-off-by: David Celis <david@davidcelis.com>
2012-07-29 18:31:53 -04:00
def test_inflector_locality
ActiveSupport :: Inflector . inflections ( :es ) do | inflect |
2016-08-06 12:03:25 -04:00
inflect . plural ( / $ / , " s " )
inflect . plural ( / z$ /i , " ces " )
Make ActiveSupport::Inflector locale aware and multilingual
The Inflector is currently not very supportive of internationalized
websites. If a user wants to singularize and/or pluralize words based on
any locale other than English, they must define each case in locale
files. Rather than create large locale files with mappings between
singular and plural words, why not allow the Inflector to accept a
locale?
This patch makes ActiveSupport::Inflector locale aware and uses `:en`` unless
otherwise specified. Users will still be provided a list of English (:en)
inflections, but they may additionally define inflection rules for other
locales. Each list is kept separately and permanently. There is no reason to
limit users to one list of inflections:
ActiveSupport::Inflector.inflections(:es) do |inflect|
inflect.plural(/$/, 's')
inflect.plural(/([^aeéiou])$/i, '\1es')
inflect.plural(/([aeiou]s)$/i, '\1')
inflect.plural(/z$/i, 'ces')
inflect.plural(/á([sn])$/i, 'a\1es')
inflect.plural(/é([sn])$/i, 'e\1es')
inflect.plural(/í([sn])$/i, 'i\1es')
inflect.plural(/ó([sn])$/i, 'o\1es')
inflect.plural(/ú([sn])$/i, 'u\1es')
inflect.singular(/s$/, '')
inflect.singular(/es$/, '')
inflect.irregular('el', 'los')
end
'ley'.pluralize(:es) # => "leyes"
'ley'.pluralize(:en) # => "leys"
'avión'.pluralize(:es) # => "aviones"
'avión'.pluralize(:en) # => "avións"
A multilingual Inflector should be of use to anybody that is tasked with
internationalizing their Rails application.
Signed-off-by: David Celis <david@davidcelis.com>
2012-07-29 18:31:53 -04:00
2016-08-06 12:03:25 -04:00
inflect . singular ( / s$ / , " " )
inflect . singular ( / es$ / , " " )
2013-01-03 21:14:57 -05:00
2016-08-06 12:03:25 -04:00
inflect . irregular ( " el " , " los " )
2017-05-09 17:50:47 -04:00
inflect . uncountable ( " agua " )
Make ActiveSupport::Inflector locale aware and multilingual
The Inflector is currently not very supportive of internationalized
websites. If a user wants to singularize and/or pluralize words based on
any locale other than English, they must define each case in locale
files. Rather than create large locale files with mappings between
singular and plural words, why not allow the Inflector to accept a
locale?
This patch makes ActiveSupport::Inflector locale aware and uses `:en`` unless
otherwise specified. Users will still be provided a list of English (:en)
inflections, but they may additionally define inflection rules for other
locales. Each list is kept separately and permanently. There is no reason to
limit users to one list of inflections:
ActiveSupport::Inflector.inflections(:es) do |inflect|
inflect.plural(/$/, 's')
inflect.plural(/([^aeéiou])$/i, '\1es')
inflect.plural(/([aeiou]s)$/i, '\1')
inflect.plural(/z$/i, 'ces')
inflect.plural(/á([sn])$/i, 'a\1es')
inflect.plural(/é([sn])$/i, 'e\1es')
inflect.plural(/í([sn])$/i, 'i\1es')
inflect.plural(/ó([sn])$/i, 'o\1es')
inflect.plural(/ú([sn])$/i, 'u\1es')
inflect.singular(/s$/, '')
inflect.singular(/es$/, '')
inflect.irregular('el', 'los')
end
'ley'.pluralize(:es) # => "leyes"
'ley'.pluralize(:en) # => "leys"
'avión'.pluralize(:es) # => "aviones"
'avión'.pluralize(:en) # => "avións"
A multilingual Inflector should be of use to anybody that is tasked with
internationalizing their Rails application.
Signed-off-by: David Celis <david@davidcelis.com>
2012-07-29 18:31:53 -04:00
end
2016-08-06 12:03:25 -04:00
assert_equal ( " hijos " , " hijo " . pluralize ( :es ) )
assert_equal ( " luces " , " luz " . pluralize ( :es ) )
assert_equal ( " luzs " , " luz " . pluralize )
Make ActiveSupport::Inflector locale aware and multilingual
The Inflector is currently not very supportive of internationalized
websites. If a user wants to singularize and/or pluralize words based on
any locale other than English, they must define each case in locale
files. Rather than create large locale files with mappings between
singular and plural words, why not allow the Inflector to accept a
locale?
This patch makes ActiveSupport::Inflector locale aware and uses `:en`` unless
otherwise specified. Users will still be provided a list of English (:en)
inflections, but they may additionally define inflection rules for other
locales. Each list is kept separately and permanently. There is no reason to
limit users to one list of inflections:
ActiveSupport::Inflector.inflections(:es) do |inflect|
inflect.plural(/$/, 's')
inflect.plural(/([^aeéiou])$/i, '\1es')
inflect.plural(/([aeiou]s)$/i, '\1')
inflect.plural(/z$/i, 'ces')
inflect.plural(/á([sn])$/i, 'a\1es')
inflect.plural(/é([sn])$/i, 'e\1es')
inflect.plural(/í([sn])$/i, 'i\1es')
inflect.plural(/ó([sn])$/i, 'o\1es')
inflect.plural(/ú([sn])$/i, 'u\1es')
inflect.singular(/s$/, '')
inflect.singular(/es$/, '')
inflect.irregular('el', 'los')
end
'ley'.pluralize(:es) # => "leyes"
'ley'.pluralize(:en) # => "leys"
'avión'.pluralize(:es) # => "aviones"
'avión'.pluralize(:en) # => "avións"
A multilingual Inflector should be of use to anybody that is tasked with
internationalizing their Rails application.
Signed-off-by: David Celis <david@davidcelis.com>
2012-07-29 18:31:53 -04:00
2016-08-06 12:03:25 -04:00
assert_equal ( " sociedad " , " sociedades " . singularize ( :es ) )
assert_equal ( " sociedade " , " sociedades " . singularize )
Make ActiveSupport::Inflector locale aware and multilingual
The Inflector is currently not very supportive of internationalized
websites. If a user wants to singularize and/or pluralize words based on
any locale other than English, they must define each case in locale
files. Rather than create large locale files with mappings between
singular and plural words, why not allow the Inflector to accept a
locale?
This patch makes ActiveSupport::Inflector locale aware and uses `:en`` unless
otherwise specified. Users will still be provided a list of English (:en)
inflections, but they may additionally define inflection rules for other
locales. Each list is kept separately and permanently. There is no reason to
limit users to one list of inflections:
ActiveSupport::Inflector.inflections(:es) do |inflect|
inflect.plural(/$/, 's')
inflect.plural(/([^aeéiou])$/i, '\1es')
inflect.plural(/([aeiou]s)$/i, '\1')
inflect.plural(/z$/i, 'ces')
inflect.plural(/á([sn])$/i, 'a\1es')
inflect.plural(/é([sn])$/i, 'e\1es')
inflect.plural(/í([sn])$/i, 'i\1es')
inflect.plural(/ó([sn])$/i, 'o\1es')
inflect.plural(/ú([sn])$/i, 'u\1es')
inflect.singular(/s$/, '')
inflect.singular(/es$/, '')
inflect.irregular('el', 'los')
end
'ley'.pluralize(:es) # => "leyes"
'ley'.pluralize(:en) # => "leys"
'avión'.pluralize(:es) # => "aviones"
'avión'.pluralize(:en) # => "avións"
A multilingual Inflector should be of use to anybody that is tasked with
internationalizing their Rails application.
Signed-off-by: David Celis <david@davidcelis.com>
2012-07-29 18:31:53 -04:00
2016-08-06 12:03:25 -04:00
assert_equal ( " los " , " el " . pluralize ( :es ) )
assert_equal ( " els " , " el " . pluralize )
Make ActiveSupport::Inflector locale aware and multilingual
The Inflector is currently not very supportive of internationalized
websites. If a user wants to singularize and/or pluralize words based on
any locale other than English, they must define each case in locale
files. Rather than create large locale files with mappings between
singular and plural words, why not allow the Inflector to accept a
locale?
This patch makes ActiveSupport::Inflector locale aware and uses `:en`` unless
otherwise specified. Users will still be provided a list of English (:en)
inflections, but they may additionally define inflection rules for other
locales. Each list is kept separately and permanently. There is no reason to
limit users to one list of inflections:
ActiveSupport::Inflector.inflections(:es) do |inflect|
inflect.plural(/$/, 's')
inflect.plural(/([^aeéiou])$/i, '\1es')
inflect.plural(/([aeiou]s)$/i, '\1')
inflect.plural(/z$/i, 'ces')
inflect.plural(/á([sn])$/i, 'a\1es')
inflect.plural(/é([sn])$/i, 'e\1es')
inflect.plural(/í([sn])$/i, 'i\1es')
inflect.plural(/ó([sn])$/i, 'o\1es')
inflect.plural(/ú([sn])$/i, 'u\1es')
inflect.singular(/s$/, '')
inflect.singular(/es$/, '')
inflect.irregular('el', 'los')
end
'ley'.pluralize(:es) # => "leyes"
'ley'.pluralize(:en) # => "leys"
'avión'.pluralize(:es) # => "aviones"
'avión'.pluralize(:en) # => "avións"
A multilingual Inflector should be of use to anybody that is tasked with
internationalizing their Rails application.
Signed-off-by: David Celis <david@davidcelis.com>
2012-07-29 18:31:53 -04:00
2017-05-09 17:50:47 -04:00
assert_equal ( " agua " , " agua " . pluralize ( :es ) )
assert_equal ( " aguas " , " agua " . pluralize )
Make ActiveSupport::Inflector locale aware and multilingual
The Inflector is currently not very supportive of internationalized
websites. If a user wants to singularize and/or pluralize words based on
any locale other than English, they must define each case in locale
files. Rather than create large locale files with mappings between
singular and plural words, why not allow the Inflector to accept a
locale?
This patch makes ActiveSupport::Inflector locale aware and uses `:en`` unless
otherwise specified. Users will still be provided a list of English (:en)
inflections, but they may additionally define inflection rules for other
locales. Each list is kept separately and permanently. There is no reason to
limit users to one list of inflections:
ActiveSupport::Inflector.inflections(:es) do |inflect|
inflect.plural(/$/, 's')
inflect.plural(/([^aeéiou])$/i, '\1es')
inflect.plural(/([aeiou]s)$/i, '\1')
inflect.plural(/z$/i, 'ces')
inflect.plural(/á([sn])$/i, 'a\1es')
inflect.plural(/é([sn])$/i, 'e\1es')
inflect.plural(/í([sn])$/i, 'i\1es')
inflect.plural(/ó([sn])$/i, 'o\1es')
inflect.plural(/ú([sn])$/i, 'u\1es')
inflect.singular(/s$/, '')
inflect.singular(/es$/, '')
inflect.irregular('el', 'los')
end
'ley'.pluralize(:es) # => "leyes"
'ley'.pluralize(:en) # => "leys"
'avión'.pluralize(:es) # => "aviones"
'avión'.pluralize(:en) # => "avións"
A multilingual Inflector should be of use to anybody that is tasked with
internationalizing their Rails application.
Signed-off-by: David Celis <david@davidcelis.com>
2012-07-29 18:31:53 -04:00
ActiveSupport :: Inflector . inflections ( :es ) { | inflect | inflect . clear }
assert ActiveSupport :: Inflector . inflections ( :es ) . plurals . empty?
assert ActiveSupport :: Inflector . inflections ( :es ) . singulars . empty?
2017-05-09 17:50:47 -04:00
assert ActiveSupport :: Inflector . inflections ( :es ) . uncountables . empty?
Make ActiveSupport::Inflector locale aware and multilingual
The Inflector is currently not very supportive of internationalized
websites. If a user wants to singularize and/or pluralize words based on
any locale other than English, they must define each case in locale
files. Rather than create large locale files with mappings between
singular and plural words, why not allow the Inflector to accept a
locale?
This patch makes ActiveSupport::Inflector locale aware and uses `:en`` unless
otherwise specified. Users will still be provided a list of English (:en)
inflections, but they may additionally define inflection rules for other
locales. Each list is kept separately and permanently. There is no reason to
limit users to one list of inflections:
ActiveSupport::Inflector.inflections(:es) do |inflect|
inflect.plural(/$/, 's')
inflect.plural(/([^aeéiou])$/i, '\1es')
inflect.plural(/([aeiou]s)$/i, '\1')
inflect.plural(/z$/i, 'ces')
inflect.plural(/á([sn])$/i, 'a\1es')
inflect.plural(/é([sn])$/i, 'e\1es')
inflect.plural(/í([sn])$/i, 'i\1es')
inflect.plural(/ó([sn])$/i, 'o\1es')
inflect.plural(/ú([sn])$/i, 'u\1es')
inflect.singular(/s$/, '')
inflect.singular(/es$/, '')
inflect.irregular('el', 'los')
end
'ley'.pluralize(:es) # => "leyes"
'ley'.pluralize(:en) # => "leys"
'avión'.pluralize(:es) # => "aviones"
'avión'.pluralize(:en) # => "avións"
A multilingual Inflector should be of use to anybody that is tasked with
internationalizing their Rails application.
Signed-off-by: David Celis <david@davidcelis.com>
2012-07-29 18:31:53 -04:00
assert ! ActiveSupport :: Inflector . inflections . plurals . empty?
assert ! ActiveSupport :: Inflector . inflections . singulars . empty?
2017-05-09 17:50:47 -04:00
assert ! ActiveSupport :: Inflector . inflections . uncountables . empty?
Make ActiveSupport::Inflector locale aware and multilingual
The Inflector is currently not very supportive of internationalized
websites. If a user wants to singularize and/or pluralize words based on
any locale other than English, they must define each case in locale
files. Rather than create large locale files with mappings between
singular and plural words, why not allow the Inflector to accept a
locale?
This patch makes ActiveSupport::Inflector locale aware and uses `:en`` unless
otherwise specified. Users will still be provided a list of English (:en)
inflections, but they may additionally define inflection rules for other
locales. Each list is kept separately and permanently. There is no reason to
limit users to one list of inflections:
ActiveSupport::Inflector.inflections(:es) do |inflect|
inflect.plural(/$/, 's')
inflect.plural(/([^aeéiou])$/i, '\1es')
inflect.plural(/([aeiou]s)$/i, '\1')
inflect.plural(/z$/i, 'ces')
inflect.plural(/á([sn])$/i, 'a\1es')
inflect.plural(/é([sn])$/i, 'e\1es')
inflect.plural(/í([sn])$/i, 'i\1es')
inflect.plural(/ó([sn])$/i, 'o\1es')
inflect.plural(/ú([sn])$/i, 'u\1es')
inflect.singular(/s$/, '')
inflect.singular(/es$/, '')
inflect.irregular('el', 'los')
end
'ley'.pluralize(:es) # => "leyes"
'ley'.pluralize(:en) # => "leys"
'avión'.pluralize(:es) # => "aviones"
'avión'.pluralize(:en) # => "avións"
A multilingual Inflector should be of use to anybody that is tasked with
internationalizing their Rails application.
Signed-off-by: David Celis <david@davidcelis.com>
2012-07-29 18:31:53 -04:00
end
2007-01-23 00:32:08 -05:00
def test_clear_all
2015-06-14 23:46:18 -04:00
ActiveSupport :: Inflector . inflections do | inflect |
# ensure any data is present
inflect . plural ( / (quiz)$ /i , '\1zes' )
inflect . singular ( / (database)s$ /i , '\1' )
2016-08-06 12:03:25 -04:00
inflect . uncountable ( " series " )
2015-06-14 23:46:18 -04:00
inflect . human ( " col_rpted_bugs " , " Reported bugs " )
inflect . clear :all
assert inflect . plurals . empty?
assert inflect . singulars . empty?
assert inflect . uncountables . empty?
assert inflect . humans . empty?
2011-04-24 21:17:22 -04:00
end
2008-06-03 14:32:53 -04:00
end
2007-01-23 00:32:08 -05:00
def test_clear_with_default
2015-06-14 23:46:18 -04:00
ActiveSupport :: Inflector . inflections do | inflect |
# ensure any data is present
inflect . plural ( / (quiz)$ /i , '\1zes' )
inflect . singular ( / (database)s$ /i , '\1' )
2016-08-06 12:03:25 -04:00
inflect . uncountable ( " series " )
2015-06-14 23:46:18 -04:00
inflect . human ( " col_rpted_bugs " , " Reported bugs " )
inflect . clear
assert inflect . plurals . empty?
assert inflect . singulars . empty?
assert inflect . uncountables . empty?
assert inflect . humans . empty?
2011-04-24 21:17:22 -04:00
end
2007-01-23 00:32:08 -05:00
end
2007-01-28 10:52:45 -05:00
2013-07-30 07:01:56 -04:00
Irregularities . each do | singular , plural |
define_method ( " test_irregularity_between_ #{ singular } _and_ #{ plural } " ) do
2015-06-14 23:46:18 -04:00
ActiveSupport :: Inflector . inflections do | inflect |
inflect . irregular ( singular , plural )
assert_equal singular , ActiveSupport :: Inflector . singularize ( plural )
assert_equal plural , ActiveSupport :: Inflector . pluralize ( singular )
2007-01-28 10:52:45 -05:00
end
end
end
2013-07-30 07:01:56 -04:00
Irregularities . each do | singular , plural |
define_method ( " test_pluralize_of_irregularity_ #{ plural } _should_be_the_same " ) do
2015-06-14 23:46:18 -04:00
ActiveSupport :: Inflector . inflections do | inflect |
inflect . irregular ( singular , plural )
assert_equal plural , ActiveSupport :: Inflector . pluralize ( plural )
2008-07-04 03:04:50 -04:00
end
end
end
2013-07-30 07:01:56 -04:00
Irregularities . each do | singular , plural |
define_method ( " test_singularize_of_irregularity_ #{ singular } _should_be_the_same " ) do
2015-06-14 23:46:18 -04:00
ActiveSupport :: Inflector . inflections do | inflect |
inflect . irregular ( singular , plural )
assert_equal singular , ActiveSupport :: Inflector . singularize ( singular )
2012-06-21 05:16:48 -04:00
end
end
end
2007-01-28 10:52:45 -05:00
[ :all , [ ] ] . each do | scope |
2008-06-03 14:32:53 -04:00
ActiveSupport :: Inflector . inflections do | inflect |
2007-01-28 10:52:45 -05:00
define_method ( " test_clear_inflections_with_ #{ scope . kind_of? ( Array ) ? " no_arguments " : scope } " ) do
# save all the inflections
singulars , plurals , uncountables = inflect . singulars , inflect . plurals , inflect . uncountables
# clear all the inflections
inflect . clear ( * scope )
assert_equal [ ] , inflect . singulars
assert_equal [ ] , inflect . plurals
assert_equal [ ] , inflect . uncountables
# restore all the inflections
2014-10-13 06:47:16 -04:00
singulars . reverse_each { | singular | inflect . singular ( * singular ) }
plurals . reverse_each { | plural | inflect . plural ( * plural ) }
2007-01-28 10:52:45 -05:00
inflect . uncountable ( uncountables )
assert_equal singulars , inflect . singulars
assert_equal plurals , inflect . plurals
assert_equal uncountables , inflect . uncountables
end
end
end
2012-02-24 18:06:17 -05:00
%w( plurals singulars uncountables humans acronyms ) . each do | scope |
2014-05-25 12:06:02 -04:00
define_method ( " test_clear_inflections_with_ #{ scope } " ) do
2015-06-14 23:46:18 -04:00
# clear the inflections
ActiveSupport :: Inflector . inflections do | inflect |
inflect . clear ( scope )
assert_equal [ ] , inflect . send ( scope )
2007-01-28 10:52:45 -05:00
end
end
end
2005-07-17 06:02:23 -04:00
end