lucky_case 0.1.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f8bf7cdb1dcc0214e91e6a2818262ff49b4f0aac27cf39d09d19b6f356f8c4f
-  data.tar.gz: cb8ccfab6f18eba90fa37b4ba364d2571f417e21a885e7c32760145696ad3f14
+  metadata.gz: bfe36f3ecf272ce46d7350964f6396949e54b49544e2d4a886b27cba698acedd
+  data.tar.gz: 99e2745316e403bd0c1258bfc5db260da120b3215f224d38efee03a5bcc46392
 SHA512:
-  metadata.gz: fca494255aeeee1f77928f0b6cce87252311e1459a59ea2b70e14ea2df3b0a5b6c9998734f73f0199ee9ecc97c3b6fc7a1f5a41aa7e054dd9def83014d44da63
-  data.tar.gz: 52644493a0bc2adedd7aee6059fccf0aa3c7c14e0a15f91188f5e0a09167dca7a507d4cb18fcbd5f42f7d88a384eed2cb967a86438c7ea97d0be45dc6c689521
+  metadata.gz: 704d45b0cd6df44c2097b467759a0a4ec58d42b0fdbeed78b3cf11f8012b68aae9fd9beb2bb23fa25224338d876e93daf1001b7616491665224c6ebe45dcdbd1
+  data.tar.gz: 60d487477cf8d5515ec135a370aaa97b78665ad6ec060f63a29e0190858ea7ddc5eb09dd1642d15da2ff3bc03c378878e41e2a228649bb646ecd5dbb70f901df

data/README.md

@@ -25,21 +25,27 @@ Useful when working with conventions, where class names, method names and file n
 
 You can either use the static LuckyCase class with its method or optionally monkey patch the String class.
 
-### Use the static class only
+### Approach 1: Using the static class
 ```ruby
 require 'lucky_case'
 
 # converters
-LuckyCase.snake_case('ExamplePascalString')            # => 'example_pascal_string'
-LuckyCase.upper_snake_case('Example-Train-String')     # => 'EXAMPLE_TRAIN_STRING'
-LuckyCase.pascal_case('example_snake_string')          # => 'ExampleSnakeString'
-LuckyCase.camel_case('example-dash-string')            # => 'exampleDashString'
-LuckyCase.dash_case('ExamplePascalString')             # => 'example-pascal-string'
-LuckyCase.upper_dash_case('ExamplePascalString')       # => 'EXAMPLE-PASCAL-STRING'
-LuckyCase.train_case('example_snake_string')           # => 'Example-Snake-String'
+LuckyCase.snake_case('PascalToSnake')                  # => 'pascal_to_snake'
+LuckyCase.upper_snake_case('Train-To-Upper-Snake')     # => 'TRAIN_TO_UPPER_SNAKE'
+LuckyCase.pascal_case('snake_to_pascal')               # => 'SnakeToPascal'
+LuckyCase.camel_case('dash-to-camel-case')             # => 'dashToCamelCase'
+LuckyCase.dash_case('PascalToDashCase')                # => 'pascal-to-dash-case'
+LuckyCase.upper_dash_case('PascalToUpperDash')         # => 'PASCAL-TO-UPPER-DASH'
+LuckyCase.train_case('snake_to_train_case')            # => 'Snake-To-Train-Case'
+LuckyCase.word_case('PascalToWordCase')                # => 'pascal to word case'
+LuckyCase.upper_word_case('PascalToUpperWord')         # => 'PASCAL TO UPPER WORD'
+LuckyCase.capital_word_case('snake_to_capital_word')   # => 'Snake To Capital Word'
+LuckyCase.sentence_case('snake_to_sentence_case')      # => 'Snake to sentence case'
 LuckyCase.mixed_case('example_snake_string')           # => 'Example-snake_STRING'
+
 # converter by type
 LuckyCase.convert_case('some_snake', :pascal_case)     # => 'SomeSnake'
+
 # transformers
 LuckyCase.lower_case('Some_FuckingShit')               # => 'some_fuckingshit'
 LuckyCase.upper_case('Some_FuckingShit')               # => 'SOME_FUCKINGSHIT'
@@ -51,29 +57,41 @@ LuckyCase.constantize('SOME_CONSTANT')                 # => SomeConstant
 LuckyCase.constantize('some/path_example/folder')      # => Some::PathExample::Folder
 LuckyCase.deconstantize(SomeConstant)                  # => 'some_constant'
 LuckyCase.deconstantize(Some::PathExample::Folder, case_type: :camel_case)     # => 'some/pathExample/folder'
-# identifier
+
+# identifiers
 LuckyCase.case('this_can_only_be_snake_case')          # => :snake_case
-LuckyCase.cases('multiple')                            # => [ :snake_case, :camel_case, :dash_case ]
+LuckyCase.cases('validformultiple')                    # => [ :snake_case, :camel_case, :dash_case, :word_case ]
+
 # checkers
 LuckyCase.snake_case?('valid_snake_case')              # => true
-LuckyCase.upper_snake_case?('inValidSnakeCase')        # => false
+LuckyCase.upper_snake_case?('UPPER_SNAKE')             # => true
 LuckyCase.pascal_case?('PascalCase')                   # => true
 LuckyCase.camel_case?('camelCase')                     # => true
 LuckyCase.dash_case?('dash-case')                      # => true
 LuckyCase.upper_dash_case?('DASH-CASE')                # => true
 LuckyCase.train_case?('Train-Case')                    # => true
+LuckyCase.word_case?('word case')                      # => true
+LuckyCase.upper_word_case?('UPPER WORD CASE')          # => true
+LuckyCase.capital_word_case?('Capital Word Case')      # => true
+LuckyCase.sentence_case?('Sentence case string')       # => true
 LuckyCase.mixed_case?('mixed_Case')                    # => true
 LuckyCase.upper_case?('UPPER50984')                    # => true
-LuckyCase.lower_case?('mixed_Case')                    # => true
+LuckyCase.lower_case?('lower_cheese')                  # => true
 LuckyCase.capital?('Some')                             # => true
 LuckyCase.capitalized?('some')                         # => false
+LuckyCase.valid_case_type?(:snake_case)                # => true
+LuckyCase.valid_case_type?(:apple_case)                # => false
+LuckyCase.valid_case_string?('validString')            # => true
+LuckyCase.valid_case_string?('1nV4lid$tring')          # => false
 ```
 
