nomener 0.2.8 → 0.2.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 68e937013b06402708e9f33b7105bfa96838b310
-  data.tar.gz: 52555ad53e9a6dceac49750a28f4eecba8463e51
+  metadata.gz: 1a5d4f2bd5060c45197d9b93c147ecf4975b66a4
+  data.tar.gz: 82d2f6e476c9fab3b3c18e1203fb7fc57cb7fe5d
 SHA512:
-  metadata.gz: 92fe2644e1408afdfb36cfbd24bc9d9d2d5d2cf2d9b405bd875cf3e8990c7253a449106c4338e6fcf6670f0780b64a4b5ca9011426bc75cabf2faf36a9b59f43
-  data.tar.gz: dde1cdf91eac5b6ed6e0dbd9a15c077f8c3457848eead726df0a8a5838a83f1b4ac81c06f92edaedd5a3d5b7112e4734c76152489e7da9e59fb223c3b940954d
+  metadata.gz: a84f031b213de553071f89fbfc16d0efab68e2b69471e32c2c92aa35598c80f2e2a1520a0ecbd0b88c4262c605f77c879b57a085ee33578bfa548483b1ccee54
+  data.tar.gz: 0783c6281f125eb7808772518e7bc3d0a26335625b3bb7d3340c59e4eb5f4c0ebcc1355864660d6550ffcbc66183133f2ccce0756e3c4322e27b9b829644b87e

data/lib/nomener.rb

@@ -1,12 +1,13 @@
 #-- encoding: UTF-8
-require "nomener/version"
-require "nomener/name"
-require "nomener/parser"
+require 'nomener/version'
+require 'nomener/name'
 
+# Base module for our names
 module Nomener
+  # Error class raised for the few times we aren't able to parse a name
+  class ParseError < StandardError
+  end
 
-  class ParseError < StandardError; end
-  
   # Public: Convenience method to parse a name
   #
   # name - a string of a name to parse
@@ -15,5 +16,4 @@ module Nomener
   def self.parse(name)
     Name.new(name).parse
   end
-
 end

data/lib/nomener/base.rb

@@ -0,0 +1,34 @@
+module Nomener
+  # Module of constants, methods being used in other modules and classes
+  module Base
+    # probably unnecessary constant
+    PERIOD = /\./
+
+    # Internal: a softer clean we keep re-using
+    #
+    # str - the string to dust off
+    #
+    # Returns the nice clean
+    def dustoff(str)
+      str = str.gsub PERIOD, ' '
+      str = str.squeeze ' '
+      str.strip
+    end
+
+    # Internal: clean out a given string with a given pattern
+    #   Modfies the given string
+    #
+    # str - the string to gut
+    # pattern - the regext to cut with
+    #
+    # Returns the gutted pattern
+    def gut!(str = '', pattern = / /)
+      found = []
+      str.gsub! pattern do |pat|
+        found << pat.strip
+        ''
+      end
+      found.join ' '
+    end
+  end
+end

data/lib/nomener/cleaner.rb

