name_tamer 0.6.0 → 1.0.0

data/lib/name_tamer/name.rb

@@ -1,3 +1,9 @@
+# frozen_string_literal: true
+
+require_relative 'name/private_methods_nice_name'
+require_relative 'name/private_methods_simple_name'
+require_relative 'name/utilities'
+
 module NameTamer
   class Name
     # References:
@@ -50,7 +56,7 @@ module NameTamer
         remove_periods_from_initials # "J.P.R. Williams" -> "JPR Williams"
         standardize_words # "B&Q Intl" -> "B and Q International"
 
-        @simple_name.whitespace_to!(ASCII_SPACE)
+        @simple_name = Strings.whitespace_to(@simple_name, ASCII_SPACE)
       end
 
       @simple_name
@@ -70,228 +76,20 @@ module NameTamer
     end
 
     def contact_type=(new_contact_type)
-      ct_as_sym = new_contact_type.to_sym
-
-      unless @contact_type.nil? || @contact_type == ct_as_sym
-        puts "Changing contact type of #{@name} from #{@contact_type} to #{new_contact_type}"
-      end
-
-      @contact_type = ct_as_sym
+      @contact_type = new_contact_type.to_sym
     end
 
     # Useful method for iterating through the words in the name
-    def each_word(&block)
+    def each_word(&)
       @words ||= slug.split(SLUG_DELIMITER)
-      @words.each(&block)
+      @words.each(&)
     end
 
-    # These lines aren't used and aren't covered by specs
-    #   def name=(new_name)
-    #     initialize new_name, :contact_type => @contact_type
-    #   end
-    #
-    #   def to_hash
-    #     {
-    #       name:         name,
-    #       nice_name:    nice_name,
-    #       simple_name:  simple_name,
-    #       slug:         slug,
-    #       contact_type: contact_type,
-    #       last_name:    last_name,
-    #       remainder:    remainder,
-    #       adfix_found:  adfix_found
-    #     }
-    #   end
-
     private
 