-### Monkey patch the string class
+### Approach 2: Monkey patch the string class
 
-With monkey patching you can access the same methods (except deconstantize) of LuckyCase directly from strings.
+With monkey patching you can access the same methods (except deconstantize, valid_case_type?) of LuckyCase directly from strings.
 Additionally they provide versions with exclamation mark for direct manipulation.
 
+Because the method #case is so general and could lead to conflicts, it is called #letter_case here.
+
 ```ruby
 require 'lucky_case/string'
 
@@ -82,9 +100,17 @@ a = 'ExampleString'
 a.pascal_case?                          # => true
 a.snake_case                            # => 'example_string'
 a                                       # => 'ExampleString'
+
 # string variable manipulation
 a.snake_case!                           # => 'example_string'
 a                                       # => 'example_string'
+...
+
+# identifiers
+# got a other method name here because 'case' might be to common and cause conflicts
+b = 'example'
+b.letter_case                           # => :snake_case
+b.letter_cases                          # => [ :snake_case, :camel_case, :dash_case, :word_case ]
 ```
 
 

data/lib/lucky_case.rb

@@ -18,7 +18,11 @@ module LuckyCase
       dash_case: /^([[:lower:]]){1}[[:lower:]\-0-9]*[[:lower:]0-9]+$/,
       upper_dash_case: /^([[:upper:]]){1}[[:upper:]\-0-9]*[[:upper:]0-9]+$/,
       train_case: /^([[:upper:]][[:lower:]0-9]*\-|[0-9]+\-)*([[:upper:]][[:lower:]0-9]*)$/,