@@ -0,0 +1,111 @@
+#-- encoding: UTF-8
+
+# For Ruby 1.9.3, 2.0.0
+rv = RUBY_VERSION.split('.')[(0..1)].join('')
+require 'string-scrub' if rv >= '19' && rv < '21'
+
+module Nomener
+  # Module with helper functions to clean strings
+  #
+  #   Currently exposes
+  #   .reformat
+  #   .cleanup!
+  #   .dustoff
+  #
+  module Cleaner
+    # Allowable characters in a name after quotes have been reduced
+    @@allowable = nil
+
+    # regex for stuff at the end we want to get out
+    TRAILER_TRASH = /[,|\s]+$/
+
+    # regex for name characters we aren't going to use
+    DIRTY_STUFF = /[^,'\-(?:\p{Alpha}(?<\.))\p{Alpha}\p{Blank}]/
+
+    # Internal: Clean up a given string. Quotes from http://en.wikipedia.org/wiki/Quotation_mark
+    #  Needs to be fixed up for matching and non-english quotes
+    #
+    # name - the string to clean
+    # double - the double quotes to replace others with "" by default
+    # single - the single quotes to replace others with '' by default
+    #
+    # Returns a string which is (ideally) pretty much the same as it was given.
+    def self.reformat(name, double = '""', single = "''")
+      @@allowable = %r![^\p{Alpha}\-&\/\ \.\,\'\"\(\)
+        #{double[0] || '"'}
+        #{double[1] || '"'}
+        #{single[0] || "'"}
+        #{single[1] || "'"}] !x unless @@allowable
+
+      # remove illegal characters, translate fullwidth down
+      nomen = name.dup.scrub.tr("\uFF02\uFF07", "\u0022\u0027")
+
+      nomen = replace_doubles(nomen, double)
+      replace_singles(nomen, single)
+        .gsub(/@@allowable/, ' ')
+        .squeeze(' ')
+        .strip
+    end
+
+    # Internal: Clean up a string where there are numerous consecutive and
+    #   trailing non-name characters.
+    #   Modifies given string in place.
+    #
+    # args - strings to clean up
+    #
+    # Returns nothing
+    def self.cleanup!(*args)
+      args.each do |dirty|
+        next unless dirty.is_a?(String)
+
+        dirty.gsub! DIRTY_STUFF, ' '
+        dirty.squeeze! ' '
+        # remove any trailing commas or whitespace
+        dirty.gsub! TRAILER_TRASH, ''
+        dirty.strip!
+      end
+    end
+
+    # Internal: Replace various double quote characters with given char
+    #
+    # str - the string to find replacements in
+    # double - string with two characters, the left and right quotes
+    #
+    # Returns the string with the quotes replaced
+    def self.replace_doubles(str, double)
+      left, right = quotes_from double
+
+      # replace left and right double quotes
+      str.tr("\u0022\u00AB\u201C\u201E\u2036\u300E\u301D\u301F\uFE43", left)
+        .tr("\u0022\u00BB\u201D\u201F\u2033\u300F\u301E\uFE44", right)
+    end
+    private_class_method :replace_doubles
+
+    # Internal: Replace various single quote characters with given chars
+    #
+    # str - the string to find replacements in
+    # double - string with two characters, the left and right quotes
+    #
+    # Returns the string with the quotes replaced
+    def self.replace_singles(str, single)
+      left, right = quotes_from single
+
+      # replace left and right single quotes
+      str.tr("\u0027\u2018\u201A\u2035\u2039\u300C\uFE41\uFF62", left)
+        .tr("\u0027\u2019\u201B\u2032\u203A\u300D\uFE42\uFF62", right)
+    end
+    private_class_method :replace_singles
+
+    # Internal: Get the quotes from a string
+    #
+    # str - the string of two characters for the left and right quotes
+    #
+    # Returns an array of the [left, right] quotes
+    def self.quotes_from(str = '""')
+      left, right = str.split(/\B/)
+      right = left unless right
+      [left, right]
+    end
+    private_class_method :quotes_from
+  end
+end

data/lib/nomener/compounders.rb

@@ -1,10 +1,10 @@
 #-- encoding: UTF-8
 module Nomener
+  # Module for assist with finding family name compounds and prefixes
   module Compounders
     # Many of these are from http://en.wikipedia.org/wiki/List_of_family_name_affixes
-
     # Internal: Regex last name prefixes.
-    COMPOUNDS = %r!(?<part>(?:
+    COMPOUNDS = %r/(?<part>(?:
       Ab
       | Ap
       | Abu
@@ -74,6 +74,6 @@ module Nomener
       | Zu
       | (?-i:y)
       | 't
-    )\b\p{Blank}?\g<part>*)*!xi
+    )\b\p{Blank}?\g<part>*)*/xi
   end
 end

data/lib/nomener/name.rb

@@ -1,23 +1,22 @@
 #-- encoding: UTF-8
-require "nomener/parser"
+require 'nomener/parser'
 
 module Nomener
+  # name class for general purposes
   class Name < Struct.new :title, :first, :middle, :nick, :last, :suffix
-
     # we don't want to change what we were instantiated with
     attr_reader :original
 
     # Public: Create an instance!
     def initialize(nomen = '')
-      @original = ""
-      if nomen.kind_of?(String)
-        @original = Nomener::Helper.reformat nomen
-        parse
-      end
+      return @original = '' unless nomen.is_a?(String)
+      @original = Cleaner.reformat nomen
+      parse
     end
 
     # Public: Break down a string into parts of a persons name
-    #   As of 0.2.5 parse no longer needs to be called after initialization, it's done automatically.
+    #   As of 0.2.5 parse no longer needs to be called after initialization,
+    #   it's done automatically. Recalling it doesn't hurt though.
     #
     # name - A string of name to parse
     #
@@ -32,12 +31,11 @@ module Nomener
     #
     # Returns a string of the full name in a proper (western) case
     def properlike
-      f = (first || "").capitalize
-      n = (nick.nil? || nick.empty?) ? "" : "\"#{nick}\""
-      m = (middle || "").capitalize
-      l = capit(last || "")
-      t = (title || "").capitalize
-      "#{t} #{f} #{n} #{m} #{l} #{suffix}".strip.gsub(/\p{Blank}+/, ' ')
+      [capit(title), capit(first),
+        (nick.to_s.empty? ? '' : "\"#{nick}\""),
+        capit(middle), capit(last),
+        suffix
+      ].join(' ').strip.squeeze ' '
     end
 
     # Internal: try to capitalize last names with Mac and Mc and D' and such
@@ -46,19 +44,15 @@ module Nomener
     #
     # Returns a string of the capitalized name
     def capit(last)
-      return "" if last.nil? || last.empty?
-
-      fix = last.dup
+      fix = last.to_s.dup
 
       # if there are multiple last names separated by a dash
-      fix = fix.split("-").map { |v|
-        v.split(" ").map { |w| w.capitalize }.join " "
-      }.join "-"
+      fix = fix.split('-')
+        .map { |outer| outer.split(' ').map(&:capitalize).join ' ' }.join '-'
 
       # anything begining with Mac and not ending in [aciozj], except for a few
       fix.sub!(/Mac(?!
-        hin|
-        hlen|
+        hin|hlen|
         har|
         kle|
         klin|
@@ -67,15 +61,15 @@ module Nomener
         evicius|  # Lithuanian
         iulis|    # Lithuanian
         ias       # Lithuanian
-      )([\p{Alpha}]{2,}[^aAcCiIoOzZjJ])\b/x) { |s| "Mac#{$1.capitalize}" }
+      )([\p{Alpha}]{2,}[^aAcCiIoOzZjJ])\b/x) { "Mac#{$1.capitalize}" }
 