-    #--------------------------------------------------------
-    # Tidy up the name we've received
-    #--------------------------------------------------------
-
-    def unescape
-      @tidy_name.ensure_safe!.safe_unescape!.unescape_html!
-    end
-
-    def remove_zero_width
-      @tidy_name.strip_unwanted!(ZERO_WIDTH_FILTER)
-    end
-
-    def tidy_spacing
-      @tidy_name
-        .space_around_comma!
-        .strip_or_self!
-        .whitespace_to!(ASCII_SPACE)
-    end
-
-    def fix_encoding_errors
-      @tidy_name.fix_encoding_errors!
-    end
-
-    # Remove spaces from groups of initials
-    def consolidate_initials
-      @tidy_name
-        .remove_spaces_from_initials!
-        .ensure_space_after_initials!
-    end
-
-    # An adfix is either a prefix or a suffix
-    def remove_adfixes
-      if @last_name.nil?
-        # Our name is still in one part, not two
-        loop do
-          @nice_name = remove_outermost_adfix(:suffix, @nice_name)
-          break unless @adfix_found
-        end
-
-        loop do
-          @nice_name = remove_outermost_adfix(:prefix, @nice_name)
-          break unless @adfix_found
-        end
-      else
-        # Our name is currently in two halves
-        loop do
-          @last_name = remove_outermost_adfix(:suffix, @last_name)
-          break unless @adfix_found
-        end
-
-        loop do
-          @remainder = remove_outermost_adfix(:prefix, @remainder)
-          break unless @adfix_found
-        end
-      end
-    end
-
-    # Names in the form "Smith, John" need to be turned around to "John Smith"
-    def fixup_last_name_first
-      return if @contact_type == :organization
-
-      parts = @nice_name.split ', '
-
-      return unless parts.count == 2
-
-      @last_name = parts[0] # Sometimes the last name alone is all caps and we can name-case it
-      @remainder = parts[1]
-    end
-
-    # Sometimes we end up with mismatched braces after adfix stripping
-    # e.g. "Ceres (Ceres Holdings LLC)" -> "Ceres (Ceres Holdings"
-    def fixup_mismatched_braces
-      left_brace_count = @nice_name.count '('
-      right_brace_count = @nice_name.count ')'
-
-      if left_brace_count > right_brace_count
-        @nice_name += ')'
-      elsif left_brace_count < right_brace_count
-        @nice_name = '(' + @nice_name
-      end
-    end
-
-    def name_wrangle
-      # Fix case if all caps or all lowercase
-      if @last_name.nil?
-        name_wrangle_single_name
-      else
-        name_wrangle_split_name
-      end
-    end
-
-    def name_wrangle_single_name
-      lowercase = @nice_name.downcase
-      uppercase = @nice_name.upcase
-      fix_case = false
-
-      if @contact_type == :organization
-        fix_case = true if @nice_name == uppercase && @nice_name.length > 4
-      elsif [uppercase, lowercase].include?(@nice_name)
-        fix_case = true
-      end
-
-      @nice_name = name_case(lowercase) if fix_case
-    end
-
-    def name_wrangle_split_name
-      # It's a person if we've split the name, so no organization logic here
-      lowercase = @last_name.downcase
-      uppercase = @last_name.upcase
-      @last_name = name_case(lowercase) if [uppercase, lowercase].include?(@last_name)
-      @nice_name = "#{@remainder} #{@last_name}"
-    end
-
-    # Conjoin compound names with non-breaking spaces
-    def use_nonbreaking_spaces_in_compound_names
-      @nice_name
-        .nbsp_in_compound_name!
-        .nbsp_in_name_modifier!
-    end
-
-    #--------------------------------------------------------
-    # Make search name from nice name
-    #--------------------------------------------------------
-
-    # Remove initials from personal names unless they are the only identifier.
-    # i.e. only remove initials if there's also a proper name there
-    def remove_initials
-      return unless @contact_type == :person
-
-      temp_name = @simple_name.gsub(/\b([a-z](?:\.*\s+|\.))/i, '')
-
-      # If the name still has at least one space we're OK
-      @simple_name = temp_name if temp_name.include?(ASCII_SPACE)
-    end
-
-    def remove_middle_names
-      return unless @contact_type == :person
-
-      first_name, parts = find_first_usable_name(@simple_name.split)
-      last_name, = find_last_usable_name(parts)
-
-      return unless first_name || last_name
-
-      separator = first_name && last_name ? ' ' : ''
-      @simple_name = "#{first_name}#{separator}#{last_name}"
-    end
-
-    def find_first_usable_name(parts)
-      part = nil
-
-      parts.each_index do |i|
-        part = parts[i]
-        next if part.gsub(FILTER_COMPAT, '').empty?
-        parts = parts.slice(i + 1, parts.length) # don't use "slice!"
-        break
-      end
-
-      [part, parts]
-    end
-
-    def find_last_usable_name(parts)
-      part = nil
-
-      parts.reverse_each do |p|
-        next if p.gsub(FILTER_COMPAT, '').empty?
-        part = p
-        break
-      end
-
-      part
-    end
-
-    def remove_periods_from_initials
-      @simple_name.remove_periods_from_initials!
-    end
-
-    def standardize_words
-      @simple_name.gsub!(/ *& */, ' and ') # replace ampersand characters with ' and '
-      @simple_name.gsub!(/ *\+ */, ' plus ') # replace plus signs with ' plus '
-      @simple_name.gsub!(/\bintl\b/i, 'International') # replace 'intl' with 'International'
-      @simple_name.gsub!(/[־‐‑‒–—―−﹘﹣－]/, SLUG_DELIMITER) # Replace Unicode dashes with ASCII hyphen
-      @simple_name.strip_unwanted!(/["“”™℠®©℗]/) # remove quotes and commercial decoration
-    end
-
-    #--------------------------------------------------------
-    # Initialization and utilities
-    #--------------------------------------------------------
+    include Name::PrivateMethodsNiceName
+    include Name::PrivateMethodsSimpleName
+    include Name::Utilities
 
     def initialize(new_name, args = {})
       @name = new_name || ''
@@ -307,84 +105,5 @@ module NameTamer
 
       @adfix_found = false
     end
-
-    def contact_type_from(args)
-      args_ct = args[:contact_type]
-      return unless args_ct
-
-      ct = args_ct.is_a?(Symbol) ? args_ct : args_ct.dup
-      ct = ct.to_s unless [String, Symbol].include? ct.class
-      ct.downcase! if ct.class == String
-      ct = ct.to_sym
-      ct = nil unless %i[person organization].include? ct
-
-      ct
-    end
-
-    # If we don't know the contact type, what's our best guess?
-    def contact_type_best_effort
-      if @contact_type
-        @contact_type
-      else
-        # If it's just one word we'll assume organization.
-        # If more then we'll assume a person
-        @name.include?(ASCII_SPACE) ? :person : :organization
-      end
-    end
-
-    # We pass to this routine either prefixes or suffixes
-    def remove_outermost_adfix(adfix_type, name_part)
-      ct, parts = find_contact_type_and_parts(ADFIX_PATTERNS[adfix_type], name_part)
-
-      return name_part unless @adfix_found
-
-      # If we've found a diagnostic adfix then set the contact type
-      self.contact_type = ct
-
-      # The remainder of the name will be in parts[0] or parts[2] depending
-      # on whether this is a prefix or a suffix.
-      # We'll also remove any trailing commas we've exposed.
-      (parts[0] + parts[2]).gsub(/\s*,\s*$/, '')
-    end
-
-    def find_contact_type_and_parts(adfixes, name_part)
-      ct = contact_type_best_effort
-      parts = name_part.partition adfixes[ct]
-      @adfix_found = !parts[1].empty?
-
-      return [ct, parts] if @contact_type || @adfix_found
-
-      # If the contact type is indeterminate and we didn't find a diagnostic adfix
-      # for a person then try again for an organization
-      ct = :organization
-      parts = name_part.partition adfixes[ct]
-      @adfix_found = !parts[1].empty?
-
-      [ct, parts]
-    end
-
-    # Original Version of NameCase:
-    # Copyright (c) Mark Summerfield 1998-2008. All Rights Reserved
-    # This module may be used/distributed/modified under the same terms as Perl itself
-    # http://dev.perl.org/licenses/ (GPL)
-    #
-    # Ruby Version:
-    # Copyright (c) Aaron Patterson 2006
-    # NameCase is distributed under the GPL license.
-    #
-    # Substantially modified for Xendata
-    # Improved in several areas, also now adds non-breaking spaces for
-    # compound names like "van der Pump"
-    def name_case(lowercase)
-      n = lowercase.dup # We assume the name is passed already downcased
-
-      n
-        .upcase_first_letter!
-        .downcase_after_apostrophe!
-        .fix_mac!
-        .fix_ff!
-        .fix_name_modifiers!
-        .upcase_initials!
-    end
   end
 end

data/lib/name_tamer/strings/approximations.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+# Transliterations (like the i18n defaults)
+# see https://github.com/svenfuchs/i18n/blob/master/lib/i18n/backend/transliterator.rb
+module NameTamer
+  module Strings
+    module_function
+
+    # Any characters that resemble latin characters might usefully be
+    # transliterated into ones that are easy to type on an anglophone
+    # keyboard.
+    def approximate_latin_chars(string)
+      string.gsub(/[^\x00-\x7f]/u) { |char| APPROXIMATIONS[char] || char }
+    end
+
+    APPROXIMATIONS = {
+      'İ' => 'I',
+      '×' => 'x',
+      'ß' => 'ss',
+      'À' => 'A',
+      'à' => 'a',
+      'Á' => 'A',
+      'á' => 'a',
+      'Â' => 'A',
+      'â' => 'a',
+      'Ã' => 'A',
+      'ã' => 'a',
+      'Ä' => 'A',
+      'ä' => 'a',
+      'Å' => 'A',
+      'å' => 'a',
+      'Æ' => 'AE',
+      'æ' => 'ae',
+      'Ç' => 'C',
+      'ç' => 'c',
+      'È' => 'E',
+      'è' => 'e',
+      'É' => 'E',
+      'é' => 'e',
+      'Ê' => 'E',
+      'ê' => 'e',
+      'Ë' => 'E',
+      'ë' => 'e',
+      'Ì' => 'I',
+      'ì' => 'i',
+      'Í' => 'I',
+      'í' => 'i',
+      'Î' => 'I',
+      'î' => 'i',
+      'Ï' => 'I',
+      'ï' => 'i',
+      'Ð' => 'D',
+      'ð' => 'd',
+      'Ñ' => 'N',
+      'ñ' => 'n',
+      'Ò' => 'O',
+      'ò' => 'o',
+      'Ó' => 'O',
+      'ó' => 'o',
+      'Ô' => 'O',
+      'ô' => 'o',
+      'Õ' => 'O',
+      'õ' => 'o',
+      'Ö' => 'O',
+      'ö' => 'o',
+      'Ø' => 'O',
+      'ø' => 'o',
+      'Ù' => 'U',
+      'ù' => 'u',
+      'Ú' => 'U',
+      'ú' => 'u',
+      'Û' => 'U',
+      'û' => 'u',
+      'Ü' => 'U',
+      'ü' => 'u',
+      'Ý' => 'Y',
+      'ý' => 'y',
+      'Þ' => 'Th',
+      'þ' => 'th',
+      'ÿ' => 'y',
+      'Ÿ' => 'Y',
+      'Ā' => 'A',
+      'ā' => 'a',
+      'Ă' => 'A',
+      'ă' => 'a',
+      'Ą' => 'A',
+      'ą' => 'a',
+      'Ć' => 'C',
+      'ć' => 'c',
+      'Ĉ' => 'C',
+      'ĉ' => 'c',
+      'Ċ' => 'C',
+      'ċ' => 'c',
+      'Č' => 'C',
+      'č' => 'c',
+      'Ď' => 'D',
+      'ď' => 'd',
+      'Đ' => 'D',
+      'đ' => 'd',
+      'Ē' => 'E',
+      'ē' => 'e',
+      'Ĕ' => 'E',
+      'ĕ' => 'e',
+      'Ė' => 'E',
+      'ė' => 'e',
+      'Ę' => 'E',
+      'ę' => 'e',
+      'Ě' => 'E',
+      'ě' => 'e',
+      'Ĝ' => 'G',
+      'ĝ' => 'g',
+      'Ğ' => 'G',
+      'ğ' => 'g',
+      'Ġ' => 'G',
+      'ġ' => 'g',
+      'Ģ' => 'G',
+      'ģ' => 'g',
+      'Ĥ' => 'H',
+      'ĥ' => 'h',
+      'Ħ' => 'H',
+      'ħ' => 'h',
+      'Ĩ' => 'I',
+      'ĩ' => 'i',
+      'Ī' => 'I',
+      'ī' => 'i',
+      'Ĭ' => 'I',
+      'ĭ' => 'i',
+      'Į' => 'I',
+      'į' => 'i',
+      'ı' => 'i',
+      'IJ' => 'IJ',
+      'ij' => 'ij',
+      'Ĵ' => 'J',
+      'ĵ' => 'j',
+      'Ķ' => 'K',
+      'ķ' => 'k',
+      'ĸ' => 'k',
+      'Ĺ' => 'L',
+      'ĺ' => 'l',
+      'Ļ' => 'L',
+      'ļ' => 'l',
+      'Ľ' => 'L',
+      'ľ' => 'l',
+      'Ŀ' => 'L',
+      'ŀ' => 'l',
+      'Ł' => 'L',
+      'ł' => 'l',
+      'Ń' => 'N',
+      'ń' => 'n',
+      'Ņ' => 'N',
+      'ņ' => 'n',
+      'Ň' => 'N',
+      'ň' => 'n',
+      'ʼn' => "'n",
+      'Ŋ' => 'NG',
+      'ŋ' => 'ng',
+      'Ō' => 'O',
+      'ō' => 'o',
+      'Ŏ' => 'O',
+      'ŏ' => 'o',
+      'Ő' => 'O',
+      'ő' => 'o',
+      'Œ' => 'OE',
+      'œ' => 'oe',
+      'Ŕ' => 'R',
+      'ŕ' => 'r',
+      'Ŗ' => 'R',
+      'ŗ' => 'r',
+      'Ř' => 'R',
+      'ř' => 'r',
+      'Ś' => 'S',
+      'ś' => 's',
+      'Ŝ' => 'S',
+      'ŝ' => 's',
+      'Ş' => 'S',
+      'ş' => 's',
+      'Š' => 'S',
+      'š' => 's',
+      'Ţ' => 'T',
+      'ţ' => 't',
+      'Ť' => 'T',
+      'ť' => 't',
+      'Ŧ' => 'T',
+      'ŧ' => 't',
+      'Ũ' => 'U',
+      'ũ' => 'u',
+      'Ū' => 'U',
+      'ū' => 'u',
+      'Ŭ' => 'U',
+      'ŭ' => 'u',
+      'Ů' => 'U',
+      'ů' => 'u',
+      'Ű' => 'U',
+      'ű' => 'u',
+      'Ų' => 'U',
+      'ų' => 'u',
+      'Ŵ' => 'W',
+      'ŵ' => 'w',
+      'Ŷ' => 'Y',
+      'ŷ' => 'y',
+      'Ź' => 'Z',
+      'ź' => 'z',
+      'Ż' => 'Z',
+      'ż' => 'z',
+      'ž' => 'z',
+      'Ž' => 'Z',
+    }.freeze
+  end
+end

data/lib/name_tamer/strings/bad_encoding.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+# When strings are mistakenly encoded as single-byte character sets, instead
+# of UTF-8, there are some distinctive character combinations that we can spot
+# and fix
+# Useful table here http://www.i18nqa.com/debug/utf8-debug.html
+module NameTamer
+  module Strings
+    module_function
+
+    # Strings that were wrongly encoded with single-byte encodings sometimes
+    # have tell-tale substrings that we can put back into the correct UTF-8
+    # character
+    def fix_encoding_errors(string)
+      string.gsub(BAD_ENCODING_PATTERNS) { |substring| BAD_ENCODING[substring] || substring }
+    end
+
+    BAD_ENCODING = {
+      "\xC3\x8D" => 'Í',
+      "\xC3\x8F" => 'Ï',
+      "\xC3\x90" => 'Ð',
+      "\xC3\x9D" => 'Ý',
+      ' ' => ' ',
+      '¡' => '¡',
+      '¢' => '¢',
+      '£' => '£',
+      '¤' => '¤',
+      'Â¥' => '¥',
+      '¦' => '¦',
+      '§' => '§',
+      '¨' => '¨',
+      '©' => '©',
+      'ª' => 'ª',
+      '«' => '«',
+      '¬' => '¬',
+      '­' => '­',
+      '®' => '®',
+      '¯' => '¯',
+      '°' => '°',
+      '±' => '±',
+      '²' => '²',
+      '³' => '³',
+      '´' => '´',
+      'µ' => 'µ',
+      '¶' => '¶',
+      '·' => '·',
+      '¸' => '¸',
+      '¹' => '¹',
+      'º' => 'º',
+      '»' => '»',
+      '¼' => '¼',
+      '½' => '½',
+      '¾' => '¾',
+      '¿' => '¿',
+      '€' => '€',
+      'â„¢' => '™',
+      '”' => '”', # Note the invisible Ux009D in the key
+      '†' => '†',
+      '‡' => '‡',
+      '•' => '•',
+      '…' => '…',
+      '‰' => '‰',
+      '′' => '′', # Manually added. Some seem to use this instead of Ux2019
+      '‹' => '‹',
+      '›' => '›',
+      '“' => '“',
+      '‚' => '‚',
+      '„' => '„',
+      '‘' => '‘',
+      '–' => '–',
+      '—' => '—',
+      '’' => '’',
+      'à' => 'à',
+      'á' => 'á',
+      'â' => 'â',
+      'ã' => 'ã',
+      'ä' => 'ä',
+      'Ã¥' => 'å',
+      'æ' => 'æ',
+      'ç' => 'ç',
+      'è' => 'è',
+      'é' => 'é',
+      'ê' => 'ê',
+      'ë' => 'ë',
+      'ì' => 'ì',
+      'í' => 'í',
+      'î' => 'î',
+      'ï' => 'ï',
+      'ð' => 'ð',
+      'ñ' => 'ñ',
+      'ò' => 'ò',
+      'ó' => 'ó',
+      'ô' => 'ô',
+      'õ' => 'õ',
+      'ö' => 'ö',
+      '÷' => '÷',
+      'ø' => 'ø',
+      'ù' => 'ù',
+      'ú' => 'ú',
+      'û' => 'û',
+      'ü' => 'ü',
+      'ý' => 'ý',
+      'þ' => 'þ',
+      'ÿ' => 'ÿ',
+      'ß' => 'ß',
+      'ÃŒ' => 'Ì',
+      'Ãœ' => 'Ü',
+      'Ê' => 'Ê',
+      'Ú' => 'Ú',
+      'ÃŽ' => 'Î',
+      'Þ' => 'Þ',
+      'Ã' => 'Ã',
+      'È' => 'È',
+      'Ø' => 'Ø',
+      'Ö' => 'Ö',
+      '×' => '×',
+      'Ñ' => 'Ñ',
+      'Ã’' => 'Ò',
+      'Â' => 'Â',
+      'Ó' => 'Ó',
+      'Ô' => 'Ô',
+      'Ä' => 'Ä',
+      'Æ' => 'Æ',
+      'Ç' => 'Ç',
+      'Õ' => 'Õ',
+      'Ã…' => 'Å',
+      'É' => 'É',
+      'Ë' => 'Ë',
+      'Û' => 'Û',
+      'À' => 'À',
+      'Ù' => 'Ù',
+      'Ã�' => 'Á',
+      'Å ' => 'Š',
+      'Å¡' => 'š',
+      'Ÿ' => 'Ÿ',
+      'Ž' => 'Ž',
+      'ž' => 'ž',
+      'Å’' => 'Œ',
+      'Å“' => 'œ',
+      'Æ’' => 'ƒ',
+      'Ëœ' => '˜',
+      'ˆ' => 'ˆ',
+      "\x00" => '', # Manually added to avoid Bad Argument exception
+    }.freeze
+
+    BAD_ENCODING_PATTERNS = /(#{BAD_ENCODING.keys.join('|')})/
+  end
+end