lucky_case 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a2cb0b71a39713fbfdcf1d1c829a682b2b5c3d3ab3e27848ed10ddb9b17f17c
-  data.tar.gz: 47d28a8136f743a4bb8bd6b3687eecf40fd8bddc92554cd093616dc91a81b14a
+  metadata.gz: f78932c6caab460f362db13b18485d98b98b016dda12cc9750b9a649297c4587
+  data.tar.gz: 0240f607386929862771d4a44df92cd6f7dc186cdf11f2bd1a281463286b9c43
 SHA512:
-  metadata.gz: 3c6f91d4e248c1c54fff4f25c168a34010dcadf12de9dedf488e50e4ca6f9235959990a6d59bd0f69b6cd6e7f5f72ffea2231b83745184e20ca2bcf0e529c22e
-  data.tar.gz: c8dadeefe2192286ff3b9f3e756a6fc5fc8b0d640140ae38aaa1a300b526a12e2bc04c43b62b8112ee348b064e7a3348836da3516b188008e0e2ca910d402ac0
+  metadata.gz: 8455aad2bc3344d211556e326e073a68ee5ef02e2b9edab1f02454fab8841513323383f6d2e7679de21a641fce17f4438506fbc32ee72fdb2d249133d9f1a3b3
+  data.tar.gz: bc6cda1182cc9c1d83977d8a75fe726c543efc8713c3dab7761e58617d8ab92e7e4f00e31dc648d6df2518da6be7e8ec4b4cc5426a4554b15daf3a55046ff49b

data/CODE_OF_CONDUCT.md

@@ -55,7 +55,7 @@ further defined and clarified by project maintainers.
 ## Enforcement
 
 Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting the project team at yaml_extend.gemspec@mail.magynhard.de. All
+reported by contacting the project team at lucky_case.gemspec@mail.magynhard.de. All
 complaints will be reviewed and investigated and will result in a response that
 is deemed necessary and appropriate to the circumstances. The project team is
 obligated to maintain confidentiality with regard to the reporter of an incident.

data/README.md

@@ -30,13 +30,17 @@ You can either use the static LuckyCase class with its method or optionally monk
 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'
@@ -53,18 +57,22 @@ LuckyCase.deconstantize(SomeConstant)                  # => 'some_constant'
 LuckyCase.deconstantize(Some::PathExample::Folder, case_type: :camel_case)     # => 'some/pathExample/folder'
 # identifier
 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?('Train-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
 ```
@@ -106,7 +114,7 @@ And then execute:
 
 Or install it yourself by:
 
-    $ gem install yaml_extend
+    $ gem install lucky_case
 
 
 

data/lib/lucky_case.rb

@@ -18,6 +18,10 @@ 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]*)$/,
+      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]*$/,
   }
 
@@ -391,6 +395,146 @@ module LuckyCase
     _case_match? s, :train_case
   end
 
+  #----------------------------------------------------------------------------------------------------
+  # WORD CASE
+  #----------------------------------------------------------------------------------------------------
+
+  # Converts 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
+
+  # Checks 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
+
+  # Converts 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
+
+  # Checks 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
+
+  # Converts 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
+
+  # Checks 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
+  #----------------------------------------------------------------------------------------------------
+
+  # Converts 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
+
+  # Checks 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
   #----------------------------------------------------------------------------------------------------
@@ -539,7 +683,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
@@ -627,6 +771,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

@@ -286,6 +286,110 @@ class String
     LuckyCase.train_case? self, allow_prefixed_underscores: allow_prefixed_underscores
   end
 
+  #----------------------------------------------------------------------------------------------------
+  # WORD CASE
+  #----------------------------------------------------------------------------------------------------
+
+  # Converts 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
+
+  # Checks 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
+
+  # Converts 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
+
+  # Checks 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
+
+  # Converts 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
+
+  # Checks 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
+  #----------------------------------------------------------------------------------------------------
+
+  # Converts 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
+
+  # Checks 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
   #----------------------------------------------------------------------------------------------------

data/lib/lucky_case/version.rb

@@ -1,3 +1,3 @@
 module LuckyCase
-  VERSION = '0.1.0'.freeze
+  VERSION = '0.2.1'.freeze
 end

metadata

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