caseconverter 0.1.0 → 0.1.1

data/lib/case_converter.rb

@@ -1,25 +1,77 @@
+# CaseConverter - A module that converts to and from different casings.
+#
+# ==Class Methods
+# For example:
+#  require 'caseconverter'
+#  
+#  CaseConverter.to_underscore_case('TestTheCasing')
+#  # returns 'test_the_casing'
+#
+# This module support conversion to UpperCamelCase, lowerCamelCase,
+# and underscore_case.
+#
+# The string can also be tokenized. This is useful for creating a custom
+# casing.
+# For example:
+#  require 'caseconverter'
+#  
+#  ar = CaseConverter.tokenize('TestTheCasing')
+#  # ar = ['test', 'the', 'casing']
+#
+#  ar.join('__')
+#  # returns 'test__the__casing'
+#  ar.join('+')
+#  # returns 'test+the+casing'
+#
+# ==Instance Methods
+# This module can also be used to extend strings.
+#
+# For example:
+#  require 'caseconverter'
+#  
+#  s = 'TestTheCasing'
+#  s.extend(CaseConverter)
+#  s.to_underscore_case
+#  # returns 'test_the_casing'
+#
+#  # Extending a symbol will cause an error.
+#  # Extend the corresponding string by using the to_s method to be safe.
+#  s = :TestTheCasing.to_s
+#  s.extend(CaseConverter)
+#  s.to_underscore_case
+#  # returns 'test_the_casing'
+#
+# This is applicable for all of the module methods.
+
 module CaseConverter
 class << self
   public
   
+  # Converts a string casing to UpperCamelCase.
   def to_upper_camel_case(str)
     tokens = tokenize(str)
     tokens.each { |t| t.capitalize! }
     tokens.join('')
   end
   
+  # Converts a string casing to lowerCamelCase.
   def to_lower_camel_case(str)
     tokens = tokenize(str)
     tokens.each_with_index { |t, i| t.capitalize! unless i == 0 }
     tokens.join('')
   end
   
+  # Converts a string casing to underscore_case.
   def to_underscore_case(str)
     tokens = tokenize(str)
     tokens.join('_')
   end
   
-  def tokenize(str)
+  # Tokenizes a string into an array. Any non alphanumeric character,
+  # or capitalized character will start a new word. This method is
+  # useful for creating custom casing that are not supported in this module.
+  def tokenize(value)
+    str = value.to_s
     str.squeeze(' ')
     tokens = str.split(' ')
     
@@ -56,18 +108,22 @@ class << self
   end
 end
 
+  # Instance method of CaseConverter.to_upper_camel_case
   def to_upper_camel_case
     CaseConverter.to_upper_camel_case(self.to_s)
   end
   
-  def to_lower_camel_case(str)
+  # Instance method of CaseConverter.to_lower_camel_case
+  def to_lower_camel_case
     CaseConverter.to_lower_camel_case(self.to_s)
   end
   
-  def to_underscore_case(str)
+  # Instance method of CaseConverter.to_underscore_case
+  def to_underscore_case
     CaseConverter.to_underscore_case(self.to_s)
   end
   
+  # Instance method of CaseConverter.tokenize
   def tokenize
     CaseConverter.tokenize(self.to_s)
   end

data/test/tc_case_converter.rb

@@ -6,46 +6,72 @@ class TestCaseConverter < Test::Unit::TestCase
   public
   
   def test_to_upper_camel_case
-    strings_to_test.each do |s|
-      assert_equal(
-        'OneTwoThreeFour',
-        CaseConverter.to_upper_camel_case(s)
-      )
-    end
+    do_test_module_method('OneTwoThreeFour', :to_upper_camel_case)
+  end
+    
+  def test_instance_to_upper_camel_case
+    do_test_instance_method('OneTwoThreeFour', :to_upper_camel_case)
   end
   
   def test_to_lower_camel_case
+    do_test_module_method('oneTwoThreeFour', :to_lower_camel_case)
+  end
+  
+  def test_instance_to_lower_camel_case
+    do_test_instance_method('oneTwoThreeFour', :to_lower_camel_case)
+  end
+  
+  def test_to_underscore_case
+    do_test_module_method('one_two_three_four', :to_underscore_case)
+  end
+  
+  def test_instance_to_underscore_case
+    do_test_instance_method('one_two_three_four', :to_underscore_case)
+  end
+  
+  def test_tokenize
+    strings_to_test.each do |s|
+      do_test_tokenize(CaseConverter.tokenize(s))
+    end 
+  end
+  
+  def test_instance_tokenize
+    strings_to_test.each do |s|
+      str = s.to_s
+      str.extend(CaseConverter)
+      do_test_tokenize(str.tokenize)
+    end 
+  end
+    
+  private
+  
+  def do_test_module_method(expected_output, method_sym)
     strings_to_test.each do |s|
       assert_equal(
-        'oneTwoThreeFour',
-        CaseConverter.to_lower_camel_case(s)
+        expected_output,
+        CaseConverter.send(method_sym, s)
       )
     end
   end
   
-  def test_to_underscore_case
+  def do_test_instance_method(expected_output, method_sym)
     strings_to_test.each do |s|
+      str = s.to_s
+      str.extend(CaseConverter)
       assert_equal(
-        'one_two_three_four',
-        CaseConverter.to_underscore_case(s)
+        expected_output,
+        str.send(method_sym)
       )
     end
   end
   
-  def test_tokenize
-    strings_to_test.each do |s|
-      tokens = CaseConverter.tokenize(s)
-      assert_equal('one', tokens[0])
-      assert_equal('two', tokens[1])
-      assert_equal('three', tokens[2])
-      assert_equal('four', tokens[3])
-    end 
+  def do_test_tokenize(tokens)
+    assert_equal('one', tokens[0])
+    assert_equal('two', tokens[1])
+    assert_equal('three', tokens[2])
+    assert_equal('four', tokens[3])
   end
   
-  private
-  
-  include(CaseConverter)
-  
   def strings_to_test
     [
       'one two three four',
@@ -55,7 +81,10 @@ class TestCaseConverter < Test::Unit::TestCase
       'one two_threeFour',
       'one_TwoThree Four',
       'one,two, three, four',
-      'One-two_threeFour'
+      'One-two_threeFour',
+      :one_two_three_four,
+      :oneTwoThreeFour,
+      :OneTwoThreeFour,
     ]
   end
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: caseconverter
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
-date: 2005-09-06 00:00:00 -07:00
+  version: 0.1.1
+date: 2005-09-09 00:00:00 -07:00
 summary: Operations that change the casing of a string.
 require_paths: 
   - lib