Parameterize with options to preserve case of string

Added test cases

Using kwargs instead of three seperate functions

Updated parameterize in transliterate.rb

Updated parameterize in transliterate.rb

Added deprecation warnings and updating RDoc+Guide

Misspelled separtor. Fixed.

Deprecated test cases and added support to parameterize with keyword parameters

Squashing commits.

Fixed test cases and added deprecated test cases

Small changes to Gemfile.lock and CHANGELOG

Update Gemfile.lock

7 files changed, 156 insertions, 14 deletions

diff --git a/activesupport/CHANGELOG.md b/activesupport/CHANGELOG.md
index 7c0f3eae80..d505218c7a 100644
--- a/activesupport/CHANGELOG.md
+++ b/activesupport/CHANGELOG.md
@@ -1,3 +1,12 @@
+* Updated `parameterize` to preserve the case of a string, optionally.
+
+    Example:
+
+      parameterize("Donald E. Knuth", separator: '_') # => "donald_e_knuth"
+      parameterize("Donald E. Knuth", preserve_case: true) # => "Donald-E-Knuth"
+
+    *Swaathi Kakarla*
+
 *   `HashWithIndifferentAccess.new` respects the default value or proc on objects
     that respond to `#to_hash`. `.new_from_hash_copying_default` simply invokes `.new`.
     All calls to `.new_from_hash_copying_default` are replaced with `.new`.
diff --git a/activesupport/lib/active_support/core_ext/string/inflections.rb b/activesupport/lib/active_support/core_ext/string/inflections.rb
index b2e713077c..cc71b8155d 100644
--- a/activesupport/lib/active_support/core_ext/string/inflections.rb
+++ b/activesupport/lib/active_support/core_ext/string/inflections.rb
@@ -164,8 +164,26 @@ class String
   #
   #   <%= link_to(@person.name, person_path) %>
   #   # => <a href="/person/1-donald-e-knuth">Donald E. Knuth</a>
-  def parameterize(sep = '-'.freeze)
-    ActiveSupport::Inflector.parameterize(self, sep)
+  #   
+  # To preserve the case of the characters in a string, use the `preserve_case` argument.
+  #
+  #   class Person
+  #     def to_param
+  #       "#{id}-#{name.parameterize(preserve_case: true)}"
+  #     end
+  #   end
+  #
+  #   @person = Person.find(1)
+  #   # => #<Person id: 1, name: "Donald E. Knuth">
+  #
+  #   <%= link_to(@person.name, person_path) %>
+  #   # => <a href="/person/1-Donald-E-Knuth">Donald E. Knuth</a>
+  def parameterize(sep = :unused, separator: '-', preserve_case: false)
+    unless sep == :unused
+      ActiveSupport::Deprecation.warn("Passing the separator argument as a positional parameter is deprecated and will soon be removed. Use `separator: '#{sep}'` instead.")
+      separator = sep
+    end
+    ActiveSupport::Inflector.parameterize(self, separator: separator, preserve_case: preserve_case)
   end
 
   # Creates the name of a table like Rails does for models to table names. This method
diff --git a/activesupport/lib/active_support/inflector/transliterate.rb b/activesupport/lib/active_support/inflector/transliterate.rb
index 103207fb63..871cfb8a72 100644
--- a/activesupport/lib/active_support/inflector/transliterate.rb
+++ b/activesupport/lib/active_support/inflector/transliterate.rb
@@ -68,29 +68,44 @@ module ActiveSupport
     #
     #   parameterize("Donald E. Knuth") # => "donald-e-knuth"
     #   parameterize("^trés|Jolie-- ")  # => "tres-jolie"
-    def parameterize(string, sep = '-')
+    #
+    # To use a custom separator, override the `separator` argument.
+    #
+    #  parameterize("Donald E. Knuth", separator: '_') # => "donald_e_knuth"
+    #  parameterize("^trés|Jolie-- ", separator: '_')  # => "tres_jolie"
+    #
+    # To preserve the case of the characters in a string, use the `preserve_case` argument.
+    #
+    #   parameterize("Donald E. Knuth", preserve_case: true) # => "Donald-E-Knuth"
+    #   parameterize("^trés|Jolie-- ", preserve_case: true) # => "tres-Jolie"
+    #
+    def parameterize(string, sep = :unused, separator: '-', preserve_case: false)
+      unless sep == :unused
+        ActiveSupport::Deprecation.warn("Passing the separator argument as a positional parameter is deprecated and will soon be removed. Use `separator: '#{sep}'` instead.")
+        separator = sep
+      end
       # Replace accented chars with their ASCII equivalents.
       parameterized_string = transliterate(string)
 
       # Turn unwanted chars into the separator.
-      parameterized_string.gsub!(/[^a-z0-9\-_]+/i, sep)
+      parameterized_string.gsub!(/[^a-z0-9\-_]+/i, separator)
 
-      unless sep.nil? || sep.empty?
-        if sep == "-".freeze
+      unless separator.nil? || separator.empty?
+        if separator == "-".freeze
           re_duplicate_separator        = /-{2,}/
           re_leading_trailing_separator = /^-|-$/i
         else
