lucky_case 0.1.0

data/lib/lucky_case/string.rb

@@ -0,0 +1,413 @@
+
+require_relative '../lucky_case'
+
+# LuckyCase version to add methods directly to string by monkey patching
+#
+#   can be included this way by
+#   require 'lucky_case/string'
+#
+
+class String
+
+  # 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 [Boolean] allow_prefixed_underscores
+  # @return [Symbol,nil] symbol of type, nil if no match
+  def lucky_case(allow_prefixed_underscores: true)
+    LuckyCase.case self, allow_prefixed_underscores: allow_prefixed_underscores
+  end
+
+  # Get types of cases of string (keys of LuckyCase.CASES)
+  #
+  # @param [Boolean] allow_prefixed_underscores
+  # @return [Array<Symbol>,nil] symbols of types, nil if no one matches
+  def lucky_cases(allow_prefixed_underscores: true)
+    LuckyCase.cases self, allow_prefixed_underscores: allow_prefixed_underscores
+  end
+
+  # Convert a string into the given case type
+  #
+  # @param [Symbol,String] case_type
+  # @param [Boolean] preserve_prefixed_underscores
+  # @return [String]
+  def convert_case(case_type, preserve_prefixed_underscores: true)
+    LuckyCase.convert_case self, case_type, preserve_prefixed_underscores: preserve_prefixed_underscores
+  end
+
+  def convert_case!(case_type, preserve_prefixed_underscores: true)
+    set_self_value self.convert_case(case_type, preserve_prefixed_underscores: preserve_prefixed_underscores)
+  end
+
+  #----------------------------------------------------------------------------------------------------
+  # UPPER CASE
+  #----------------------------------------------------------------------------------------------------
+
+  # Converts all characters inside the string
+  # into upper case
+  #
+  # @example conversion
+  #   'this-isAnExample_string' => 'THIS-ISANEXAMPLE_STRING'
+  #
+  # @return [String]
+  def upper_case()
+    LuckyCase.upper_case self
+  end
+
+  def upper_case!()
+    set_self_value self.upper_case
+  end
+
+  # Checks if all characters inside the string are upper case
+  #
+  # @return [Boolean]
+  def upper_case?()
+    LuckyCase.upper_case? self
+  end
+
+  #----------------------------------------------------------------------------------------------------
+  # LOWER CASE
+  #----------------------------------------------------------------------------------------------------
+
+  # Converts all characters inside the string
+  # into lower case
+  #
+  # @example conversion
+  #   'this-isAnExample_string' => 'this-isanexample_string'
+  #
+  # @return [String]
+  def lower_case()
+    LuckyCase.lower_case self
+  end
+
+  def lower_case!()
+    set_self_value self.lower_case
+  end
+
+  # Checks if all characters inside the string are lower case
+  #
+  # @return [Boolean]
+  def lower_case?()
+    LuckyCase.lower_case? self
+  end
+
+  #----------------------------------------------------------------------------------------------------
+  # SNAKE CASE
+  #----------------------------------------------------------------------------------------------------
+
+  # Converts the given string from any case
+  # into snake case
+  #
+  # @example conversion
+  #   'this-isAnExample_string' => 'this_is_an_example_string'
+  #
+  # @param [Boolean] preserve_prefixed_underscores
+  # @return [String]
+  def snake_case(preserve_prefixed_underscores: true)
+    LuckyCase.snake_case self, preserve_prefixed_underscores: preserve_prefixed_underscores
+  end
+
+  def snake_case!(preserve_prefixed_underscores: true)
+    set_self_value self.snake_case preserve_prefixed_underscores: preserve_prefixed_underscores
+  end
+
+  # Checks if the string is snake case
+  #
+  # @param [Boolean] allow_prefixed_underscores
+  # @return [Boolean]
+  def snake_case?(allow_prefixed_underscores: true)
+    LuckyCase.snake_case? self, allow_prefixed_underscores: allow_prefixed_underscores
+  end
+
+  # Converts the given string from any case
+  # into upper snake case
+  #
+  # @example conversion
+  #   'this-isAnExample_string' => 'THIS_IS_AN_EXAMPLE_STRING'
+  #
+  # @param [Boolean] preserve_prefixed_underscores
+  # @return [String]
+  def upper_snake_case(preserve_prefixed_underscores: true)
+    LuckyCase.upper_snake_case self, preserve_prefixed_underscores: preserve_prefixed_underscores
+  end
+
+  def upper_snake_case!(preserve_prefixed_underscores: true)
+    set_self_value self.upper_snake_case preserve_prefixed_underscores: preserve_prefixed_underscores
+  end
+
+  # Checks if the string is upper snake case
+  #
+  # @param [Boolean] allow_prefixed_underscores
+  # @return [Boolean]
+  def upper_snake_case?(allow_prefixed_underscores: true)
+    LuckyCase.upper_snake_case? self, allow_prefixed_underscores: allow_prefixed_underscores
+  end
+
+  #----------------------------------------------------------------------------------------------------
+  # PASCAL CASE
+  #----------------------------------------------------------------------------------------------------
+
+  # Converts the given string from any case
+  # into pascal case
+  #
+  # @example conversion
+  #   'this-isAnExample_string' => 'ThisIsAnExampleString'
+  #
+  # @param [Boolean] preserve_prefixed_underscores
+  # @return [String]
+  def pascal_case(preserve_prefixed_underscores: true)
+    LuckyCase.pascal_case self, preserve_prefixed_underscores: preserve_prefixed_underscores
+  end
+
+  def pascal_case!(preserve_prefixed_underscores: true)
+    set_self_value self.pascal_case preserve_prefixed_underscores: preserve_prefixed_underscores
+  end
+
+  # Checks if the string is upper pascal case
+  #
+  # @param [Boolean] allow_prefixed_underscores
+  # @return [Boolean]
+  def pascal_case?(allow_prefixed_underscores: true)
+    LuckyCase.pascal_case? self, allow_prefixed_underscores: allow_prefixed_underscores
+  end
+
+  #----------------------------------------------------------------------------------------------------
+  # CAMEL CASE
+  #----------------------------------------------------------------------------------------------------
+
+  # Converts the given string from any case
+  # into camel case
+  #
+  # @example conversion
+  #   'this-isAnExample_string' => 'thisIsAnExampleString'
+  #
+  # @param [Boolean] preserve_prefixed_underscores
+  # @return [String]
+  def camel_case(preserve_prefixed_underscores: true)
+    LuckyCase.camel_case self, preserve_prefixed_underscores: preserve_prefixed_underscores
+  end
+
+  def camel_case!(preserve_prefixed_underscores: true)
+    set_self_value self.camel_case preserve_prefixed_underscores: preserve_prefixed_underscores
+  end
+
+  # Checks if the string is camel case
+  #
+  # @param [Boolean] allow_prefixed_underscores
+  # @return [Boolean]
+  def camel_case?(allow_prefixed_underscores: true)
+    LuckyCase.camel_case? self, allow_prefixed_underscores: allow_prefixed_underscores
+  end
+
+  #----------------------------------------------------------------------------------------------------
+  # DASH CASE
+  #----------------------------------------------------------------------------------------------------
+
+  # Converts the given string from any case
+  # into dash case
+  #
+  # @example conversion
+  #   'this-isAnExample_string' => 'this-is-an-example-string'
+  #
+  # @param [Boolean] preserve_prefixed_underscores
+  # @return [String]
+  def dash_case(preserve_prefixed_underscores: true)
+    LuckyCase.dash_case self, preserve_prefixed_underscores: preserve_prefixed_underscores
+  end
+
+  def dash_case!(preserve_prefixed_underscores: true)
+    set_self_value self.dash_case preserve_prefixed_underscores: preserve_prefixed_underscores
+  end
+
+  # Checks if the string is dash case
+  #
+  # @param [Boolean] allow_prefixed_underscores
+  # @return [Boolean]
+  def dash_case?(allow_prefixed_underscores: true)
+    LuckyCase.dash_case? self, allow_prefixed_underscores: allow_prefixed_underscores
+  end
+
+  # Converts the given string from any case
+  # into upper dash case
+  #
+  # @example conversion
+  #   'this-isAnExample_string' => 'THIS-IS-AN-EXAMPLE-STRING'
+  #
+  # @param [Boolean] preserve_prefixed_underscores
+  # @return [String]
+  def upper_dash_case(preserve_prefixed_underscores: true)
+    LuckyCase.upper_dash_case self, preserve_prefixed_underscores: preserve_prefixed_underscores
+  end
+
+  def upper_dash_case!(preserve_prefixed_underscores: true)
+    set_self_value self.upper_dash_case preserve_prefixed_underscores: preserve_prefixed_underscores
+  end
+
+  # Checks if the string is upper dash case
+  #
+  # @param [Boolean] allow_prefixed_underscores
+  # @return [Boolean]
+  def upper_dash_case?(allow_prefixed_underscores: true)
+    LuckyCase.upper_dash_case? self, allow_prefixed_underscores: allow_prefixed_underscores
+  end
+
+  #----------------------------------------------------------------------------------------------------
+  # TRAIN CASE
+  #----------------------------------------------------------------------------------------------------
+
+  # Converts the given string from any case
+  # into train case
+  #
+  # @example conversion
+  #   'this-isAnExample_string' => 'This-Is-An-Example-String'
+  #
+  # @param [Boolean] preserve_prefixed_underscores
+  # @return [String]
+  def train_case(preserve_prefixed_underscores: true)
+    LuckyCase.train_case self, preserve_prefixed_underscores: preserve_prefixed_underscores
+  end
+
+  def train_case!(preserve_prefixed_underscores: true)
+    set_self_value self.train_case preserve_prefixed_underscores: preserve_prefixed_underscores
+  end
+
+  # Checks if the string is train case
+  #
+  # @param [Boolean] allow_prefixed_underscores
+  # @return [Boolean]
+  def train_case?(allow_prefixed_underscores: true)
+    LuckyCase.train_case? self, allow_prefixed_underscores: allow_prefixed_underscores
+  end
+
+  #----------------------------------------------------------------------------------------------------
+  # CAPITALIZE
+  #----------------------------------------------------------------------------------------------------
+
+  # Converts the first character to capital
+  #
+  # @param [Boolean] skip_prefixed_underscores
+  # @return [String]
+  def capital(skip_prefixed_underscores: false)
+    LuckyCase.capitalize self, skip_prefixed_underscores: skip_prefixed_underscores
+  end
+
+  # Converts the first character to capital
+  #
+  # @param [Boolean] skip_prefixed_underscores
+  # @return [String]
+  def capitalize(skip_prefixed_underscores: false)
+    self.capital skip_prefixed_underscores: skip_prefixed_underscores
+  end
+
+  def capital!(skip_prefixed_underscores: false)
+    set_self_value self.capitalize skip_prefixed_underscores: skip_prefixed_underscores
+  end
+
+  def capitalize!(skip_prefixed_underscores: false)
+    self.capital! skip_prefixed_underscores: skip_prefixed_underscores
+  end
+
+  # Checks if the strings first character is a capital letter
+  #
+  # @param [Boolean] skip_prefixed_underscores
+  # @return [Boolean]
+  def capital?(skip_prefixed_underscores: false)
+    LuckyCase.capital? self, skip_prefixed_underscores: skip_prefixed_underscores
+  end
+
+  # Checks if the strings first character is a capital letter
+  #
+  # @param [Boolean] skip_prefixed_underscores
+  # @return [Boolean]
+  def capitalized?(skip_prefixed_underscores: false)
+    self.capital? 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 [Boolean] preserve_prefixed_underscores
+  # @return [String]
+  def mixed_case(preserve_prefixed_underscores: true)
+    LuckyCase.mixed_case self, preserve_prefixed_underscores: preserve_prefixed_underscores
+  end
+
+  def mixed_case!(preserve_prefixed_underscores: true)
+    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!)
+  #
+  # @return [Boolean]
+  def mixed_case?()
+    LuckyCase.mixed_case? self
+  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 [Boolean] preserve_prefixed_underscores
+  # @return [String]
+  def swap_case(preserve_prefixed_underscores: false)
+    LuckyCase.swap_case self, preserve_prefixed_underscores: preserve_prefixed_underscores
+  end
+
+  #----------------------------------------------------------------------------------------------------
+
+  def swap_case!(preserve_prefixed_underscores: false)
+    set_self_value self.swap_case preserve_prefixed_underscores: preserve_prefixed_underscores
+  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 [Boolean] preserve_prefixed_underscores
+  # @return [Constant]
+  def constantize()
+    LuckyCase.constantize self
+  end
+
+  #----------------------------------------------------------------------------------------------------
+  # HELPERS
+  #----------------------------------------------------------------------------------------------------
+
+  private
+  
+  def set_self_value(val)
+    self.gsub!(self, val)
+  end
+  
+end

data/lib/lucky_case/version.rb

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

data/lucky_case.gemspec

@@ -0,0 +1,37 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'lucky_case/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "lucky_case"
+  spec.version       = LuckyCase::VERSION
+  spec.authors       = ["Matthäus J. N. Beyrle"]
+  spec.email         = ["lucky_case.gemspec@mail.magynhard.de"]
+
+  spec.summary       = %q{The lucky ruby gem to identify and convert strings from any letter case to another}
+  spec.homepage      = "https://github.com/magynhard/lucky_case"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '>= 2.3'
+
+  spec.add_development_dependency 'bundler',  '>= 2.0'
+  spec.add_development_dependency 'rake',     '>= 10.0'
+  spec.add_development_dependency 'rspec',    '>= 3.0'
+end