-      fix.sub! /\bMacmurdo\b/, "MacMurdo" # fix MacMurdo
+      fix.sub!(/\bMacmurdo\b/, 'MacMurdo') # fix MacMurdo
 
       # anything beginning with Mc, Mcdonald == McDonald
-      fix.sub!(/Mc(\p{Alpha}{2,})/) { |s| "Mc#{$1.capitalize}" }
+      fix.sub!(/Mc(\p{Alpha}{2,})/) { |s| "Mc#{s[2..-1].capitalize}" }
 
       # names like D'Angelo or Van 't Hooft, no cap 't
-      fix.gsub!(/('\p{Alpha})(?=\p{Alpha})/) { |s| "'#{$1[(1..-1)].capitalize}" }
+      fix.gsub!(/('\p{Alpha})(?=\p{Alpha})/) { |s| "'#{s[(1..-1)].capitalize}" }
 
       fix
     end
@@ -84,7 +78,10 @@ module Nomener
     #
     # Returns a nicely formatted string
     def inspect
-      "#<Nomener::Name #{each_pair.map { |k,v| [k,v.inspect].join('=') if (!v.nil? && !v.empty?) }.compact.join(' ')}>"
+      "#<Nomener::Name #{
+        each_pair.map { |k, v| [k, v.inspect].join('=') unless v.to_s.empty? }
+        .compact
+        .join(' ') }>"
     end
 
     # Public: an alias for the last name
@@ -93,7 +90,7 @@ module Nomener
     def surname
       last
     end
-    alias :family :surname
+    alias_method :family, :surname
 
     # Public: Return the first name
     #
@@ -104,7 +101,7 @@ module Nomener
 
     # Public: Make the name a string.
     #
-    # format - a string using symboles specifying the format of the name to return
+    # format - a string using symbols for the format of the name to return
     #   defaults to "%f %l"
     #     %f -> first name
     #     %l -> last/surname/family name
@@ -118,16 +115,15 @@ module Nomener
     #   defaults to true
     #
     # Returns the name as a string
-    def name(format = "%f %l", propercase = true)
+    def name(format = '%f %l', _propercase = true)
       nomen = to_h
-      nomen[:nick] = (nick.nil? || nick.empty?) ? "" : "\"#{nick}\""
-      format.gsub! /\%f/, '%{first}'
-      format.gsub! /\%l/, '%{last}'
-      format.gsub! /\%m/, '%{middle}'
-      format.gsub! /\%n/, '%{nick}'
-      format.gsub! /\%s/, '%{suffix}'
-      format.gsub! /\%t/, '%{title}'
-      (format % nomen).strip.gsub /\p{Blank}+/, " "
+      nomen[:nick] = (nick.nil? || nick.empty?) ? '' : "\"#{nick}\""
+
+      format = format.gsub(/%[flmnst]/,
+        '%f' => '%{first}', '%l' => '%{last}', '%m' => '%{middle}',
+        '%n' => '%{nick}', '%s' => '%{suffix}', '%t' => '%{title}'
+      )
+      (format % nomen).strip.squeeze ' '
     end
 
     # Public: Shortcut for name format
@@ -135,15 +131,15 @@ module Nomener
     #
     # Returns the full name
     def full
-      name("%f %m %l")
+      name '%f %m %l'
     end
-    alias :fullname :full
+    alias_method :fullname, :full
 
     # Public: See name
     #
     # Returns the name as a string
     def to_s
-      name("%f %l")
+      name '%f %l'
     end
 
     # Internal: merge another Nomener::Name to this one
@@ -152,16 +148,15 @@ module Nomener
     #
     # Returns nothing
     def merge(other)
-      return self unless other.kind_of?(Hash)
-      each_pair { |k, v| self[k] = other[k] }
+      return self unless other.is_a?(Hash)
+      each_pair { |k, _| self[k] = other[k] }
     end
 
     # Public: return self as a hash. For ruby 1.9.3
     #
     # Returns a hash of the name parts
     def to_h
-      Hash[self.each_pair.to_a]
+      Hash[each_pair.to_a]
     end unless method_defined?(:to_h)
-
   end
-end
+end

data/lib/nomener/parser.rb

@@ -1,21 +1,23 @@
 #-- encoding: UTF-8
-require "nomener/name"
-require "nomener/titles"
-require "nomener/suffixes"
-require "nomener/compounders"
-require "nomener/helper"
+require 'nomener/base'
+require 'nomener/compounders'
+require 'nomener/cleaner'
+require 'nomener/name'
+require 'nomener/suffixes'
+require 'nomener/titles'
 
 module Nomener
-  class Parser
-    include Nomener::Titles
-    include Nomener::Suffixes
-    include Nomener::Compounders
-
-    # regex for stuff at the end we want to get out
-    TRAILER_TRASH = /[,|\s]+$/
+  # Class containing the blades for carving a string into a name
+  #
+  # The two significant methods are:
+  #   parse returning a hash or nil
+  #   parse! returning a hash or raising an exception
+  module Parser
+    extend Nomener::Base
+    extend Nomener::Cleaner
+    extend Nomener::Titles
 
-    # regex for name characters we aren't going to use
-    DIRTY_STUFF = /[^,'(?:\p{Alpha}(?<\.))\p{Alpha}\p{Blank}]{2,}/
+    include Nomener::Compounders
 
     # regex for boundaries we'll use to find leftover nickname boundaries
     NICKNAME_LEFTOVER = /["'\(\)]{2}/
@@ -32,26 +34,22 @@ module Nomener
     # regex for matching last names in a "last, first" pattern
     LASTCOMFIRST_MATCHER = /\A(?<fam>#{COMPOUNDS}\b[\p{Alpha}\-\'\p{Blank}]+),/i
 
-    # period. probably not much performance help.
-    PERIOD = /\./
-
     # Public: parse a string into name parts
     #
     # name - a string to get the name from
-    # format - a hash of options to parse name (default {:order => :fl, :spacelimit => 0})
+    # format - hash of options to parse name
+    #   default {:order => :fl, :spacelimit => 0}
     #   :order - format the name. defaults to "last first" of the available
     #     :fl - presumes the name is in the format of "first last"
     #     :lf - presumes the name is in the format of "last first"
     #     :lcf - presumes the name is in the format of "last, first"
     #   :spacelimit - the number of spaces to consider in the first name
     #
-    # Returns a Nomener::Name object hopefully a parsed name of the string or nil
-    def self.parse(name, format = {:order => :auto, :spacelimit => 1})
-      begin
-        self.parse!(name, format)
+    # Returns a Nomener::Name of a parsed name of the string or nil
+    def self.parse(name, format = { order: :auto, spacelimit: 1 })
+      self.parse!(name, format)
       rescue
         nil
-      end
     end
 
     # Public: parse a string into name parts
@@ -61,80 +59,60 @@ module Nomener
     #
     # Returns a hash of name parts or nil
     # Raises ArgumentError if 'name' is not a string or is empty
-    def self.parse!(name, format = {:order => :auto, :spacelimit => 0})
-      raise ArgumentError, "Name to parse not provided" unless (name.kind_of?(String) && !name.empty?)
-
-      name = Nomener::Helper.reformat name
-      newname = { :title => "", :first => "", :nick => "", :middle => "", :last => "", :suffix => "" }
-
-      # grab any identified nickname before working on the rest
-      newname[:nick] = parse_nick! name
-      name.sub! NICKNAME_LEFTOVER, ""
-      cleanup! name
-
-      # grab any suffix' we can find
-      newname[:suffix] = parse_suffix! name
-      cleanup! name
-
-      newname[:title] = parse_title! name
-      name = dustoff name
-
-      newname[:last] = name # possibly mononyms
-
-      
-      case name
-      when /,/ # if there's a comma, it may be a useful hint
-        clues = name.split(",").each { |i| i.strip! }
-
-        raise ParseError, "Could not decipher commas in \"#{name}\"" if clues.length > 2
-
-        # convention is last, first when there's a comma
-        newname[:last], newname[:first] = clues
-        
-        # check the last by comparing a re-ordering of the name
-        # Mies van der Rohe, Ludwig
-        # Snepscheut, Jan L. A. van de
-        unless newname[:first].nil? || newname[:first].split(" ").length == 1
-          check = parse_last!("#{newname[:first]} #{newname[:last]}", :fl)
-
-          # let's trust the full name
-          if check != newname[:last]
-            newname[:first] = "#{newname[:first]} #{newname[:last]}".sub(check, "").strip
-            newname[:last] = check
-          end
-        end
+    def self.parse!(name, format = { order: :auto, spacelimit: 0 })
+      raise ArgumentError,
+        'Name to parse not provided' if name.to_s.empty?
+
+      name = Cleaner.reformat name
+
+      # we want the hash in this order as it helps with parsing out pieces
+      newname = { first: '', middle: '', last: '' }
+      newname[:nick] = parse_nick!(name) # grab any identified nickname
+      newname[:suffix] = Suffixes.parse_suffix!(name) # grab any suffix'
+      newname[:title] = Titles.parse_title!(name)
+
+      # stop here if we know we'll be confused
+      raise ParseError,
+        "Could not decipher commas in \"#{name}\"" if name.count(',') > 1
 
+      newname[:last] = dustoff name # possibly mononyms
+
+      if name.count(',') > 0
+        newname[:last], newname[:first] = splitcomma(name)
         # titles which are part of the first name...
-        newname[:title] = parse_title!(newname[:first]) if newname[:title].empty?
-        
-      when / / # no comma, check for space on first then last
+        newname[:title] = Titles.parse_title!(newname[:first]) if newname[:title].empty?
+      else
         newname[:last] = parse_last!(name, format[:order])
         newname[:first], newname[:middle] = parse_first!(name, format[:spacelimit])
       end
 
-      cleanup! newname[:last], newname[:first], newname[:middle]
+      Cleaner.cleanup! newname[:last], newname[:first], newname[:middle]
+      newname[:first] = dustoff newname[:first]
 
       newname
     end
 
-    # Internal: pull off a title if we can
-    #   Modifies given string in place.
+    # Internal split on the comma to get the first and last names
     #
-    # nm - string of the name to parse
+    # str - the name
     #
-    # Returns string of the title found or and empty string
-    def self.parse_title!(nm)
-      dustoff gut!(nm, TITLES)
-    end
+    # Returns an array of the last and first names found
+    def self.splitcomma(str)
+      last, first = str.split(',').each(&:strip!)
 
-    # Internal: pull off what suffixes we can
-    #   Modifies given string in place.
-    #
-    # nm - string of the name to parse
-    #
-    # Returns string of the suffixes found or and empty string
-    def self.parse_suffix!(nm)
-      dustoff gut!(nm, SUFFIXES)
+      # check the last by comparing a re-ordering of the name
+      # Mies van der Rohe, Ludwig
+      # Snepscheut, Jan L. A. van de
+      unless first.to_s.count(' ') == 0
+        check = parse_last!("#{first} #{last}", :fl)
+
+        # trust the full name and remove the parsed last
+        if check != last
+          first = "#{first} #{last}".sub(check, '').strip
+          last = check
+        end
+      end
+      [last, first]
     end
 
     # Internal: parse nickname out of string. presuming it's in quotes
@@ -144,7 +122,12 @@ module Nomener
     #
     # Returns string of the nickname found or and empty string
     def self.parse_nick!(nm)
-      dustoff gut!(nm, NICKNAME)
+      return '' if nm.to_s.empty?
+
+      nick = dustoff gut!(nm, NICKNAME)
+      nm.sub! NICKNAME_LEFTOVER, ''
+      Cleaner.cleanup! nm
+      nick
     end
 
     # Internal: parse last name from string
@@ -155,25 +138,25 @@ module Nomener
     #
     # Returns string of the last name found or an empty string
     def self.parse_last!(nm, format = :fl)
-      last = ""
+      last = ''
 
-      format = :fl  if (format == :auto && nm.index(",").nil?)
-      format = :lcf if (format == :auto && nm.index(","))
+      format = :fl  if format == :auto
+      format = :lcf if format == :auto && nm.index(',')
 
       # these constants should have the named match :fam
       nomen = case format
         when :fl
-          nm.match( FIRSTLAST_MATCHER )
+          nm.match FIRSTLAST_MATCHER
         when :lf
-          nm.match( LASTFIRST_MATCHER )
+          nm.match LASTFIRST_MATCHER
         when :lcf
-          nm.match( LASTCOMFIRST_MATCHER )
+          nm.match LASTCOMFIRST_MATCHER
       end
 
       unless nomen.nil? || nomen[:fam].nil?
         last = nomen[:fam].strip
-        nm.sub!(last, "")
-        nm.sub!(",", "")
+        nm.sub!(last, '')
+        nm.sub!(',', '')
       end
 
       last
@@ -187,56 +170,11 @@ module Nomener
     #
     # Returns an array containing the first name and middle name if any
     def self.parse_first!(nm, namecount = 0)
-      nm.tr! ".", " "
-      nm.squeeze! " "
-      first, middle = nm.split " ", namecount
-
-      [first || "", middle || ""]
-    end
+      nm.tr! '.', ' '
+      nm.squeeze! ' '
+      first, middle = nm.split ' ', namecount
 
-    private
-    # Internal: Clean up a string where there are numerous consecutive and trailing non-name characters.
-    #   Modifies given string in place.
-    #
-    # args - strings to clean up
-    #
-    # Returns nothing
-    def self.cleanup!(*args)
-      args.each do |dirty|
-        next if(dirty.nil? || !dirty.kind_of?(String))
-
-        dirty.gsub! DIRTY_STUFF, ""
-        dirty.squeeze! " "
-        # remove any trailing commas or whitespace
-        dirty.gsub! TRAILER_TRASH, ""
-        dirty.strip!
-      end
-    end
-
-    # Internal: a softer clean we keep re-using
-    #
-    # str - the string to dust off
-    #
-    # Returns the nice clean
-    def self.dustoff(str)
-      str = str.gsub PERIOD, " "
-      str = str.squeeze " "
-      str = str.strip
-    end
-
-    # Internal: clean out a given string with a given pattern
-    #   Modfies the given string
-    # str - the string to gut
-    # pattern - the regext to cut with
-    #
-    # Returns the gutted pattern
-    def self.gut!(str = "", pattern = / /)
-      found = []
-      str.gsub! pattern do |pat|
-        found << pat.strip
-        ""
-      end
-      found.join " "
+      [first || '', middle || '']
     end
   end
 end