-          re_sep = Regexp.escape(sep)
+          re_sep = Regexp.escape(separator)
           re_duplicate_separator        = /#{re_sep}{2,}/
           re_leading_trailing_separator = /^#{re_sep}|#{re_sep}$/i
         end
         # No more than one of the separator in a row.
-        parameterized_string.gsub!(re_duplicate_separator, sep)
+        parameterized_string.gsub!(re_duplicate_separator, separator)
         # Remove leading/trailing separator.
         parameterized_string.gsub!(re_leading_trailing_separator, ''.freeze)
       end
-
-      parameterized_string.downcase!
+      
+      parameterized_string.downcase! unless preserve_case
       parameterized_string
     end
   end
diff --git a/activesupport/test/core_ext/string_ext_test.rb b/activesupport/test/core_ext/string_ext_test.rb
index 9cc7bb1a77..2e69816364 100644
--- a/activesupport/test/core_ext/string_ext_test.rb
+++ b/activesupport/test/core_ext/string_ext_test.rb
@@ -143,15 +143,49 @@ class StringInflectionsTest < ActiveSupport::TestCase
     end
   end
 
+  def test_string_parameterized_normal_preserve_case
+    StringToParameterizedPreserveCase.each do |normal, slugged|
+      assert_equal(normal.parameterize(preserve_case: true), slugged)
+    end
+  end
+
   def test_string_parameterized_no_separator
     StringToParameterizeWithNoSeparator.each do |normal, slugged|
-      assert_equal(normal.parameterize(''), slugged)
+      assert_equal(normal.parameterize(separator: ''), slugged)
+    end
+  end
+
+  def test_string_parameterized_no_separator_deprecated
+    StringToParameterizeWithNoSeparator.each do |normal, slugged|
+      assert_deprecated(/Passing the separator argument as a positional parameter is deprecated and will soon be removed. Use `separator: ''` instead./i) do
+        assert_equal(normal.parameterize(''), slugged)
+      end
+    end
+  end
+
+  def test_string_parameterized_no_separator_preserve_case
+    StringToParameterizePreserveCaseWithNoSeparator.each do |normal, slugged|
+      assert_equal(normal.parameterize(separator: '', preserve_case: true), slugged)
     end
   end
 
   def test_string_parameterized_underscore
     StringToParameterizeWithUnderscore.each do |normal, slugged|
-      assert_equal(normal.parameterize('_'), slugged)
+      assert_equal(normal.parameterize(separator: '_'), slugged)
+    end
+  end
+
+  def test_string_parameterized_underscore_deprecated
+    StringToParameterizeWithUnderscore.each do |normal, slugged|
+      assert_deprecated(/Passing the separator argument as a positional parameter is deprecated and will soon be removed. Use `separator: '_'` instead./i) do
+        assert_equal(normal.parameterize('_'), slugged)
+      end
+    end
+  end
+
+  def test_string_parameterized_underscore_preserve_case
+    StringToParameterizePreserceCaseWithUnderscore.each do |normal, slugged|
+      assert_equal(normal.parameterize(separator: '_', preserve_case: true), slugged)
     end
   end
 
diff --git a/activesupport/test/inflector_test.rb b/activesupport/test/inflector_test.rb
index a0764f6d6b..06cd41c86d 100644
--- a/activesupport/test/inflector_test.rb
+++ b/activesupport/test/inflector_test.rb
@@ -269,14 +269,32 @@ class InflectorTest < ActiveSupport::TestCase
   def test_parameterize_with_custom_separator
     jruby_skip "UTF-8 to UTF8-MAC Converter is unavailable"
     StringToParameterizeWithUnderscore.each do |some_string, parameterized_string|
-      assert_equal(parameterized_string, ActiveSupport::Inflector.parameterize(some_string, '_'))
+      assert_equal(parameterized_string, ActiveSupport::Inflector.parameterize(some_string, separator: '_'))
+    end
+  end
+
+  def test_parameterize_with_custom_separator_deprecated
+    jruby_skip "UTF-8 to UTF8-MAC Converter is unavailable"
+    StringToParameterizeWithUnderscore.each do |some_string, parameterized_string|
+      assert_deprecated(/Passing the separator argument as a positional parameter is deprecated and will soon be removed. Use `separator: '_'` instead./i) do
+        assert_equal(parameterized_string, ActiveSupport::Inflector.parameterize(some_string, '_'))
+      end
     end
   end
 
   def test_parameterize_with_multi_character_separator
     jruby_skip "UTF-8 to UTF8-MAC Converter is unavailable"
     StringToParameterized.each do |some_string, parameterized_string|
