more_ruby 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b1771efb7dc83fea53e24b2d7b5a2f67fa7d1e2cdca9dec76ef81ad09817c30
-  data.tar.gz: 46a7e965a7449f3f6e0258f355e414cc2f537ad8f2c2284f06a63fddf515e26b
+  metadata.gz: 216485758b0badb8831ccff9952d5f05a8dc2dd96820d3fe378daf544fb07a3b
+  data.tar.gz: 41bcb4b845d8961f738da3c316c38fe9cfc855b3fe2c5561c4cf3b92fcd14a82
 SHA512:
-  metadata.gz: 6a8b12b7cf3c75568bfbce46433e6b07e315524ffb34d2b37bdf2f3cae73c0919e2f075f9425a88cd55638caa76e85928c04dcb02a42f1503a173dafaba15012
-  data.tar.gz: 3ad555c95b8f5c8512a6b24522dea8b434539584ecb237c66e56ad9154f26863a168fc16b55df38275cace7ac8e248ca9648e7587c776599ed6f0b0c2cc6aea8
+  metadata.gz: f1f9392fef5750e502ab0dfe956e1f9c2fc4d2eebd8debc19d38b8b121052dcfb8eaa9bc62fa02600bef57ec7f89abfc2a868754394f1b114db33c34e5fd6c6f
+  data.tar.gz: f24a25df5c7c650cc3ec62d749c6844908b8dfa0c48aa409fe9e1eb1f0e9279453bc2a97380c4565f65aca32b67d69900e9f030760ae95e29e642f402f5ed34c

data/README.md

@@ -26,7 +26,7 @@ Simply require the gem ( require "more_ruby" ) and the additional methods will b
 :format_with_thousands_delimiter
 
 ## String
-:append, :camelcase, :camelcase_to_snakecase, :capitalize_all, :capitalize_first_letter_only, :escape, :escape_whitespace, :extract_values_from_xml_string, :formatted_number, :index_of_last_capital, :invert_case, :is_hex?, :is_integer?, :join, :pascalcase, :prefix_lines, :random_case, :snakecase, :snakecase_and_downcase, :to_bool, :unindent
+:append, :camelcase, :capitalize_all, :capitalize_first_letter_only, :escape, :escape_whitespace, :extract_values_from_xml_string, :formatted_number, :index_of_last_capital, :invert_case, :is_hex?, :is_integer?, :join, :pascalcase, :prefix_lines, :random_case, :snakecase, :snakecase_and_downcase, :snakecase_non_alpha, :to_bool, :unindent
 
 ## Time
 :is_after?, :is_before?, :is_within?, :remove_subseconds

data/lib/more_ruby/string.rb

@@ -59,14 +59,13 @@ class String
         self.size - reverse_index - 1
     end
 
-    def snakecase
+    # Changes every sequence of non-alpha-numeric characters to underscores
+    # If you want to convert something looking like camelcase to snakecase, 
+    # use snakecase
+    def snakecase_non_alpha
         gsub(/[^a-zA-Z0-9]+/, '_')
     end
 
-    def snakecase_and_downcase
-        downcase.snakecase
-    end
-
     # Like camelcase but with the first letter also capitalised
     # Pascalcase is C#'s case convention
     def pascalcase
@@ -79,27 +78,103 @@ class String
     end
 
     # Converts aStringInCamelCase to a_string_in_camel_case
-    def camelcase_to_snakecase
+    # Also converts SomeStringInPascalCase to some_string_in_pascal_case
+    #a << {:raw => "thiNGS-with_stuff", :expected => "thi_ngs_with_stuff"}
+    def snakecase
+        # Notes : 
+        # If the entire string contains only uppercase (with or without underscores), return it as it is
+        if self =~ /^[A-Z_]+$/
+            return self
+        end
+
+        # If the entire string contains only uppercase and numbers, AND has underscores, return it as it is
+        # REQ_ID2 -> REQ_ID2 ; REQID2 should not -> REQID2
+        if self =~ /^[A-Z0-9_]+$/ && self.include?("_")
+            return self
+        end
+
         a = []
 
-        self =~ /(^[a-z]+)/
-        a << $1 if $1
-
-        m = self.scan /([A-Z]+[a-z0-9]*)/
-        m.flatten!
-        m.each do |fragment|
-            fragment =~ /([A-Z]+[a-z0-9]*)/
-            caps = $1
-            lower = $2
-            if caps.size > 1
-                s = "_#{caps.downcase}"
-                a << s
-                caps = "" # set to empty string so that the below caps.downcase still works
+        before = self.snakecase_non_alpha
+        parts = before.split("_")
+        
+        # Process each part, then stitch them back together
+        # Each part might itself contain several 'camel humps' 
+        # Each fragment within each part might be of different 'format'
+
+        parts.each do |part|
+            # If the part is already all lowercase, keep it and move on to the next part
+            part =~ /^([a-z0-9]+)$/
+            if $1
+                a << $1
+                next
             end
