strings-case 0.2.0 → 0.4.0

data/lib/strings/case.rb

@@ -1,304 +1,407 @@
 # frozen_string_literal: true
 
+require "forwardable"
+require "strscan"
+
+require_relative "case/acronyms"
+require_relative "case/configuration"
 require_relative "case/version"
 
 module Strings
-  module Case
-    DIGITS = ("0".."9").freeze
-    UP_LETTERS = ("A".."Z").freeze
-    DOWN_LETTERS = ("a".."z").freeze
+  # Responsible for converting strings to common cases
+  #
+  # @api public
+  class Case
+    # The word delimiters
+    #
+    # @return [Array<String>]
+    #
+    # @api private
     DELIMITERS = [" ", "\n", "\t", "_", ".", "-", "#", "?", "!"].freeze
-    NONALPHANUMERIC = (32..127).map(&:chr) -
-      (DIGITS.to_a + DOWN_LETTERS.to_a + UP_LETTERS.to_a + DELIMITERS)
-    UPCASE = /(?<!\p{Lu})\p{Lu}$/.freeze
+    private_constant :DELIMITERS
+
+    # The pattern to detect word delimiters
+    #
+    # @return [Regexp]
+    #
+    # @api private
+    DELIMS = Regexp.union(DELIMITERS)
+    private_constant :DELIMS
+
+    # The pattern to detect uppercase characters
+    #
+    # @return [Regexp]
+    #
+    # @api private
+    UPPERCASE = /^(\p{Ll}|\p{Digit})\p{Lu}/.freeze
+    private_constant :UPPERCASE
+
+    # The pattern to detect lowercase characters
+    #
+    # @return [Regexp]
+    #
+    # @api private
     LOWERCASE = /\p{Lu}(?=\p{Ll})/.freeze
+    private_constant :LOWERCASE
 
     class Error < StandardError; end
 
-    # Prevent changing case
-    module NullCase
-      def downcase
-        self
-      end
-      alias upcase downcase
-      alias capitalize downcase
+    # Global instance
+    #
+    # @return [Strings::Case]
+    #
+    # @api private
+    def self.__instance__
+      @__instance__ ||= Case.new
     end
+    private_class_method :__instance__
+
+    class << self
+      extend Forwardable
 
-    # Convert string to camel case:
-    # * start with a lowercase character
-    # * every subsequent word has its first character uppercased
-    # * all words are compounded together
+      delegate %i[camelcase constcase constantcase dashcase
+                  headercase kebabcase lower_camelcase
+                  pascalcase pathcase sentencecase snakecase
+                  titlecase underscore upper_camelcase] => :__instance__
+    end
+
+    # Create a Strings::Case instance
     #
     # @example
-    #   camelcase("foo bar baz") # => "fooBarBaz"
+    #   strings = Strings::Case.new(acronyms: %w[HTTP XML])
     #
-    # @param [String] string
-    #   the string to camelcase
-    # @param [Array[String]] acronyms
+    # @param [Array<String>] acronyms
     #   the acronyms to use to prevent modifications
-    # @param [String] separator
-    #   the separator for linking words, by default none
     #
     # @api public
-    def camelcase(string, acronyms: [], separator: "")
-      res = parsecase(string, acronyms: acronyms, sep: separator, casing: :capitalize)
+    def initialize(acronyms: nil)
+      configure(acronyms: acronyms)
+    end
 
-      return res if res.to_s.empty?
+    # Access configuration
+    #
+    # @example
+    #   strings.config
+    #
+    # @return [Strings::Case::Configuration]
+    #
+    # @api public
+    def config
+      @config ||= Configuration.new
+    end
 