-      assert_equal(parameterized_string.gsub('-', '__sep__'), ActiveSupport::Inflector.parameterize(some_string, '__sep__'))
+      assert_equal(parameterized_string.gsub('-', '__sep__'), ActiveSupport::Inflector.parameterize(some_string, separator: '__sep__'))
+    end
+  end
+
+  def test_parameterize_with_multi_character_separator_deprecated
+    jruby_skip "UTF-8 to UTF8-MAC Converter is unavailable"
+    StringToParameterized.each do |some_string, parameterized_string|
+      assert_deprecated(/Passing the separator argument as a positional parameter is deprecated and will soon be removed. Use `separator: '__sep__'` instead./i) do
+        assert_equal(parameterized_string.gsub('-', '__sep__'), ActiveSupport::Inflector.parameterize(some_string, '__sep__'))
+      end
     end
   end
 
diff --git a/activesupport/test/inflector_test_cases.rb b/activesupport/test/inflector_test_cases.rb
index e6898658b5..14fe97a986 100644
--- a/activesupport/test/inflector_test_cases.rb
+++ b/activesupport/test/inflector_test_cases.rb
@@ -174,6 +174,17 @@ module InflectorTestCases
     "Test with malformed utf8 \251"       => "test-with-malformed-utf8"
   }
 
+  StringToParameterizedPreserveCase = {
+    "Donald E. Knuth"                     => "Donald-E-Knuth",
+    "Random text with *(bad)* characters" => "Random-text-with-bad-characters", 
+    "Allow_Under_Scores"                  => "Allow_Under_Scores", 
+    "Trailing bad characters!@#"          => "Trailing-bad-characters", 
+    "!@#Leading bad characters"           => "Leading-bad-characters", 
+    "Squeeze   separators"                => "Squeeze-separators", 
+    "Test with + sign"                    => "Test-with-sign", 
+    "Test with malformed utf8 \xA9"       => "Test-with-malformed-utf8"
+  }
+
   StringToParameterizeWithNoSeparator = {
     "Donald E. Knuth"                     => "donaldeknuth",
     "With-some-dashes"                    => "with-some-dashes",
@@ -185,6 +196,17 @@ module InflectorTestCases
     "Test with malformed utf8 \251"       => "testwithmalformedutf8"
   }
 
+  StringToParameterizePreserveCaseWithNoSeparator = {
+    "Donald E. Knuth"                     => "DonaldEKnuth",
+    "With-some-dashes"                    => "With-some-dashes",
+    "Random text with *(bad)* characters" => "Randomtextwithbadcharacters", 
+    "Trailing bad characters!@#"          => "Trailingbadcharacters", 
+    "!@#Leading bad characters"           => "Leadingbadcharacters", 
+    "Squeeze   separators"                => "Squeezeseparators", 
+    "Test with + sign"                    => "Testwithsign", 
+    "Test with malformed utf8 \xA9"       => "Testwithmalformedutf8"
+  }
+
   StringToParameterizeWithUnderscore = {
     "Donald E. Knuth"                     => "donald_e_knuth",
     "Random text with *(bad)* characters" => "random_text_with_bad_characters",
@@ -197,6 +219,18 @@ module InflectorTestCases
     "Test with malformed utf8 \251"       => "test_with_malformed_utf8"
   }
 
+  StringToParameterizePreserceCaseWithUnderscore = {
+    "Donald E. Knuth"                     => "Donald_E_Knuth", 
+    "Random text with *(bad)* characters" => "Random_text_with_bad_characters",
+    "With-some-dashes"                    => "With-some-dashes", 
+    "Allow_Under_Scores"                  => "Allow_Under_Scores", 
+    "Trailing bad characters!@#"          => "Trailing_bad_characters", 
+    "!@#Leading bad characters"           => "Leading_bad_characters", 
+    "Squeeze   separators"                => "Squeeze_separators", 
+    "Test with + sign"                    => "Test_with_sign", 
+    "Test with malformed utf8 \xA9"       => "Test_with_malformed_utf8"
+  }
+
   StringToParameterizedAndNormalized = {
     "Malmö"                               => "malmo",
     "Garçons"                             => "garcons",
diff --git a/guides/source/active_support_core_extensions.md b/guides/source/active_support_core_extensions.md
index f6fc255c24..181dca4b71 100644
--- a/guides/source/active_support_core_extensions.md
+++ b/guides/source/active_support_core_extensions.md
@@ -1710,6 +1710,20 @@ The method `parameterize` normalizes its receiver in a way that can be used in p
 "Kurt Gödel".parameterize # => "kurt-godel"
 ```
 
+To preserve the case of the string, set the `preserve_case` argument to true. By default, `preserve_case` is set to false.
+
+```ruby
+"John Smith".parameterize(preserve_case: true) # => "John-Smith"
+"Kurt Gödel".parameterize(preserve_case: true) # => "Kurt-Godel"
+```
+
+To use a custom separator, override the `separator` argument.
+
+```ruby
+"John Smith".parameterize(separator: "_") # => "john\_smith"
+"Kurt Gödel".parameterize(separator: "_") # => "kurt\_godel"
+```
+
 In fact, the result string is wrapped in an instance of `ActiveSupport::Multibyte::Chars`.
 
 NOTE: Defined in `active_support/core_ext/string/inflections.rb`.