-      mixed_case: /^[[:upper:][:lower:]][[:upper:][:lower:]_\-0-9]*$/,
+      word_case: /^[[:lower:]]{1}[[:lower:] 0-9]+$/,
+      upper_word_case: /^[[:upper:]]{1}[[:upper:] 0-9]+$/,
+      capital_word_case: /^([[:upper:]][[:lower:]0-9]*\ |[0-9]+\ )*([[:upper:]][[:lower:]0-9]*)$/,
+      sentence_case: /^[[:upper:]]{1}[[:lower:] 0-9]+$/,
+      mixed_case: /^[[:upper:][:lower:]][[:upper:][:lower:]_\-0-9 ]*$/,
   }
 
   FORMATS = {
@@ -97,11 +101,31 @@ module LuckyCase
     raise InvalidCaseError.new error_message
   end
 
+  # Check if given case type is a valid case type
+  # 
+  # @param [Symbol, String] case_type
+  # @return [Boolean]
+  def self.valid_case_type?(case_type)
+    if CASES.keys.include? case_type.to_sym
+      true
+    else
+      false
+    end
+  end
+
+  # Check if the string matches any of the available cases
+  # 
+  # @param [String] case_type
+  # @return [Boolean]
+  def self.valid_case_string?(string)
+    self.case(string) != nil
+  end
+  
   #----------------------------------------------------------------------------------------------------
   # UPPER CASE
   #----------------------------------------------------------------------------------------------------
 
-  # Converts all characters inside the string
+  # Convert all characters inside the string
   # into upper case
   #
   # @example conversion
@@ -113,7 +137,7 @@ module LuckyCase
     string.upcase
   end
 
-  # Checks if all characters inside the string are upper case
+  # Check if all characters inside the string are upper case
   #
   # @param [String] string to check
   # @return [Boolean]
@@ -125,7 +149,7 @@ module LuckyCase
   # LOWER CASE
   #----------------------------------------------------------------------------------------------------
 
-  # Converts all characters inside the string
+  # Convert all characters inside the string
   # into lower case
   #
   # @example conversion
@@ -137,7 +161,7 @@ module LuckyCase
     string.downcase
   end
 
-  # Checks if all characters inside the string are lower case
+  # Check if all characters inside the string are lower case
   #
   # @param [String] string to check
   # @return [Boolean]
@@ -149,7 +173,7 @@ module LuckyCase
   # SNAKE CASE
   #----------------------------------------------------------------------------------------------------
 
-  # Converts the given string from any case
+  # Convert the given string from any case
   # into snake case
   #
   # @example conversion
@@ -168,7 +192,7 @@ module LuckyCase
     end
   end
 
-  # Checks if the string is snake case
+  # Check if the string is snake case
   #
   # @param [String] string to check
   # @param [Boolean] allow_prefixed_underscores
@@ -182,7 +206,7 @@ module LuckyCase
     _case_match? s, :snake_case
   end
 
-  # Converts the given string from any case
+  # Convert the given string from any case
   # into upper snake case
   #
   # @example conversion
@@ -201,7 +225,7 @@ module LuckyCase
     end
   end
 
-  # Checks if the string is upper snake case
+  # Check if the string is upper snake case
   #
   # @param [String] string to check
   # @param [Boolean] allow_prefixed_underscores
@@ -219,7 +243,7 @@ module LuckyCase
   # PASCAL CASE
   #----------------------------------------------------------------------------------------------------
 
-  # Converts the given string from any case
+  # Convert the given string from any case
   # into pascal case
   #
   # @example conversion
@@ -238,7 +262,7 @@ module LuckyCase
     end
   end
 
-  # Checks if the string is upper pascal case
+  # Check if the string is upper pascal case
   #
   # @param [String] string to check
   # @param [Boolean] allow_prefixed_underscores
@@ -256,7 +280,7 @@ module LuckyCase
   # CAMEL CASE
   #----------------------------------------------------------------------------------------------------
 
-  # Converts the given string from any case
+  # Convert the given string from any case
   # into camel case
   #
   # @example conversion
@@ -275,7 +299,7 @@ module LuckyCase
     end
   end
 
-  # Checks if the string is camel case
+  # Check if the string is camel case
   #
   # @param [String] string to check
   # @param [Boolean] allow_prefixed_underscores
@@ -293,7 +317,7 @@ module LuckyCase
   # DASH CASE
   #----------------------------------------------------------------------------------------------------
 
-  # Converts the given string from any case
+  # Convert the given string from any case
   # into dash case
   #
   # @example conversion
@@ -312,7 +336,7 @@ module LuckyCase
     end
   end
 
-  # Checks if the string is dash case
+  # Check if the string is dash case
   #
   # @param [String] string to check
   # @param [Boolean] allow_prefixed_underscores
@@ -326,7 +350,7 @@ module LuckyCase
     _case_match? s, :dash_case
   end
 
-  # Converts the given string from any case
+  # Convert the given string from any case
   # into upper dash case
   #
   # @example conversion
@@ -340,7 +364,7 @@ module LuckyCase
     upper_case s
   end
 
-  # Checks if the string is upper dash case
+  # Check if the string is upper dash case
   #
   # @param [String] string to check
   # @param [Boolean] allow_prefixed_underscores
@@ -358,7 +382,7 @@ module LuckyCase
   # TRAIN CASE
   #----------------------------------------------------------------------------------------------------
 
-  # Converts the given string from any case
+  # Convert the given string from any case
   # into train case
   #
   # @example conversion
@@ -377,7 +401,7 @@ module LuckyCase
     end
   end
 
-  # Checks if the string is train case
+  # Check if the string is train case
   #
   # @param [String] string to check
   # @param [Boolean] allow_prefixed_underscores
@@ -391,11 +415,151 @@ module LuckyCase
     _case_match? s, :train_case
   end
 
+  #----------------------------------------------------------------------------------------------------
+  # WORD CASE
+  #----------------------------------------------------------------------------------------------------
+
+  # Convert the given string from any case
+  # into word case
+  #
+  # @example conversion
+  #   'this-isAnExample_string' => 'this is an example string'
+  #
+  # @param [String] string to convert
+  # @param [Boolean] preserve_prefixed_underscores
+  # @return [String]
+  def self.word_case(string, preserve_prefixed_underscores: true)
+    a = split_case_string string
+    converted = a.join(' ')
+    if preserve_prefixed_underscores
+      underscores_at_start(string) + converted
+    else
+      converted
+    end
+  end
+
+  # Check if the string is word case
+  #
+  # @param [String] string to check
+  # @param [Boolean] allow_prefixed_underscores
+  # @return [Boolean]
+  def self.word_case?(string, allow_prefixed_underscores: true)
+    s = if allow_prefixed_underscores
+          cut_underscores_at_start string
+        else
+          string
+        end
+    _case_match? s, :word_case
+  end
+
+  # Convert the given string from any case
+  # into upper word case
+  #
+  # @example conversion
+  #   'this-isAnExample_string' => 'THIS IS AN EXAMPLE STRING'
+  #
+  # @param [String] string to convert
+  # @param [Boolean] preserve_prefixed_underscores
+  # @return [String]
+  def self.upper_word_case(string, preserve_prefixed_underscores: true)
+    a = split_case_string string
+    converted = a.map { |e| upper_case e }.join(' ')
+    if preserve_prefixed_underscores
+      underscores_at_start(string) + converted
+    else
+      converted
+    end
+  end
+
+  # Check if the string is upper word case
+  #
+  # @param [String] string to check
+  # @param [Boolean] allow_prefixed_underscores
+  # @return [Boolean]
+  def self.upper_word_case?(string, allow_prefixed_underscores: true)
+    s = if allow_prefixed_underscores
+          cut_underscores_at_start string
+        else
+          string
+        end
+    _case_match? s, :upper_word_case
+  end
+
+  # Convert the given string from any case
+  # into capital word case
+  #
+  # @example conversion
+  #   'this-isAnExample_string' => 'This Is An Example String'
+  #
+  # @param [String] string to convert
+  # @param [Boolean] preserve_prefixed_underscores
+  # @return [String]
+  def self.capital_word_case(string, preserve_prefixed_underscores: true)
+    a = split_case_string string
+    converted = a.map { |e| capital e }.join(' ')
+    if preserve_prefixed_underscores
+      underscores_at_start(string) + converted
+    else
+      converted
+    end
+  end
+
+  # Check if the string is capital word case
+  #
+  # @param [String] string to check
+  # @param [Boolean] allow_prefixed_underscores
+  # @return [Boolean]
+  def self.capital_word_case?(string, allow_prefixed_underscores: true)
+    s = if allow_prefixed_underscores
+          cut_underscores_at_start string
+        else
+          string
+        end
+    _case_match? s, :capital_word_case
+  end
+
+  #----------------------------------------------------------------------------------------------------
+  # SENTENCE CASE
+  #----------------------------------------------------------------------------------------------------
+
+  # Convert the given string from any case
+  # into sentence case
+  #
+  # @example conversion
+  #   'this-isAnExample_string' => 'This is an example string'
+  #
+  # @param [String] string to convert
+  # @param [Boolean] preserve_prefixed_underscores
+  # @return [String]
+  def self.sentence_case(string, preserve_prefixed_underscores: true)
+    a = split_case_string string
+    converted = capital(a.join(' '))
+    if preserve_prefixed_underscores
+      underscores_at_start(string) + converted
+    else
+      converted
+    end
+  end
+
+  # Check if the string is sentence case
+  #
+  # @param [String] string to check
+  # @param [Boolean] allow_prefixed_underscores
+  # @return [Boolean]
+  def self.sentence_case?(string, allow_prefixed_underscores: true)
+    s = if allow_prefixed_underscores
+          cut_underscores_at_start string
+        else
+          string
+        end
+    _case_match? s, :sentence_case
+  end
+
   #----------------------------------------------------------------------------------------------------
   # CAPITALIZE
   #----------------------------------------------------------------------------------------------------
 
-  # Converts the first character to capital
+  # Convert the first character to capital
   #
   # @param [String] string to convert
   # @param [Boolean] skip_prefixed_underscores
@@ -415,7 +579,7 @@ module LuckyCase
     end
   end
 
-  # Converts the first character to capital
+  # Convert the first character to capital
   #
   # @param [String] string to convert
   # @param [Boolean] skip_prefixed_underscores
@@ -424,7 +588,7 @@ module LuckyCase
     capital string, skip_prefixed_underscores: skip_prefixed_underscores
   end
 
-  # Checks if the strings first character is a capital letter
+  # Check if the strings first character is a capital letter
   #
   # @param [String] string to check
   # @param [Boolean] skip_prefixed_underscores
@@ -438,7 +602,7 @@ module LuckyCase
     _case_match? s, :capital
   end
 
-  # Checks if the strings first character is a capital letter
+  # Check if the strings first character is a capital letter
   #
   # @param [String] string to check
   # @param [Boolean] skip_prefixed_underscores
@@ -451,7 +615,7 @@ module LuckyCase
   # MIXED CASE
   #----------------------------------------------------------------------------------------------------
 
-  # Converts the given string from any case
+  # Convert the given string from any case
   # into mixed case
   #
   # @example conversion
@@ -473,7 +637,7 @@ module LuckyCase
     end
   end
 
-  # Checks if the string is a valid mixed case (without special characters!)
+  # Check if the string is a valid mixed case (without special characters!)
   #
   # @param [String] string to check
   # @return [Boolean]
@@ -528,7 +692,7 @@ module LuckyCase
   # CONSTANTIZE
   #----------------------------------------------------------------------------------------------------
 
-  # Converts the string from any case
+  # Convert the string from any case
   # into pascal case and casts it into a constant
   #
   # @example conversion
@@ -539,7 +703,7 @@ module LuckyCase
   # @param [Boolean] preserve_prefixed_underscores
   # @return [Constant]
   def self.constantize(string)
-    s = string.gsub('/','::')
+    s = string.gsub('/', '::')
     constants = if s.include? '::'
                   s.split('::')
                 else
@@ -586,7 +750,7 @@ module LuckyCase
   #----------------------------------------------------------------------------------------------------
   # HELPERS
   #----------------------------------------------------------------------------------------------------
-
+  
   # Return string without underscores at the start
   #
   # @param [String] string
@@ -627,6 +791,7 @@ module LuckyCase
   def self.split_case_string(string)
     s = cut_underscores_at_start string
     s = s.gsub(/([[:upper:]])/, '_\1') unless upper_case? s # prepend all upper characters with underscore
+    s = s.gsub(' ', '_') # replace all spaces with underscore
     s = s.gsub('-', '_') # replace all dashes with underscore
     s = cut_underscores_at_start s
     s.downcase.split('_').reject(&:empty?) # split everything by underscore

data/lib/lucky_case/string.rb

@@ -46,11 +46,18 @@ class String
     set_self_value self.convert_case(case_type, preserve_prefixed_underscores: preserve_prefixed_underscores)
   end
 
+  # Check if the string matches any of the available cases
+  #
+  # @return [Boolean]
+  def valid_case_string?()
+    LuckyCase.case(self) != nil
+  end
+
   #----------------------------------------------------------------------------------------------------
   # UPPER CASE
   #----------------------------------------------------------------------------------------------------
 
-  # Converts all characters inside the string
+  # Convert all characters inside the string
   # into upper case
   #
   # @example conversion
@@ -65,7 +72,7 @@ class String
     set_self_value self.upper_case
   end
 
-  # Checks if all characters inside the string are upper case
+  # Check if all characters inside the string are upper case
   #
   # @return [Boolean]
   def upper_case?()
@@ -76,7 +83,7 @@ class String
   # LOWER CASE
   #----------------------------------------------------------------------------------------------------
 
-  # Converts all characters inside the string
+  # Convert all characters inside the string
   # into lower case
   #
   # @example conversion
@@ -91,7 +98,7 @@ class String
     set_self_value self.lower_case
   end
 
-  # Checks if all characters inside the string are lower case
+  # Check if all characters inside the string are lower case
   #
   # @return [Boolean]
   def lower_case?()
@@ -102,7 +109,7 @@ class String
   # SNAKE CASE
   #----------------------------------------------------------------------------------------------------
 
-  # Converts the given string from any case
+  # Convert the given string from any case
   # into snake case
   #
   # @example conversion
@@ -118,7 +125,7 @@ class String
     set_self_value self.snake_case preserve_prefixed_underscores: preserve_prefixed_underscores
   end
 
-  # Checks if the string is snake case
+  # Check if the string is snake case
   #
   # @param [Boolean] allow_prefixed_underscores
   # @return [Boolean]
@@ -126,7 +133,7 @@ class String
     LuckyCase.snake_case? self, allow_prefixed_underscores: allow_prefixed_underscores
   end
 
-  # Converts the given string from any case
+  # Convert the given string from any case
   # into upper snake case
   #
   # @example conversion
@@ -142,7 +149,7 @@ class String
     set_self_value self.upper_snake_case preserve_prefixed_underscores: preserve_prefixed_underscores
   end
 
-  # Checks if the string is upper snake case
+  # Check if the string is upper snake case
   #
   # @param [Boolean] allow_prefixed_underscores
   # @return [Boolean]
@@ -154,7 +161,7 @@ class String
   # PASCAL CASE
   #----------------------------------------------------------------------------------------------------
 
-  # Converts the given string from any case
+  # Convert the given string from any case
   # into pascal case
   #
   # @example conversion
@@ -170,7 +177,7 @@ class String
     set_self_value self.pascal_case preserve_prefixed_underscores: preserve_prefixed_underscores
   end
 
-  # Checks if the string is upper pascal case
+  # Check if the string is upper pascal case
   #
   # @param [Boolean] allow_prefixed_underscores
   # @return [Boolean]
@@ -182,7 +189,7 @@ class String
   # CAMEL CASE
   #----------------------------------------------------------------------------------------------------
 
-  # Converts the given string from any case
+  # Convert the given string from any case
   # into camel case
   #
   # @example conversion
@@ -198,7 +205,7 @@ class String
     set_self_value self.camel_case preserve_prefixed_underscores: preserve_prefixed_underscores
   end
 
-  # Checks if the string is camel case
+  # Check if the string is camel case
   #
   # @param [Boolean] allow_prefixed_underscores
   # @return [Boolean]
@@ -210,7 +217,7 @@ class String
   # DASH CASE
   #----------------------------------------------------------------------------------------------------
 
-  # Converts the given string from any case
+  # Convert the given string from any case
   # into dash case
   #
   # @example conversion
@@ -226,7 +233,7 @@ class String
     set_self_value self.dash_case preserve_prefixed_underscores: preserve_prefixed_underscores
   end
 
-  # Checks if the string is dash case
+  # Check if the string is dash case
   #
   # @param [Boolean] allow_prefixed_underscores
   # @return [Boolean]
@@ -234,7 +241,7 @@ class String
     LuckyCase.dash_case? self, allow_prefixed_underscores: allow_prefixed_underscores
   end
 
-  # Converts the given string from any case
+  # Convert the given string from any case
   # into upper dash case
   #
   # @example conversion
@@ -250,7 +257,7 @@ class String
     set_self_value self.upper_dash_case preserve_prefixed_underscores: preserve_prefixed_underscores
   end
 
-  # Checks if the string is upper dash case
+  # Check if the string is upper dash case
   #
   # @param [Boolean] allow_prefixed_underscores
   # @return [Boolean]
@@ -262,7 +269,7 @@ class String
   # TRAIN CASE
   #----------------------------------------------------------------------------------------------------
 
-  # Converts the given string from any case
+  # Convert the given string from any case
   # into train case
   #
   # @example conversion
@@ -278,7 +285,7 @@ class String
     set_self_value self.train_case preserve_prefixed_underscores: preserve_prefixed_underscores
   end
 
-  # Checks if the string is train case
+  # Check if the string is train case
   #
   # @param [Boolean] allow_prefixed_underscores
   # @return [Boolean]
@@ -286,11 +293,115 @@ class String
     LuckyCase.train_case? self, allow_prefixed_underscores: allow_prefixed_underscores
   end
 
+  #----------------------------------------------------------------------------------------------------
+  # WORD CASE
+  #----------------------------------------------------------------------------------------------------
+
+  # Convert the given string from any case
+  # into word case
+  #
+  # @example conversion
+  #   'this-isAnExample_string' => 'this is an example string'
+  #
+  # @param [Boolean] preserve_prefixed_underscores
+  # @return [String]
+  def word_case(preserve_prefixed_underscores: true)
+    LuckyCase.word_case self, preserve_prefixed_underscores: preserve_prefixed_underscores
+  end
+
+  def word_case!(preserve_prefixed_underscores: true)
+    set_self_value self.word_case preserve_prefixed_underscores: preserve_prefixed_underscores
+  end
+
+  # Check if the string is word case
+  #
+  # @param [Boolean] allow_prefixed_underscores
+  # @return [Boolean]
+  def word_case?(allow_prefixed_underscores: true)
+    LuckyCase.word_case? self, allow_prefixed_underscores: allow_prefixed_underscores
+  end
+
+  # Convert the given string from any case
+  # into upper word case
+  #
+  # @example conversion
+  #   'this-isAnExample_string' => 'THIS IS AN EXAMPLE STRING'
+  #
+  # @param [Boolean] preserve_prefixed_underscores
+  # @return [String]
+  def upper_word_case(preserve_prefixed_underscores: true)
+    LuckyCase.upper_word_case self, preserve_prefixed_underscores: preserve_prefixed_underscores
+  end
+
+  def upper_word_case!(preserve_prefixed_underscores: true)
+    set_self_value self.upper_word_case preserve_prefixed_underscores: preserve_prefixed_underscores
+  end
+
+  # Check if the string is upper word case
+  #
+  # @param [Boolean] allow_prefixed_underscores
+  # @return [Boolean]
+  def upper_word_case?(allow_prefixed_underscores: true)
+    LuckyCase.upper_word_case? self, allow_prefixed_underscores: allow_prefixed_underscores
+  end
+
+  # Convert the given string from any case
+  # into capital word case
+  #
+  # @example conversion
+  #   'this-isAnExample_string' => 'This Is An Example String'
+  #
+  # @param [Boolean] preserve_prefixed_underscores
+  # @return [String]
+  def capital_word_case(preserve_prefixed_underscores: true)
+    LuckyCase.capital_word_case self, preserve_prefixed_underscores: preserve_prefixed_underscores
+  end
+
+  def capital_word_case!(preserve_prefixed_underscores: true)
+    set_self_value self.capital_word_case preserve_prefixed_underscores: preserve_prefixed_underscores
+  end
+
+  # Check if the string is capital word case
+  #
+  # @param [Boolean] allow_prefixed_underscores
+  # @return [Boolean]
+  def capital_word_case?(allow_prefixed_underscores: true)
+    LuckyCase.capital_word_case? self, allow_prefixed_underscores: allow_prefixed_underscores
+  end
+
+  #----------------------------------------------------------------------------------------------------
+  # SENTENCE CASE
+  #----------------------------------------------------------------------------------------------------
+
+  # Convert the given string from any case
+  # into sentence case
+  #
+  # @example conversion
+  #   'this-isAnExample_string' => 'This is an example string'
+  #
+  # @param [Boolean] preserve_prefixed_underscores
+  # @return [String]
+  def sentence_case(preserve_prefixed_underscores: true)
+    LuckyCase.sentence_case self, preserve_prefixed_underscores: preserve_prefixed_underscores
+  end
+
+  def sentence_case!(preserve_prefixed_underscores: true)
+    set_self_value self.sentence_case preserve_prefixed_underscores: preserve_prefixed_underscores
+  end
+
+  # Check if the string is sentence case
+  #
+  # @param [Boolean] allow_prefixed_underscores
+  # @return [Boolean]
+  def sentence_case?(allow_prefixed_underscores: true)
+    LuckyCase.sentence_case? self, allow_prefixed_underscores: allow_prefixed_underscores
+  end
+
   #----------------------------------------------------------------------------------------------------
   # CAPITALIZE
   #----------------------------------------------------------------------------------------------------
 
-  # Converts the first character to capital
+  # Convert the first character to capital
   #
   # @param [Boolean] skip_prefixed_underscores
   # @return [String]
@@ -298,7 +409,7 @@ class String
     LuckyCase.capitalize self, skip_prefixed_underscores: skip_prefixed_underscores
   end
 
-  # Converts the first character to capital
+  # Convert the first character to capital
   #
   # @param [Boolean] skip_prefixed_underscores
   # @return [String]
@@ -314,7 +425,7 @@ class String
     self.capital! skip_prefixed_underscores: skip_prefixed_underscores
   end
 
-  # Checks if the strings first character is a capital letter
+  # Check if the strings first character is a capital letter
   #
   # @param [Boolean] skip_prefixed_underscores
   # @return [Boolean]
@@ -322,7 +433,7 @@ class String
     LuckyCase.capital? self, skip_prefixed_underscores: skip_prefixed_underscores
   end
 
-  # Checks if the strings first character is a capital letter
+  # Check if the strings first character is a capital letter
   #
   # @param [Boolean] skip_prefixed_underscores
   # @return [Boolean]
@@ -334,7 +445,7 @@ class String
   # MIXED CASE
   #----------------------------------------------------------------------------------------------------
 
-  # Converts the given string from any case
+  # Convert the given string from any case
   # into mixed case
   #
   # @example conversion
@@ -350,7 +461,7 @@ class String
     set_self_value self.mixed_case preserve_prefixed_underscores: preserve_prefixed_underscores
   end
 
-  # Checks if the string is a valid mixed case (without special characters!)
+  # Check if the string is a valid mixed case (without special characters!)
   #
   # @return [Boolean]
   def mixed_case?()
@@ -387,7 +498,7 @@ class String
   # CONSTANTIZE
   #----------------------------------------------------------------------------------------------------
 
-  # Converts the string from any case
+  # Convert the string from any case
   # into pascal case and casts it into a constant
   #
   # @example conversion

data/lib/lucky_case/version.rb

@@ -1,3 +1,3 @@
 module LuckyCase
-  VERSION = '0.1.2'.freeze
+  VERSION = '0.2.3'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lucky_case
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.3
 platform: ruby
 authors:
 - Matthäus J. N. Beyrle
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-08-12 00:00:00.000000000 Z
+date: 2020-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler