capitalize-names 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a8e58cd8d2216549bc0bd47a2f3ce851abbcf8eed7e404a84ec43593b81fe959
-  data.tar.gz: 77f0ce726f15d3ca5e793be5485c282b71fac70a9b7bd01df4d0c648fcb4e66b
+  metadata.gz: d5c58d13e6411f8264d9b0ea09069999d61bdd1fa5fb3abc0fa08eb2c2bf42aa
+  data.tar.gz: cead79413582058ea0c34f3f67efdcf323d4cfd62f78b9e61000f7b9b719ab09
 SHA512:
-  metadata.gz: e6dd722c7e906cef3d58c203da2a52d2274ddc115dd902169b02f6f80c34f3ff81c2484a3f86ca11a6cf41f0ffabad3a3dbe48911daa2b899dc539cf0e0c4738
-  data.tar.gz: f438bda12d9d4eac554b297f9e4044f4c7663197e32ed355fcb2701a1d1048252088057f82b19c2c8b3838bfe64468e18857251e7f62d872065333dd615cbf7f
+  metadata.gz: 480a2b269eb27e44d8999e2e9753e7edf0f35a9e3dd1416d7c21269b4a8813622486c084d038f24db5438e0d7e666fc2bfc61a5b754b20955ae9051f92eb5f74
+  data.tar.gz: b0bcf24008f2b9d107284964582b20b17d7c52d7861ff563ee5c38f1fe548c3e999bb4a2c46c11779b5ee3998f1862c514fddb646ce5d4de0452b54c94b735f1

data/lib/capitalize_names/capitalizer.rb

@@ -1,100 +1,171 @@
+# frozen_string_literal: true
+
 module CapitalizeNames
   class Capitalizer
