lucky_case 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3a2cb0b71a39713fbfdcf1d1c829a682b2b5c3d3ab3e27848ed10ddb9b17f17c
+  data.tar.gz: 47d28a8136f743a4bb8bd6b3687eecf40fd8bddc92554cd093616dc91a81b14a
+SHA512:
+  metadata.gz: 3c6f91d4e248c1c54fff4f25c168a34010dcadf12de9dedf488e50e4ca6f9235959990a6d59bd0f69b6cd6e7f5f72ffea2231b83745184e20ca2bcf0e529c22e
+  data.tar.gz: c8dadeefe2192286ff3b9f3e756a6fc5fc8b0d640140ae38aaa1a300b526a12e2bc04c43b62b8112ee348b064e7a3348836da3516b188008e0e2ca910d402ac0

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/.vscode/
+/.idea/
+*.gem
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+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
+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.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in lucky_case.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Matthäus J. N. Beyrle
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,128 @@
+# lucky_case
+
+The lucky ruby gem to identify and convert strings from any letter case to another. Plus some extra functions.
+
+Useful when working with conventions, where class names, method names and file names needs to be converted.
+
+* Converters: Only characters, numbers, dashes and underlines are allowed inside a string.
+* Must not start with dash or number, underlines at the beginning are allowed by default and can be allowed/removed/controlled by parameter (when used for private methods for example)
+
+
+
+
+# Contents
+
+* [Usage](#usage)
+* [Installation](#installation)
+* [Documentation](#documentation)
+* [Contributing](#contributing)
+
+
+
+
+<a name="usage"></a>
+## Usage
+
+You can either use the static LuckyCase class with its method or optionally monkey patch the String class.
+
+### Use the static class only
+```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.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'
+LuckyCase.swap_case('SomeSwappy_Case-Example')         # => 'sOMEsWAPPY-cASE_eXAMPLE'
+LuckyCase.capital('example')                           # => 'Example'
+LuckyCase.capitalize('example')                        # => 'Example'
+LuckyCase.constantize('some_constant')                 # => SomeConstant
+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
+LuckyCase.case('this_can_only_be_snake_case')          # => :snake_case
+LuckyCase.cases('multiple')                            # => [ :snake_case, :camel_case, :dash_case ]
+# checkers
+LuckyCase.snake_case?('valid_snake_case')              # => true
+LuckyCase.upper_snake_case?('inValidSnakeCase')        # => false
+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.mixed_case?('mixed_Case')                    # => true
+LuckyCase.upper_case?('UPPER50984')                    # => true
+LuckyCase.lower_case?('mixed_Case')                    # => true
+LuckyCase.capital?('Some')                             # => true
+LuckyCase.capitalized?('some')                         # => false
+```
+
+### Monkey patch the string class
+
+With monkey patching you can access the same methods (except deconstantize) of LuckyCase directly from strings.
+Additionally they provide versions with exclamation mark for direct manipulation.
+
+```ruby
+require 'lucky_case/string'
+
+a = 'ExampleString'
+
+a.pascal_case?                          # => true
+a.snake_case                            # => 'example_string'
+a                                       # => 'ExampleString'
+# string variable manipulation
+a.snake_case!                           # => 'example_string'
+a                                       # => 'example_string'
+```
+
+
+
+
+
+<a name="installation"></a>
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'lucky_case'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself by:
+
+    $ gem install yaml_extend
+
+
+
+
+  
+<a name="documentation"></a>    
+## Documentation
+Check out the doc at RubyDoc
+<a href="https://www.rubydoc.info/gems/lucky_case">https://www.rubydoc.info/gems/lucky_case</a>
+
+
+
+
+
+<a name="contributing"></a>    
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/magynhard/lucky_case. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+#
+# run default task to see tasks to build and publish gem
+#
+task :default do
+  system 'rake --tasks'
+end
+
+RSpec::Core::RakeTask.new(:spec)

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "lucky_case"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/custom_errors/invalid_case_error.rb

@@ -0,0 +1,2 @@
+class InvalidCaseError < StandardError
+end

data/lib/lucky_case.rb

@@ -0,0 +1,648 @@
+require 'lucky_case/version'
+
+require_relative 'custom_errors/invalid_case_error'
+
+
+# LuckyCase
+#
+# Convert and detect various letter cases in strings
+#
+
+module LuckyCase
+
+  CASES = {
+      snake_case: /^[[:lower:]]{1}[[:lower:]_0-9]+$/,
+      upper_snake_case: /^[[:upper:]]{1}[[:upper:]_0-9]+$/,
+      pascal_case: /^[[:upper:]]{1}[[:upper:][:lower:]0-9]+$/,
+      camel_case: /^[[:lower:]]{1}[[:upper:][:lower:]0-9]+$/,
+      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]*$/,
+  }
+
+  FORMATS = {
+      capital: /^[[:upper:]]{1}.*$/,
+      upper_case: /^[^[:lower:]]+$/,
+      lower_case: /^[^[:upper:]]+$/,
+  }
+
+  # Get type of case of string (one key of LuckyCase.CASES)
+  #
+  # If more than one case matches, the first match wins.
+  # Match prio is the order of the regex in LuckyCase.CASES
+  #
+  # If you want or need to know all cases, use plural version of this method
+  #
+  # If you want to check explicitly for one case, use its check method,
+  # e.g. snake_case? for snake_case, etc...
+  #
+  # @param [String] string
+  # @param [Boolean] allow_prefixed_underscores
+  # @return [Symbol,nil] symbol of type, nil if no match
+  def self.case(string, allow_prefixed_underscores: true)
+    s = if allow_prefixed_underscores
+          cut_underscores_at_start string
+        else
+          string
+        end
+    CASES.each do |case_type, regex|
+      if s =~ regex
+        return case_type
+      end
+    end
+    nil
+  end
+
+  # Get types of cases of string (keys of LuckyCase.CASES)
+  #
+  # @param [String] string
+  # @param [Boolean] allow_prefixed_underscores
+  # @return [Array<Symbol>,nil] symbols of types, nil if no one matches
+  def self.cases(string, allow_prefixed_underscores: true)
+    s = if allow_prefixed_underscores
+          cut_underscores_at_start string
+        else
+          string
+        end
+    matched_cases = []
+    CASES.each do |case_type, regex|
+      if s =~ regex
+        matched_cases.push case_type
+      end
+    end
+    if matched_cases.empty?
+      nil
+      # reject mixed case if there are other matches
+      # because it would always be included if one other case matches
+    elsif matched_cases.size > 1
+      matched_cases.reject { |e| e == :mixed_case }
+    else
+      matched_cases
+    end
+  end
+
+  # Convert a string into the given case type
+  #
+  # @param [String] string
+  # @param [Symbol,String] case_type
+  # @param [Boolean] preserve_prefixed_underscores
+  # @return [String]
+  def self.convert_case(string, case_type, preserve_prefixed_underscores: true)
+    type = case_type.to_sym
+    if CASES.include? case_type.to_sym
+      return self.send type.to_s, string, preserve_prefixed_underscores: preserve_prefixed_underscores
+    end
+    error_message = "Invalid case type '#{case_type}'. Valid types are: #{CASES.keys.join(', ')}"
+    raise InvalidCaseError.new error_message
+  end
+
+  #----------------------------------------------------------------------------------------------------
+  # UPPER CASE
+  #----------------------------------------------------------------------------------------------------
+
+  # Converts all characters inside the string
+  # into upper case
+  #
+  # @example conversion
+  #   'this-isAnExample_string' => 'THIS-ISANEXAMPLE_STRING'
+  #
+  # @param [String] string to convert
+  # @return [String]
+  def self.upper_case(string)
+    string.upcase
+  end
+
+  # Checks if all characters inside the string are upper case
+  #
+  # @param [String] string to check
+  # @return [Boolean]
+  def self.upper_case?(string)
+    string == upper_case(string)
+  end
+
+  #----------------------------------------------------------------------------------------------------
+  # LOWER CASE
+  #----------------------------------------------------------------------------------------------------
+
+  # Converts all characters inside the string
+  # into lower case
+  #
+  # @example conversion
+  #   'this-isAnExample_string' => 'this-isanexample_string'
+  #
+  # @param [String] string to convert
+  # @return [String]
+  def self.lower_case(string)
+    string.downcase
+  end
+
+  # Checks if all characters inside the string are lower case
+  #
+  # @param [String] string to check
+  # @return [Boolean]
+  def self.lower_case?(string)
+    string == lower_case(string)
+  end
+
+  #----------------------------------------------------------------------------------------------------
+  # SNAKE CASE
+  #----------------------------------------------------------------------------------------------------
+
+  # Converts the given string from any case
+  # into snake 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.snake_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 snake case
+  #
+  # @param [String] string to check
+  # @param [Boolean] allow_prefixed_underscores
+  # @return [Boolean]
+  def self.snake_case?(string, allow_prefixed_underscores: true)
+    s = if allow_prefixed_underscores
+          cut_underscores_at_start string
+        else
+          string
+        end
+    _case_match? s, :snake_case
+  end
+
+  # Converts the given string from any case
+  # into upper snake 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_snake_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 snake case
+  #
+  # @param [String] string to check
+  # @param [Boolean] allow_prefixed_underscores
+  # @return [Boolean]
+  def self.upper_snake_case?(string, allow_prefixed_underscores: true)
+    s = if allow_prefixed_underscores
+          cut_underscores_at_start string
+        else
+          string
+        end
+    _case_match? s, :upper_snake_case
+  end
+
+  #----------------------------------------------------------------------------------------------------
+  # PASCAL CASE
+  #----------------------------------------------------------------------------------------------------
+
+  # Converts the given string from any case
+  # into pascal case
+  #
+  # @example conversion
+  #   'this-isAnExample_string' => 'ThisIsAnExampleString'
+  #
+  # @param [String] string to convert
+  # @param [Boolean] preserve_prefixed_underscores
+  # @return [String]
+  def self.pascal_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 upper pascal case
+  #
+  # @param [String] string to check
+  # @param [Boolean] allow_prefixed_underscores
+  # @return [Boolean]
+  def self.pascal_case?(string, allow_prefixed_underscores: true)
+    s = if allow_prefixed_underscores
+          cut_underscores_at_start string
+        else
+          string
+        end
+    _case_match? s, :pascal_case
+  end
+
+  #----------------------------------------------------------------------------------------------------
+  # CAMEL CASE
+  #----------------------------------------------------------------------------------------------------
+
+  # Converts the given string from any case
+  # into camel case
+  #
+  # @example conversion
+  #   'this-isAnExample_string' => 'thisIsAnExampleString'
+  #
+  # @param [String] string to convert
+  # @param [Boolean] preserve_prefixed_underscores
+  # @return [String]
+  def self.camel_case(string, preserve_prefixed_underscores: true)
+    a = split_case_string string
+    converted = ([a[0]] + a[1..-1].map { |e| capital e }).join('')
+    if preserve_prefixed_underscores
+      underscores_at_start(string) + converted
+    else
+      converted
+    end
+  end
+
+  # Checks if the string is camel case
+  #
+  # @param [String] string to check
+  # @param [Boolean] allow_prefixed_underscores
+  # @return [Boolean]
+  def self.camel_case?(string, allow_prefixed_underscores: true)
+    s = if allow_prefixed_underscores
+          cut_underscores_at_start string
+        else
+          string
+        end
+    _case_match? s, :camel_case
+  end
+
+  #----------------------------------------------------------------------------------------------------
+  # DASH CASE
+  #----------------------------------------------------------------------------------------------------
+
+  # Converts the given string from any case
+  # into dash 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.dash_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 dash case
+  #
+  # @param [String] string to check
+  # @param [Boolean] allow_prefixed_underscores
+  # @return [Boolean]
+  def self.dash_case?(string, allow_prefixed_underscores: true)
+    s = if allow_prefixed_underscores
+          cut_underscores_at_start string
+        else
+          string
+        end
+    _case_match? s, :dash_case
+  end
+
+  # Converts the given string from any case
+  # into upper dash 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_dash_case(string, preserve_prefixed_underscores: true)
+    s = dash_case string, preserve_prefixed_underscores: preserve_prefixed_underscores
+    upper_case s
+  end
+
+  # Checks if the string is upper dash case
+  #
+  # @param [String] string to check
+  # @param [Boolean] allow_prefixed_underscores
+  # @return [Boolean]
+  def self.upper_dash_case?(string, allow_prefixed_underscores: true)
+    s = if allow_prefixed_underscores
+          cut_underscores_at_start string
+        else
+          string
+        end
+    _case_match? s, :upper_dash_case
+  end
+
+  #----------------------------------------------------------------------------------------------------
+  # TRAIN CASE
+  #----------------------------------------------------------------------------------------------------
+
+  # Converts the given string from any case
+  # into train 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.train_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 train case
+  #
+  # @param [String] string to check
+  # @param [Boolean] allow_prefixed_underscores
+  # @return [Boolean]
+  def self.train_case?(string, allow_prefixed_underscores: true)
+    s = if allow_prefixed_underscores
+          cut_underscores_at_start string
+        else
+          string
+        end
+    _case_match? s, :train_case
+  end
+
+  #----------------------------------------------------------------------------------------------------
+  # CAPITALIZE
+  #----------------------------------------------------------------------------------------------------
+
+  # Converts the first character to capital
+  #
+  # @param [String] string to convert
+  # @param [Boolean] skip_prefixed_underscores
+  # @return [String]
+  def self.capital(string, skip_prefixed_underscores: false)
+    return string if string.empty?
+    s = if skip_prefixed_underscores
+          cut_underscores_at_start string
+        else
+          string
+        end
+    s = s[0].upcase + s[1..-1]
+    if skip_prefixed_underscores
+      underscores_at_start(string) + s
+    else
+      s
+    end
+  end
+
+  # Converts the first character to capital
+  #
+  # @param [String] string to convert
+  # @param [Boolean] skip_prefixed_underscores
+  # @return [String]
+  def self.capitalize(string, skip_prefixed_underscores: false)
+    capital string, skip_prefixed_underscores: skip_prefixed_underscores
+  end
+
+  # Checks if the strings first character is a capital letter
+  #
+  # @param [String] string to check
+  # @param [Boolean] skip_prefixed_underscores
+  # @return [Boolean]
+  def self.capital?(string, skip_prefixed_underscores: false)
+    s = if skip_prefixed_underscores
+          cut_underscores_at_start string
+        else
+          string
+        end
+    _case_match? s, :capital
+  end
+
+  # Checks if the strings first character is a capital letter
+  #
+  # @param [String] string to check
+  # @param [Boolean] skip_prefixed_underscores
+  # @return [Boolean]
+  def self.capitalized?(string, skip_prefixed_underscores: false)
+    capital? string, skip_prefixed_underscores: skip_prefixed_underscores
+  end
+
+  #----------------------------------------------------------------------------------------------------
+  # MIXED CASE
+  #----------------------------------------------------------------------------------------------------
+
+  # Converts the given string from any case
+  # into mixed case
+  #
+  # @example conversion
+  #   'this-isAnExample_string' => 'This-Is_anExample-string'
+  #
+  # @param [String] string to convert
+  # @param [Boolean] preserve_prefixed_underscores
+  # @return [String]
+  def self.mixed_case(string, preserve_prefixed_underscores: true)
+    a = split_case_string string
+    converted = ''
+    a.each do |part|
+      converted += self.send random_case, part
+    end
+    if preserve_prefixed_underscores
+      underscores_at_start(string) + converted
+    else
+      converted
+    end
+  end
+
+  # Checks if the string is a valid mixed case (without special characters!)
+  #
+  # @param [String] string to check
+  # @return [Boolean]
+  def self.mixed_case?(string)
+    _case_match? string, :mixed_case
+  end
+
+  #----------------------------------------------------------------------------------------------------
+  # SWAP CASE
+  #----------------------------------------------------------------------------------------------------
+
+  # Swaps character cases in string
+  #
+  # lower case to upper case
+  # upper case to lower case
+  # dash to underscore
+  # underscore to dash
+  #
+  # @example conversion
+  #   'this-isAnExample_string' => 'THIS_ISaNeXAMPLE-STRING'
+  #
+  # @param [String] string
+  # @param [Boolean] preserve_prefixed_underscores
+  # @return [String]
+  def self.swap_case(string, preserve_prefixed_underscores: false)
+    s = if preserve_prefixed_underscores
+          cut_underscores_at_start string
+        else
+          string
+        end
+    sp = s.split('')
+    sp.each_with_index do |char, i|
+      if char == '_'
+        sp[i] = '-'
+      elsif char == '-'
+        sp[i] = '_'
+      elsif lower_case? char
+        sp[i] = upper_case char
+      elsif upper_case? char
+        sp[i] = lower_case char
+      end
+    end
+    sp = sp.join('')
+    if preserve_prefixed_underscores
+      underscores_at_start(string) + sp
+    else
+      sp
+    end
+  end
+
+  #----------------------------------------------------------------------------------------------------
+  # CONSTANTIZE
+  #----------------------------------------------------------------------------------------------------
+
+  # Converts the string from any case
+  # into pascal case and casts it into a constant
+  #
+  # @example conversion
+  #   'this-isAnExample_string' => ThisIsAnExampleString
+  #   'this/is_an/example_path' => This::IsAn::ExamplePath
+  #
+  # @param [String] string to convert
+  # @param [Boolean] preserve_prefixed_underscores
+  # @return [Constant]
+  def self.constantize(string)
+    s = string.gsub('/','::')
+    constants = if s.include? '::'
+                  s.split('::')
+                else
+                  [s]
+                end
+    final_constant = constants.map { |e| pascal_case(e, preserve_prefixed_underscores: false) }.reject(&:empty?).join('::')
+    Object.const_get(final_constant)
+  end
+
+  # Deconverts the constant back into specified target type
+  #
+  # @example deconversion
+  #   This::AweSome::Constant => 'this/awe_some/constant'
+  #
+  # @param [Constant] constant to reconvert
+  # @param [Symbol,String] target can be :path, :string
+  # @param [Symbol,String] case_type can be any valid case of CASES
+  # @return [String]
+  def self.deconstantize(constant, target: :path, case_type: nil)
+    # defaults if none is set, depending on target
+    unless case_type
+      case_type = case target.to_sym
+                  when :path
+                    :snake_case
+                  when :string
+                    :pascal_case
+                  end
+    end
+    s = constant.name
+    split = if s.include? '::'
+              s.split('::')
+            else
+              [s]
+            end
+    reconverted_parts = split.map { |e| convert_case e, case_type }
+    case target.to_sym
+    when :path
+      reconverted_parts.join('/')
+    when :string
+      reconverted_parts.join('::')
+    end
+  end
+
+  #----------------------------------------------------------------------------------------------------
+  # HELPERS
+  #----------------------------------------------------------------------------------------------------
+
+  # Return string without underscores at the start
+  #
+  # @param [String] string
+  # @return [String] string without prefixed underscores
+  def self.cut_underscores_at_start(string)
+    underscore_counter = 0
+    string.split('').each do |c|
+      if c == '_'
+        underscore_counter += 1
+      else
+        break
+      end
+    end
+    string[underscore_counter..-1]
+  end
+
+  # Return the underscores at the start of the string
+  #
+  # @param [String] string
+  # @return [String] string of underscores or empty if none found
+  def self.underscores_at_start(string)
+    underscore_counter = 0
+    string.split('').each do |c|
+      if c == '_'
+        underscore_counter += 1
+      else
+        break
+      end
+    end
+    '_' * underscore_counter
+  end
+
+  # Split the string into parts
+  # It is splitted by all (different) case separators
+  #
+  # @param [String] string
+  # @return [Array<String>]
+  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 dashes with underscore
+    s = cut_underscores_at_start s
+    s.downcase.split('_').reject(&:empty?) # split everything by underscore
+  end
+
+  private
+
+  # Check if the given case matches the string
+  #
+  # @param [String] string
+  # @param [Symbol,String] case_to_match
+  # @return [Boolean]
+  def self._case_match?(string, case_to_match)
+    !!(string =~ CASES[case_to_match.to_sym])
+  end
+
+  #----------------------------------------------------------------------------------------------------
+
+end