-      acronyms_regex = /^(#{acronyms.join("|")})/
-      if !acronyms.empty? && (res =~ acronyms_regex)
-        res
+    # Configure acronyms
+    #
+    # @example
+    #   strings = Strings::Case.new
+    #   strings.configure do |config|
+    #     config.acronym "HTTP"
+    #   end
+    #
+    # @example
+    #   strings = Strings::Case.new
+    #   strings.configure(acronyms: %w[HTTP XML])
+    #
+    # @param [Array<String>] acronyms
+    #   the acronyms to use to prevent modifications
+    #
+    # @yield [Strings::Case::Configuration]
+    #
+    # @return [void]
+    #
+    # @api public
+    def configure(acronyms: nil)
+      if block_given?
+        yield config
       else
-        res[0].downcase + res[1..-1]
+        config.acronym(*acronyms)
       end
     end
-    module_function :camelcase
 
+    # Convert string to camel case
+    #
+    # @example
+    #   camelcase("foo bar baz") # => "fooBarBaz"
+    #
+    # @param [String] string
+    #   the string to convert to camel case
+    # @param [Array<String>] acronyms
+    #   the acronyms to use to prevent modifications
+    # @param [String] separator
+    #   the words separator, by default an empty string
+    #
+    # @return [String]
+    #
+    # @api public
+    def camelcase(string, acronyms: config.acronyms, separator: "")
+      acronyms = Acronyms.from(acronyms)
+      parsecase(string, acronyms: acronyms, sep: separator) do |word, i|
+        acronyms.fetch(word) || (i.zero? ? word.downcase : word.capitalize)
+      end
+    end
     alias lower_camelcase camelcase
-    module_function :lower_camelcase
 
-    # Converts string to a constant
+    # Convert string to constant case
     #
     # @example
     #   constantcase("foo bar baz") # => "FOO_BAR_BAZ"
     #
     # @param [String] string
-    #   the string to turn into constant
-    # @param [Array[String]] acronyms
+    #   the string to convert to constant case
+    # @param [Array<String>] acronyms
     #   the acronyms to use to prevent modifications
     # @param [String] separator
-    #   the words separator, by default "_"
+    #   the words separator, by default an underscore "_"
+    #
+    # @return [String]
     #
     # @api public
-    def constcase(string, separator: "_")
-      parsecase(string, sep: separator, casing: :upcase)
+    def constcase(string, acronyms: config.acronyms, separator: "_")
+      acronyms = Acronyms.from(acronyms)
+      parsecase(string, acronyms: acronyms, sep: separator, &:upcase)
     end
-    module_function :constcase
-
     alias constantcase constcase
-    module_function :constantcase
 
-    # Convert string to a HTTP Header
+    # Convert string to header case
     #
     # @example
     #   headercase("foo bar baz") # = "Foo-Bar-Baz"
     #
     # @param [String] string
-    #   the string to turn into header
-    # @param [Array[String]] acronyms
+    #   the string to convert to header case
+    # @param [Array<String>] acronyms
     #   the acronyms to use to prevent modifications
     # @param [String] separator
-    #   the words separator, by default "-"
+    #   the words separator, by default a hyphen "-"
+    #
+    # @return [String]
     #
     # @api public
-    def headercase(string, acronyms: [], separator: "-")
-      parsecase(string, acronyms: acronyms, sep: separator, casing: :capitalize)
+    def headercase(string, acronyms: config.acronyms, separator: "-")
+      acronyms = Acronyms.from(acronyms)
+      parsecase(string, acronyms: acronyms, sep: separator) do |word|
+        (acronym = acronyms.fetch(word)) ? acronym : word.capitalize
+      end
     end
-    module_function :headercase
 
-    # Converts string to lower case words linked by hyphenes
+    # Convert string to kebab case
     #
     # @example
     #   kebabcase("fooBarBaz") # => "foo-bar-baz"
     #
+    # @example
     #   kebabcase("__FOO_BAR__") # => "foo-bar"
     #
     # @param [String] string
-    #   the string to convert to dashed string
-    # @param [Array[String]] acronyms
+    #   the string to convert to kebab case
+    # @param [Array<String>] acronyms
     #   the acronyms to use to prevent modifications
     # @param [String] separator
-    #   the separator for linking words, by default hyphen
+    #   the words separator, by default a hyphen "-"
     #
     # @return [String]
     #
     # @api public
-    def kebabcase(string, acronyms: [], separator: "-")
-      parsecase(string, acronyms: acronyms, sep: separator)
+    def kebabcase(string, acronyms: config.acronyms, separator: "-")
+      acronyms = Acronyms.from(acronyms)
+      parsecase(string, acronyms: acronyms, sep: separator, &:downcase)
     end
-    module_function :kebabcase
-
     alias dashcase kebabcase
-    module_function :dashcase
 
-    # Convert string to pascal case:
-    # * every word has its first character uppercased
-    # * all words are compounded together
+    # Convert string to Pascal case
     #
     # @example
     #   pascalcase("foo bar baz") # => "FooBarBaz"
     #
     # @param [String] string
-    #   the string to convert to camel case with capital letter
-    # @param [Array[String]] acronyms
+    #   the string to convert to Pascal case
+    # @param [Array<String>] acronyms
     #   the acronyms to use to prevent modifications
     # @param [String] separator
-    #   the separator for linking words, by default none
+    #   the words separator, by default an empty string
+    #
+    # @return [String]
     #
     # @api public
-    def pascalcase(string, acronyms: [], separator: "")
-      parsecase(string, acronyms: acronyms, sep: separator, casing: :capitalize)
+    def pascalcase(string, acronyms: config.acronyms, separator: "")
+      acronyms = Acronyms.from(acronyms)
+      parsecase(string, acronyms: acronyms, sep: separator) do |word|
+        acronyms.fetch(word) || word.capitalize
+      end
     end
-    module_function :pascalcase
-
     alias upper_camelcase pascalcase
-    module_function :upper_camelcase
 
-    # Convert string into a file path.
-    #
-    # By default uses `/` as a path separator.
+    # Convert string to path case
     #
     # @example
     #   pathcase("foo bar baz") # => "foo/bar/baz"
     #
+    # @example
     #   pathcase("FooBarBaz") # => "foo/bar/baz"
     #
     # @param [String] string
-    #   the string to convert to file path
-    # @param [Array[String]] acronyms
+    #   the string to convert to path case
+    # @param [Array<String>] acronyms
     #   the acronyms to use to prevent modifications
     # @param [String] separator
-    #   the separator for linking words, by default `/`
+    #   the words separator, by default a forward slash "/"
+    #
+    # @return [String]
     #
     # @api public
-    def pathcase(string, acronyms: [], separator: "/")
-      parsecase(string, acronyms: acronyms, sep: separator)
+    def pathcase(string, acronyms: config.acronyms, separator: "/")
+      acronyms = Acronyms.from(acronyms)
+      parsecase(string, acronyms: acronyms, sep: separator, &:downcase)
     end
-    module_function :pathcase
 
-    # Convert string int a sentence
+    # Convert string to sentence case
     #
     # @example
     #   sentencecase("foo bar baz") # => "Foo bar baz"
     #
     # @param [String] string
-    #   the string to convert to sentence
-    # @param [Array[String]] acronyms
+    #   the string to convert to sentence case
+    # @param [Array<String>] acronyms
     #   the acronyms to use to prevent modifications
     # @param [String] separator
-    #   the separator for linking words, by default a space
+    #   the words separator, by default a space
+    #
+    # @return [String]
     #
     # @api public
-    def sentencecase(string, acronyms: [], separator: " ")
-      res = parsecase(string, acronyms: acronyms, sep: separator, casing: :downcase)
-
-      return res if res.to_s.empty?
-
-      res[0].upcase + res[1..-1]
+    def sentencecase(string, acronyms: config.acronyms, separator: " ")
+      acronyms = Acronyms.from(acronyms)
+      parsecase(string, acronyms: acronyms, sep: separator) do |word, i|
+        acronyms.fetch(word) || (i.zero? ? word.capitalize : word.downcase)
+      end
     end
-    module_function :sentencecase
 
-    # Convert string into a snake_case
+    # Convert string to snake case
     #
     # @example
     #   snakecase("foo bar baz") # => "foo_bar_baz"
     #
+    # @example
     #   snakecase("ЗдравствуйтеПривет") # => "здравствуйте_привет"
     #
+    # @example
     #   snakecase("HTTPResponse") # => "http_response"
     #
     # @param [String] string
     #   the string to convert to snake case
-    # @param [Array[String]] acronyms
+    # @param [Array<String>] acronyms
     #   the acronyms to use to prevent modifications
     # @param [String] separator
-    #   the separator for linking words, by default `_`
+    #   the words separator, by default an underscore "_"
+    #
+    # @return [String]
     #
     # @api public
-    def snakecase(string, acronyms: [], separator: "_")
-      parsecase(string, acronyms: acronyms, sep: separator)
+    def snakecase(string, acronyms: config.acronyms, separator: "_")
+      acronyms = Acronyms.from(acronyms)
+      parsecase(string, acronyms: acronyms, sep: separator, &:downcase)
     end
-    module_function :snakecase
-
     alias underscore snakecase
-    module_function :underscore
 
-    # Convert string into a title case
+    # Convert string to title case
     #
     # @example
     #   titlecase("foo bar baz") # => "Foo Bar Baz"
     #
     # @param [String] string
     #   the string to convert to title case
-    # @param [Array[String]] acronyms
+    # @param [Array<String>] acronyms
     #   the acronyms to use to prevent modifications
     # @param [String] separator
-    #   the separator for linking words, by default a space
+    #   the words separator, by default a space
+    #
+    # @return [String]
     #
     # @api public
-    def titlecase(string, acronyms: [], separator: " ")
-      parsecase(string, acronyms: acronyms, sep: separator, casing: :capitalize)
+    def titlecase(string, acronyms: config.acronyms, separator: " ")
+      acronyms = Acronyms.from(acronyms)
+      parsecase(string, acronyms: acronyms, sep: separator) do |word|
+        acronyms.fetch(word) || word.capitalize
+      end
     end
-    module_function :titlecase
+
+    private
 
     # Parse string and transform to desired case
     #
+    # @param [String] string
+    #   the string to convert to a given case
+    # @param [Strings::Case::Acronyms] acronyms
+    #   the acronyms to use to parse words
+    # @param [String] sep
+    #   the words separator, by default an underscore "_"
+    #
+    # @yield [word, index]
+    #
+    # @return [String]
+    #
     # @api private
-    def parsecase(string, acronyms: [], sep: "_", casing: :downcase)
+    def parsecase(string, acronyms: nil, sep: "_", &conversion)
       return if string.nil?
 
-      words = split_into_words(string, sep: sep)
-
-      no_case = ->(w) { acronyms.include?(w) ? w.extend(NullCase) : w }
-
-      words
-        .map(&no_case)
-        .map(&casing)
-        .join(sep)
+      none_or_index = conversion.arity <= 1 ? :map : :with_index
+      split_into_words(string, acronyms: acronyms, sep: sep)
+        .map.send(none_or_index, &conversion).join(sep)
     end
-    module_function :parsecase
-    private_class_method :parsecase
 
     # Split string into words
     #
-    # @return [Array[String]]
+    # @param [String] string
+    #   the string to split into words
+    # @param [Strings::Case::Acronyms] acronyms
+    #   the acronyms to use to split words
+    # @param [String] sep
+    #   the separator to use to split words
+    #
+    # @return [Array<String>]
     #   the split words
     #
     # @api private
-    def split_into_words(string, sep: nil)
+    def split_into_words(string, acronyms: nil, sep: nil)
       words = []
       word = []
-      last = string.length - 1
-
-      string.each_char.with_index do |char, i|
-        combine = word[-1].to_s + char
+      scanner = StringScanner.new(string)
 
-        if combine =~ UPCASE
-          if word.size <= 1 # don't allow single letter words
-            word << char
-          else
+      while !scanner.eos?
+        if scanner.match?(acronyms.pattern)
+          unless word.empty?
             words << word.join
-            word = [char]
+            word.clear
           end
-        elsif combine =~ LOWERCASE
-          letter = word.pop
-          if word.size <= 1 # don't allow single letter words
-            word << letter << char
-          else
-            words << word.join
-            word = [letter, char]
-          end
-        elsif DELIMITERS.include?(char)
+          scanner.scan(acronyms.pattern)
+          words << scanner.matched
+        elsif scanner.match?(UPPERCASE)
+          char = scanner.getch
+          word << char
+          words << word.join
+          word.clear
+        elsif scanner.match?(LOWERCASE)
+          char = scanner.getch
           words << word.join unless word.empty?
-          if i.zero? && char == sep
+          word = [char]
+        elsif scanner.match?(DELIMS)
+          char = scanner.getch
+          words << word.join unless word.empty?
+          if scanner.pos == 1 && char == sep
             words << ""
+          elsif scanner.eos? && char == sep
+            word = [""]
           else
-            word = []
+            word.clear
           end
-        elsif NONALPHANUMERIC.include?(char)
-          # noop
         else
-          word << char
-        end
-
-        if last == i
-          word = [""] if char == sep
-          words << word.join unless word.empty?
+          word << scanner.getch
         end
       end
 
+      words << word.join unless word.empty?
+
       words
     end
-    module_function :split_into_words
   end # Case
 end # Strings

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: strings-case
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Piotr Murach
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-11-23 00:00:00.000000000 Z
+date: 2023-11-19 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.5'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.5'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -42,56 +28,47 @@ dependencies:
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
 description: Convert strings to different cases
 email:
-- me@piotrmurach.com
+- piotr@piotrmurach.com
 executables: []
 extensions: []
-extra_rdoc_files: []
+extra_rdoc_files:
+- README.md
+- CHANGELOG.md
+- LICENSE.txt
 files:
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
-- Rakefile
 - lib/strings-case.rb
 - lib/strings/case.rb
+- lib/strings/case/acronyms.rb
+- lib/strings/case/configuration.rb
 - lib/strings/case/extensions.rb
 - lib/strings/case/version.rb
-- spec/spec_helper.rb
-- spec/unit/camelcase_spec.rb
-- spec/unit/constcase_spec.rb
-- spec/unit/extensions_spec.rb
-- spec/unit/headercase_spec.rb
-- spec/unit/kebabcase_spec.rb
-- spec/unit/pascalcase_spec.rb
-- spec/unit/pathcase_spec.rb
-- spec/unit/sentencecase_spec.rb
-- spec/unit/snakecase_spec.rb
-- spec/unit/titlecase_spec.rb
-- strings-case.gemspec
-- tasks/console.rake
-- tasks/coverage.rake
-- tasks/spec.rake
 homepage: https://github.com/piotrmurach/strings-case
 licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
+  bug_tracker_uri: https://github.com/piotrmurach/strings-case/issues
   changelog_uri: https://github.com/piotrmurach/strings-case/blob/master/CHANGELOG.md
   documentation_uri: https://www.rubydoc.info/gems/strings-case
   homepage_uri: https://github.com/piotrmurach/strings-case
+  rubygems_mfa_required: 'true'
   source_code_uri: https://github.com/piotrmurach/strings-case
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -106,8 +83,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
-signing_key: 
+rubygems_version: 3.4.10
+signing_key:
 specification_version: 4
 summary: Convert strings to different cases
 test_files: []

data/Rakefile

@@ -1,8 +0,0 @@
-require "bundler/gem_tasks"
-
-FileList["tasks/**/*.rake"].each(&method(:import))
-
-desc "Run all specs"
-task ci: %w[ spec ]
-
-task default: :spec