-            s = "_#{caps.downcase}#{lower}"
-            a << s unless s == "_"
-        end
-        a.join
+            
+            # ABC -> ABC # if all capitals, leave it as it is
+            # If the part is already all uppercase, keep it and move on to the next part
+            part =~ /^([A-Z]+)$/
+            if $1
+                a << $1
+                next
+            end
+
+            #
+            # The part contains 'camel humps', which need to be processed
+            #
+
+            # Make sure to preserve the leading part of the string before the first 'hump'
+            part =~ /^([a-z0-9]+)([A-Z])/
+            if $1
+                a << $1
+            end
+
+            # This scan-regex will only match from the first 'hump' onwards
+            fragments = part.scan /([A-Z]+[a-z0-9]*)/
+            fragments.flatten!
+            fragments.each do |fragment|
+
+                # ABCD -> abcd
+                fragment =~ /^([A-Z]+)$/
+                if $1
+                    a << $1.downcase
+                    next
+                end
+
+                # ABCD1234 -> abcd_1234
+                fragment =~ /^([A-Z]+)([0-9]+)$/
+                if $1
+                    a << $1.downcase
+                    a << $2
+                    next
+                end
+                
+                # Abc -> abc
+                fragment =~ /^([A-Z][a-z0-9]*)$/
+                if $1
+                    a << $1.downcase
+                    next
+                end
+                
+                # ABCDef -> abc_def
+                fragment =~ /^([A-Z]+)([A-Z][a-z0-9]*)$/
+                if $1
+                    a << $1.downcase
+                    a << $2.downcase
+                    next
+                end
+
+            end # end fragments
+        end # end parts
+        s = a.join("_")
+
+        # Final tidying
+        s.gsub!(/[_]+/, "_") # replace continuous underscores with one underscore
+        s = s[1 .. -1] if s[0] == "_" # a pascalcase string will cause a leading underscore, which we need to remove
+        s
+    end
+
+    def snakecase_and_downcase
+        self.snakecase.downcase
     end
 
     def append(s)

data/test/test_string.rb

@@ -38,7 +38,7 @@ class TestString < Test::Unit::TestCase
 		assert_nil(re =~ e, ".escape yielded an escaped string that matched its Regexp object")
 	end
 
-	def test_snakecase
+	def test_snakecase_non_alpha
 		a = []
 		a << {:raw => "thiNGS", :expected => "thiNGS"}
 		a << {:raw => "thiNGS-with_stuff", :expected => "thiNGS_with_stuff"}
@@ -46,22 +46,33 @@ class TestString < Test::Unit::TestCase
 		a << {:raw => "th2i<>n!!!gs", :expected => "th2i_n_gs"}
 
 		a.each do |x|
-			actual = x[:raw].snakecase
-			assert_equal(actual, x[:expected], ".snakecase didn't work properly")
+			actual = x[:raw].snakecase_non_alpha
+			assert_equal(x[:expected], actual, ".snakecase_non_alpha didn't work properly")
 		end
 
 	end
 
-	def test_snakecase_and_downcase
+	def test_snakecase
 		a = []
-		a << {:raw => "thiNGS", :expected => "things"}
-		a << {:raw => "thiNGS-with_stuff", :expected => "things_with_stuff"}
+		a << {:raw => "things", :expected => "things"}
+		a << {:raw => "THINGS", :expected => "THINGS"} # should stay the same if all uppercase
+		a << {:raw => "REQ_ID", :expected => "REQ_ID"} # should stay the same if all uppercase
+		a << {:raw => "REQ_ID2", :expected => "REQ_ID2"}
+		a << {:raw => "REQID2", :expected => "reqid_2"}
+		a << {:raw => "req_ID", :expected => "req_ID"}
+		a << {:raw => "reqID", :expected => "req_id"}
+		a << {:raw => "reqId", :expected => "req_id"}
+		a << {:raw => "thi_ngs_yes", :expected => "thi_ngs_yes"}
+		a << {:raw => "thiNGSYes", :expected => "thi_ngs_yes"}
+		a << {:raw => "thiNGS", :expected => "thi_ngs"}
+		a << {:raw => "thiNGS-with_stuff", :expected => "thi_ngs_with_stuff"}
 		a << {:raw => "thi--_-ngs", :expected => "thi_ngs"}
 		a << {:raw => "th2i<>n!!!gs", :expected => "th2i_n_gs"}
+		a << {:raw => "THINGS1234STUFF5678", :expected => "things_1234_stuff_5678"}
 
 		a.each do |x|
-			actual = x[:raw].snakecase_and_downcase
-			assert_equal(actual, x[:expected], "snakecase_and_downcase didn't work properly")
+			actual = x[:raw].snakecase
+			assert_equal(x[:expected], actual, "snakecase didn't work properly")
 		end
 
 	end
@@ -95,7 +106,7 @@ class TestString < Test::Unit::TestCase
 
 		a.each do |x|
 			actual = x[:raw].camelcase
-			assert_equal( x[:expected], actual, ".camelcase didn't work properly")
+			assert_equal(x[:expected], actual, ".camelcase didn't work properly")
 		end
 
 	end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: more_ruby
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Richard Morrisby
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-04 00:00:00.000000000 Z
+date: 2019-06-04 00:00:00.000000000 Z
 dependencies: []
 description: "  A very simple gem that adds some methods to some Ruby standard classes,
   e.g. <array>.include_any?, <array>.delete_random, etc.\n\n  Simply require the gem