-    attr_accessor :name
-
-    HYPHEN = /(\s*-\s*)/
-
-    MC = /^Mc(\w)(?=\w)/i 
-    MAC = /^Mac(\w)(?=\w)/i
-    O_APOSTROPHE = /^O'(\w)(?=\w)/i
-
-    def initialize(name)
+    attr_reader :name, :options
+
+    NAME = %r{
+      (                                                 # start capture
+        (?:                                             # start first name token
+          (?:(?:van\ )|(?:de\ (?:la\ )?)|(?:dit\ ))?    # optionally match one of van, de, de la, dit and space
+          (?:[[:alnum:]]|'|\(|\))+                      # match any unicode character, number, apostrophe or bracket
+        )                                               # end first name token
+        (?:                                             # start optional additional name tokens
+          -                                             # additional name tokens start with -
+          (?:                                           # start additional name token
+            (?:(?:van\ )|(?:de\ (?:la\ )?)|(?:dit\ ))?  # optionally match one of van, de, de la, dit and space
+            (?:[[:alnum:]]|'|\(|\))+                    # match any unicode character, number, apostrophe or bracket
+          )                                             # end additional name token
+        )*                                              # end optional additional name tokens
+      )                                                 # end capture
+    }ix
+
+    MC = /(?<=\A|-)Mc(\w)(?=\w)/i
+    MAC = /(?<=\A|-)Mac(\w)(?=\w)/i
+    O_APOSTROPHE = /(?<=\A|-)O'(\w)(?=\w)/i
+    VAN_SPACE = /(?<=\A|-)Van /i
+    DE_LA_SPACE = /(?<=\A|-)De La /i
+    DE_SPACE = /(?<=\A|-)De /i
+    DIT_SPACE = /(?<=\A|-)Dit /i
+
+    VALID_FORMATS = [:fullname, :firstname, :givenname, :lastname, :surname]
+
+    DEFAULT_OPTIONS = {
+      format: :fullname,
+      skip_mc: false,
+      skip_mac: false,
+      skip_o_apostrophe: false,
+      skip_van_space: false,
+      skip_de_space: false,
+      skip_de_la_space: false,
+      skip_dit_space: false,
+    }
+
+    SUFFIX_MAP = CapitalizeNames::SUFFIXES.each_with_object({}) { |suffix, map| map[suffix.downcase] = suffix }
+    SURNAME_MAP = CapitalizeNames::SURNAMES.each_with_object({}) { |surname, map| map[surname.downcase] = surname }
+
+    def initialize(name, options = {})
       @name = name
+      @options = DEFAULT_OPTIONS.merge(options)
     end
 
     def capitalize!
       can_process?
-      _capitalize
+      capitalize_name
     end
 
     def capitalize
-      begin
-        capitalize!
-      rescue CapitalizeNames::Errors::GenericError
-        name
-      end
+      capitalize!
+    rescue CapitalizeNames::Errors::GenericError
+      name
     end
 
     private
-      def can_process?
-        raise CapitalizeNames::Errors::InvalidName, "Cannot capitalize nil" unless name
-        true
+
+    def can_process?
+      raise CapitalizeNames::Errors::InvalidName, "Cannot capitalize nil" unless name
+
+      true
+    end
+
+    def name_format
+      @name_format ||= validate_name_format
+    end
+
+    def validate_name_format
+      unless VALID_FORMATS.include?(options[:format])
+        raise CapitalizeNames::Errors::InvalidOption,
+          "Invalid format: #{@options[:format]}, must be one of #{VALID_FORMATS.join(", ")}"
       end
 
-      def surname_suffix_position?(position, name, surname_or_suffix)
-        # surname/suffix must be:
-        # 1. at start of name or after a space or a -
-        #          -and-
-        # 2. followed by the end of string or a space or a -
-        (
-          (position == 0) || \
-          (
-            position > 0 && (name[position-1] == ' ' || name[position-1] == '-')
-          )
-        ) && (
-          (name.length == position+surname_or_suffix.length) || \
-          (name[position+surname_or_suffix.length] == ' ') || (name[position+surname_or_suffix.length] == '-')
-        )
+      options[:format]
+    end
+
+    def tokenize_name
+      name.split(NAME).map do |token|
+        {
+          value: token,
+          is_name: token.match?(NAME),
+        }
       end
+    end
 
-      def _capitalize
-        _name = name
+    def suffix?(str)
+      SUFFIX_MAP.key?(str.downcase)
+    end
 
-        hyphens = []
+    def surname?(str)
+      SURNAME_MAP.key?(str.downcase)
+    end
 
-        while (match = _name.match(HYPHEN)) do
-          _start = match.begin(1)
-          _end = match.end(1)
-          _value = match[1]
+    def capitalize_str(str, surname_rules)
+      str.split(/(\s|-)/).map do |word|
+        next word if word.match?(/(\s|-)/)
 
-          if _start == 0
-            _name = _name[_end..-1]
-          else
-            _name = _name[0..._start] << ' ' << _name[_end..-1]
-          end
+        output = word.capitalize
+        next output unless surname_rules
+        next capitalize_surname(output) if surname?(output)
 
-          hyphens << [_start, _end, _value]
-        end
+        output = output.gsub(MC) { "Mc#{Regexp.last_match(1).upcase}" } unless options[:skip_mc]
+        output = output.gsub(MAC) { "Mac#{Regexp.last_match(1).upcase}" } unless options[:skip_mac]
+        output = output.gsub(O_APOSTROPHE) { "O'#{Regexp.last_match(1).upcase}" } unless options[:skip_o_apostrophe]
 
-        _name = _name.split.map{ |w| 
-          w.mb_chars.capitalize.to_str 
-        }.map{ |w|
-          w.gsub(MC) { "Mc#{$1.upcase}" }\
-           .gsub(MAC) { "Mac#{$1.upcase}" }\
-           .gsub(O_APOSTROPHE) { "O'#{$1.upcase}" }
-        }
+        output
+      end.join("")
+    end
+
+    def capitalize_givenname(str)
+      capitalize_str(str, false)
+    end
 
-        _name = _name.join(" ")
+    def capitalize_suffix(str)
+      SUFFIX_MAP[str.downcase]
+    end
+
+    def capitalize_surname(str)
+      SURNAME_MAP[str.downcase]
+    end
+
+    def capitalize_lastname(str)
+      return capitalize_suffix(str) if suffix?(str)
+
+      output = capitalize_str(str, true)
+
+      output = output.gsub(VAN_SPACE, "van ") unless options[:skip_van_space]
+      output = output.gsub(DIT_SPACE, "dit ") unless options[:skip_dit_space]
+
+      if output.match?(DE_LA_SPACE)
+        output = output.gsub(DE_LA_SPACE, "de la ") unless options[:skip_de_la_space]
+      else
+        output = output.gsub(DE_SPACE, "de ") unless options[:skip_de_space]
+      end
 
-        hyphens.reverse.each do |_start, _end, _value|
-          if _start == 0
-            _name = _value << _name
+      output
+    end
+
+    def capitalize_name
+      tokens = tokenize_name
+
+      has_capitalized_last_name = false
+
+      tokens.reverse.map do |token|
+        token_value = token[:value]
+        next token_value unless token[:is_name]
+
+        case name_format
+        when :firstname, :givenname
+          capitalize_givenname(token_value)
+        when :lastname, :surname
+          capitalize_lastname(token_value)
+        else
+          if has_capitalized_last_name
+            capitalize_givenname(token_value)
           else
-            _name = _name[0..._start] << _value << (_name[_start+1..-1] || "")
+            has_capitalized_last_name = !suffix?(token_value)
+            capitalize_lastname(token_value)
           end
         end
-            
-        _name = _name.gsub("Van ", "van ").gsub("De ", "de ").gsub("Dit ", "dit ")
-        _name << " "
-
-        (CapitalizeNames::SURNAMES + CapitalizeNames::SUFFIXES).each do |surname_or_suffix|
-          position = _name.downcase.index(surname_or_suffix.downcase)
-          if position and surname_suffix_position?(position, _name, surname_or_suffix)
-            _name = _name[0...position] << surname_or_suffix << _name[position+surname_or_suffix.length..-1]
-          end
-        end
-
-        _name[0...-1]
-      end
+      end.reverse.join("")
+    end
   end
-end
+end

data/lib/capitalize_names/errors.rb

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 module CapitalizeNames
   module Errors
-    class GenericError < Exception; end
+    class GenericError < StandardError; end
     class InvalidName < GenericError; end
+    class InvalidOption < GenericError; end
   end
 end

data/lib/capitalize_names/suffixes.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module CapitalizeNames
   SUFFIXES = [
     "II",
@@ -17,6 +19,6 @@ module CapitalizeNames
     "4th",
     "(4th)",
     "5th",
-    "(5th)"
+    "(5th)",
   ]
-end
+end

data/lib/capitalize_names/surnames.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module CapitalizeNames
   SURNAMES = [
     "ApShaw",
@@ -330,6 +332,7 @@ module CapitalizeNames
     "Mackartee",
     "Mackay",
     "Macken",
+    "Mackenzie",
     "Mackert",
     "Mackey",
     "Mackie",
@@ -584,6 +587,6 @@ module CapitalizeNames
     "VonSeldern",
     "VonSpringer",
     "VonVeyelmann",
-    "VonZweidorff"
+    "VonZweidorff",
   ]
-end
+end

data/lib/capitalize_names/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module CapitalizeNames
-  VERSION = "1.1.0"
+  VERSION = "1.2.0"
 end

data/lib/capitalize_names.rb

@@ -1,20 +1,19 @@
-#based on http://dzone.com/snippets/capitalize-proper-names
-require 'capitalize_names/errors'
-require 'capitalize_names/capitalizer'
-require 'capitalize_names/suffixes'
-require 'capitalize_names/surnames'
-require 'active_support/core_ext/string/multibyte'
+# frozen_string_literal: true
 
-module CapitalizeNames
+# originally based on http://dzone.com/snippets/capitalize-proper-names
+require "capitalize_names/errors"
+require "capitalize_names/suffixes"
+require "capitalize_names/surnames"
+require "capitalize_names/capitalizer"
 
+module CapitalizeNames
   class << self
-
-    def capitalize!(name)
-      Capitalizer.new(name).capitalize!
+    def capitalize!(name, options = {})
+      Capitalizer.new(name, options).capitalize!
     end
 
-    def capitalize(name)
-      Capitalizer.new(name).capitalize
+    def capitalize(name, options = {})
+      Capitalizer.new(name, options).capitalize
     end
   end
-end
+end

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: capitalize-names
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Kyle Tate
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-09-20 00:00:00.000000000 Z
+date: 2022-07-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3'
-  type: :runtime
+        version: '0'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -39,7 +39,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-shopify
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -68,24 +82,23 @@ homepage: http://github.com/infiton/capitalize-names
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: '2.0'
+      version: '2.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
-signing_key: 
+rubygems_version: 3.3.7
+signing_key:
 specification_version: 4
 summary: Capitalizes names; handles edge cases.
 test_files: []