Class: PersonName::NameSplitter

Inherits:
Object
  • Object
show all
Defined in:
lib/person_name/name_splitter.rb

Constant Summary collapse

NAME_PARTS = 
%w(prefix first_name middle_name intercalation last_name suffix)
DEFAULT_PREFIXES = 
%w(Mr. Dhr. Drs. Prof. Mevr. Mej. Mrs.)
DEFAULT_SUFFIXES = 
%w(jr. Phd.)

Class Method Summary collapse

Class Method Details

.split(new_name_str, existing_values = {}) ⇒ Object

Splits the given name in individual name parts in form of a hash. You can supply a hash with existing values for editing purposes.



11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
 
# File 'lib/person_name/name_splitter.rb', line 11

def self.split(new_name_str, existing_values = {})
  return {} if new_name_str.nil?
  parts = new_name_str.split " "
  names = []
  stage = :prefix

  # value to remember for merging
  remember = nil
  parts.each_with_index do |part, index|

    # some helper variables
    is_upcase = (part[0,1] == part[0,1].upcase)
    has_dash = part.include? "-"
    is_last = (parts.length - 1) == index

    # add the remember part to the current part but make a note if we used a remembered value
    full_part = [remember, part].compact.join(" ")
    did_remember = (full_part != part)
    suffix_remember = remember
    remember = nil

    # Mr. Mrs. Mevr. Mej.
    if valid_prefix?(part) and stage == :prefix and not did_remember # if the part is a valid prefix, mark it as such
      names = add_to_last_if :prefix, part, names

    # Jr. Phd.
    elsif valid_suffix?(part) # if the part is a valid suffix, mark it as such
      names << [suffix_remember, :name] if did_remember
      names = add_to_last_if :suffix, part, names
    else
      remember = nil

      # Damen - van Valkenburg
      if part == "-" # if the part is a dash
        if last_stored = names.pop # retrieve the previous name part (if any) and store it with the dash
          # for the part to come (remember)
          remember = [last_stored[0], full_part].compact.join(" ")
        else
          # if there is no previous part, just store the current part for later
          remember = full_part
        end

      # van de Sloot
      elsif !is_upcase and !did_remember # intercalation words are never with a capital
        names = add_to_last_if :intercalation, full_part, names
        stage = :name

      # Groen in het Woud
      elsif !is_upcase and did_remember
        remember = full_part

      # Groen
      elsif is_upcase and !has_dash
        names << [full_part, :name]
        stage = :name

      # Groen-teboer
      elsif is_upcase and has_dash
        if full_part.ends_with? "-"
          if is_last
            names << [full_part, :name]
            stage = :name
          else
            remember = full_part
          end
        else
          if full_part.starts_with?("-") and last_stored = names.pop
            last_stored_name = last_stored[0].split(" ")
            last_part = last_stored_name.pop
            names << [last_stored_name.join(" "), last_stored[1]] unless last_stored_name.empty?
            full_part = [last_part, full_part].compact.join(" ")
          end
          dash_parts = full_part.split "-"
          if dash_parts.last[0,1] == dash_parts.last[0,1].upcase
            names << [full_part, :name]
            stage = :name
          elsif is_last
            names << [full_part, :name]
            stage = :name
          else
            remember = full_part
          end
        end
      end
    end
  end
  names << [remember, :name] if remember

  new_name = {}
  stage = O[:prefix]
  #puts names.inspect

  names.each_with_index do |value, index|
    name, name_type = *value
    stage = recheck_stage(name, stage, existing_values)

    if name_type == :prefix and stage == O[:prefix]
    elsif name_type == :suffix and (index == names.length - 1)
      stage = [O[:suffix], stage].max
    elsif name_type == :suffix and (index != names.length - 1)
      name_type = :name
    end

    if name_type == :name
      if (index == names.length - 1) or new_name[:intercalation]
        stage = [O[:last_name], stage].max
      else
        if !new_name[:first_name]
          stage = [O[:first_name], stage].max
        else
          stage = [O[:middle_name], stage].max
        end
      end
    elsif name_type == :intercalation
      stage = [O[:intercalation], stage].max
    end
    new_name = add_part(new_name, stage, name)
  end
  new_name
end