person-name 0.2.2 → 0.2.3

data/README.markdown

@@ -7,6 +7,12 @@ If you have to fill in a name for somebody, you have to display all those fields
 The goal is to make one field that can split up the name and assign it to the correct fields automatically.
 You can also still use the more precise input if necessary.
 
+Installation
+============
+in your Gemfile:
+
+    gem "person-name"
+
 Usage
 =====
 

data/VERSION

@@ -1 +1 @@
-0.2.2
+0.2.3

data/lib/person-name.rb

@@ -2,9 +2,10 @@ require "active_record"
 
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 
+require "person_name/name_splitter"
 require "person_name/name"
-require "person_name/migration_support"
 require "person_name/has_person_name"
+require "person_name/migration_support"
 
 $LOAD_PATH.shift
 

data/lib/person_name/has_person_name.rb

@@ -1,51 +1,51 @@
 module PersonName
 
-	module ActiveRecord
+  module ActiveRecord
 
-		def self.included(base) # :nodoc:
-    	base.extend ClassMethods
+    def self.included(base) # :nodoc:
+      base.extend ClassMethods
     end
 
-		module ClassMethods
+    module ClassMethods
 
-			def has_person_names?
-      	false
-    	end
+      def has_person_names?
+        false
+      end
 
-			def has_person_name(*name_types)
-				name_types = name_types.to_a.flatten.compact.map(&:to_sym)
-				name_types << :name if name_types.empty?
+      def has_person_name(*name_types)
+        name_types = name_types.to_a.flatten.compact.map(&:to_sym)
+        name_types << :name if name_types.empty?
 
-				if has_person_names?
-					write_inheritable_attribute(:name_types, (self.name_types + name_types).uniq)
-				else
-					write_inheritable_attribute(:name_types, name_types)
-					class_inheritable_reader(:name_types)
+        if has_person_names?
+          write_inheritable_attribute(:name_types, (self.name_types + name_types).uniq)
+        else
+          write_inheritable_attribute(:name_types, name_types)
+          class_inheritable_reader(:name_types)
 
-					class_eval do
-						def self.has_person_names?
-							true
-						end
+          class_eval do
+            def self.has_person_names?
+              true
+            end
 
-						include PersonName::ActiveRecord::Core
-					end
-				end
-			end
+            include PersonName::ActiveRecord::Core
+          end
+        end
+      end
 
-		end
+    end
 
-		module Core
+    module Core
 
-			def self.included(base)
-				base.send :include, PersonName::ActiveRecord::Core::InstanceMethods
-				base.extend PersonName::ActiveRecord::Core::ClassMethods
-  	    base.initialize_person_names
-	    end
+      def self.included(base)
+        base.send :include, PersonName::ActiveRecord::Core::InstanceMethods
+        base.extend PersonName::ActiveRecord::Core::ClassMethods
+        base.initialize_person_names
+      end
 
-			module ClassMethods
-				def initialize_person_names
-					name_types.map(&:to_s).each do |name_type|
-						class_eval %(
+      module ClassMethods
+        def initialize_person_names
+          name_types.map(&:to_s).each do |name_type|
+            class_eval %(
 							def #{name_type}
 								person_name_for('#{name_type}')
 							end
@@ -54,25 +54,25 @@ module PersonName
 								set_person_name_for('#{name_type}', new_name)
 							end
 						)
-					end
-				end
-			end
+          end
+        end
+      end
 
-			module InstanceMethods
+      module InstanceMethods
 
-				def person_name_for field
-					@person_names ||= {}
-					@person_names[field] ||= PersonName::Name.new(field, self)
-				end
+        def person_name_for field
+          @person_names ||= {}
+          @person_names[field] ||= PersonName::ActiveRecordPersonName.new(field, self)
+        end
 
-				def set_person_name_for field, new_name
-					person_name_for(field).full_name = new_name
-				end
+        def set_person_name_for field, new_name
+          person_name_for(field).full_name = new_name
+        end
 
-			end
+      end
 
-		end
+    end
 
-	end
+  end
 
 end

data/lib/person_name/migration_support.rb

@@ -1,12 +1,16 @@
 
 module PersonName::MigrationSupport
 
-	def person_name(name, *args)
-		options = args.extract_options!
-		name_parts = PersonName::Name::NAME_PARTS
-		name_parts.each do |part|
-			column("#{name}_#{part}".to_sym, :string, :null => true)
-		end
-	end
+  def person_name(name, *args)
+    self.add_name_columns(self, name, *args)
+  end
+
+  def self.add_name_columns(table, prefix, *args)
+    options = args.extract_options!
+    name_parts = PersonName::NameSplitter::NAME_PARTS
+    name_parts.each do |part|
+      table.column("#{prefix}_#{part}".to_sym, :string, :null => true)
+    end
+  end
 
 end

data/lib/person_name/name.rb

@@ -1,7 +1,5 @@
 module PersonName
-  class Name
-
-    NAME_PARTS = %w(prefix first_name middle_name intercalation last_name suffix)
+  class ActiveRecordPersonName
 
     def initialize(naming_prefix, record)
       @naming_prefix = naming_prefix
@@ -9,101 +7,17 @@ module PersonName
     end
 
     def full_name
-      NAME_PARTS.collect { |p| self.send(p) }.compact.join " "
+      NameSplitter::NAME_PARTS.collect { |p| self.send(p) }.compact.join " "
     end
 
     def full_name= new_name
       return if full_name == new_name # no changes
+      old_values = {}
+      NameSplitter::NAME_PARTS.collect { |p| old_values[p.to_sym] = self.send(p) }
+      new_name = NameSplitter.split(new_name, old_values)
 
-      parts = new_name.split " "
-      names = []
-      stage = :prefix
-      remember = nil
-      parts.each_with_index do |part, index|
-        is_upcase = (part[0,1] == part[0,1].upcase)
-        has_dash = part.include? "-"
-        is_last = (parts.length - 1) == index
-
-        fp = [remember, part].compact.join(" ")
-        remember = nil
-        did_remember = (fp != part)
-        if valid_prefix?(part) and stage == :prefix # if the part is a valid prefix, mark it as such
-          names = add_to_last_if :prefix, fp, names
-        elsif valid_suffix?(part) and stage == :name # if the part is a valid suffix, mark it as such
-          names = add_to_last_if :suffix, fp, names
-        elsif 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], fp].compact.join(" ")
-          else
-            # if there is no previous part, just store the current part for later
-            remember = fp
-          end
-        elsif !is_upcase and !did_remember # intercalation words are never with a capital
-          names = add_to_last_if :intercalation, fp, names
-          stage = :name
-        elsif !is_upcase and did_remember
-          remember = fp
-        elsif is_upcase and !has_dash
-          names << [fp, :name]
-          stage = :name
-        elsif is_upcase and has_dash
-          if fp.ends_with? "-"
-            if is_last
-              names << [fp, :name]
-              stage = :name
-            else
-              remember = fp
-            end
-          else
-            if fp.starts_with?("-") and last_stored = names.pop
-              fp = [last_stored[0], fp].compact.join(" ")
-            end
-            dash_parts = fp.split "-"
-            if dash_parts.last.first == dash_parts.last.first.upcase
-              names << [fp, :name]
-              stage = :name
-            elsif is_last
-              names << [fp, :name]
-              stage = :name
-            else
-              remember = fp
-            end
-          end
-        end
-      end
-
-      new_name = {}
-      stage = O[:prefix]
-
-      names.each_with_index do |value, index|
-        name, name_type = *value
-        stage = recheck_stage(name, stage)
-
-        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
       # assignments
-      NAME_PARTS.each do |part|
+      NameSplitter::NAME_PARTS.each do |part|
         self.send "#{part}=", (new_name[part.to_sym] || "").blank? ? nil : new_name[part.to_sym]
       end
     end
@@ -114,17 +28,17 @@ module PersonName
 
     def short_name include_middle_names = true
       parts = []
-      parts << "#{self.first_name.first.upcase}." if self.first_name
+      parts << "#{self.first_name[0,1].upcase}." if self.first_name
       if include_middle_names and self.middle_name
         names = self.middle_name.split(" ")
         names.each do |name|
-          parts << "#{name.first.upcase}."
+          parts << "#{name[0,1].upcase}."
         end
       end
       [parts.join, full_last_name] * " "
     end
 
-    NAME_PARTS.each do |part|
+    NameSplitter::NAME_PARTS.each do |part|
       define_method part do
         @record.send("#{@naming_prefix}_#{part}")
       end
@@ -140,57 +54,6 @@ module PersonName
 
     private
 
-    O = {
-            :prefix => 0,
-            :first_name => 1,
-            :middle_name => 2,
-            :intercalation => 3,
-            :last_name => 4,
-            :suffix => 5
-    }.freeze
-    OR = O.invert
-
-    def add_part new_name, part_score, part
-      part_name = OR[part_score]
-      new_name[part_name.to_sym] = [new_name[part_name.to_sym], part].compact.join(" ")
-      new_name
-    end
-
-    def recheck_stage value, stage
-      # test if the given value is already stored in the name right now
-      new_stage = stage
-      NAME_PARTS.each do |part|
-        part_values = (self.send(part) || "").split(" ")
-
-        part_score = O[part.to_sym]
-        if part_values.include? value
-          part_score = O[:first_name] if stage == O[:prefix] and part = :middle_name
-          new_stage = part_score if part_score > new_stage
-          return new_stage
-        end
-      end
-      stage
-    end
-
-    def add_to_last_if part, value, list
-      if list.last and list.last[1] == part
-        last_part = list.pop
-        list << [[last_part[0], value].compact.join(" "), part]
-      else
-        list << [value, part]
-      end
-      list
-    end
-
     attr_reader :naming_prefix, :record
-
-    def valid_prefix? name_part
-      false
-    end
-
-    def valid_suffix? name_part
-      false
-    end
-
   end
-end
+end

data/lib/person_name/name_splitter.rb

@@ -0,0 +1,150 @@
+module PersonName
+  class NameSplitter
+
+    NAME_PARTS = %w(prefix first_name middle_name intercalation last_name suffix)
+
+    def self.split(new_name_str, existing_values = {})
+      parts = new_name_str.split " "
+      names = []
+      stage = :prefix
+      remember = nil
+      parts.each_with_index do |part, index|
+        is_upcase = (part[0,1] == part[0,1].upcase)
+        has_dash = part.include? "-"
+        is_last = (parts.length - 1) == index
+
+        fp = [remember, part].compact.join(" ")
+        remember = nil
+        did_remember = (fp != part)
+        if valid_prefix?(part) and stage == :prefix # if the part is a valid prefix, mark it as such
+          names = add_to_last_if :prefix, fp, names
+        elsif valid_suffix?(part) and stage == :name # if the part is a valid suffix, mark it as such
+          names = add_to_last_if :suffix, fp, names
+        elsif 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], fp].compact.join(" ")
+          else
+            # if there is no previous part, just store the current part for later
+            remember = fp
+          end
+        elsif !is_upcase and !did_remember # intercalation words are never with a capital
+          names = add_to_last_if :intercalation, fp, names
+          stage = :name
+        elsif !is_upcase and did_remember
+          remember = fp
+        elsif is_upcase and !has_dash
+          names << [fp, :name]
+          stage = :name
+        elsif is_upcase and has_dash
+          if fp.ends_with? "-"
+            if is_last
+              names << [fp, :name]
+              stage = :name
+            else
+              remember = fp
+            end
+          else
+            if fp.starts_with?("-") and last_stored = names.pop
+              fp = [last_stored[0], fp].compact.join(" ")
+            end
+            dash_parts = fp.split "-"
+            if dash_parts.last.first == dash_parts.last.first.upcase
+              names << [fp, :name]
+              stage = :name
+            elsif is_last
+              names << [fp, :name]
+              stage = :name
+            else
+              remember = fp
+            end
+          end
+        end
+      end
+
+      new_name = {}
+      stage = O[:prefix]
+
+      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
+
+    private
+
+    O = {
+            :prefix => 0,
+            :first_name => 1,
+            :middle_name => 2,
+            :intercalation => 3,
+            :last_name => 4,
+            :suffix => 5
+    }.freeze
+    OR = O.invert
+
+    def self.add_part new_name, part_score, part
+      part_name = OR[part_score]
+      new_name[part_name.to_sym] = [new_name[part_name.to_sym], part].compact.join(" ")
+      new_name
+    end
+
+    def self.recheck_stage value, stage, old_values
+      # test if the given value is already stored in the name right now
+      new_stage = stage
+      NAME_PARTS.each do |part|
+        part_values = (old_values[part.to_sym] || "").split(" ")
+
+        part_score = O[part.to_sym]
+        if part_values.include? value
+          part_score = O[:first_name] if stage == O[:prefix] and part = :middle_name
+          new_stage = part_score if part_score > new_stage
+          return new_stage
+        end
+      end
+      stage
+    end
+
+    def self.add_to_last_if part, value, list
+      if list.last and list.last[1] == part
+        last_part = list.pop
+        list << [[last_part[0], value].compact.join(" "), part]
+      else
+        list << [value, part]
+      end
+      list
+    end
+
+    def self.valid_prefix? name_part
+      false
+    end
+
+    def self.valid_suffix? name_part
+      false
+    end
+
+  end
+end

data/spec/models.rb

@@ -2,3 +2,10 @@ class Person < ActiveRecord::Base
   has_person_name
 end
 
+class PersonWithoutName < ActiveRecord::Base
+end
+
+class NamePerson < ActiveRecord::Base
+  has_person_name
+  has_person_name :birth_name
+end

data/spec/person_name/has_person_name_spec.rb

@@ -5,6 +5,18 @@ describe "Has Person Name" do
     clean_database!
   end
 
+  describe "Some model without names" do
+    it "should not have person names" do
+      PersonWithoutName.should_not have_person_names
+    end
+  end
+
+  describe "Some model with names" do
+    it "should have person names" do
+      Person.should have_person_names
+    end
+  end
+
   describe "Automatic name assignment" do
     before(:each) do
       clean_database!
@@ -33,6 +45,17 @@ describe "Has Person Name" do
       @person.name_last_name.should == "Groen"
     end
 
+    it "should be able to show a short name" do
+      @person.name = "Matthijs Jacobus Groen"
+      @person.name.short_name.should == "M.J. Groen"
+      @person.name.short_name(false).should == "M. Groen"
+    end
+
+    it "should be able to show a full last name" do
+      @person.name = "Frans van der Sluis"
+      @person.name.full_last_name.should == "van der Sluis"
+    end
+
     it "should split up name parts and assign to correct fields" do
       test_fields = %w(prefix first_name middle_name intercalation last_name suffix)
       test_cases = [
@@ -40,6 +63,9 @@ describe "Has Person Name" do
         [nil, "Matthijs", "Jacobus", nil, "Groen", nil],
         [nil, "Frans", nil, "van der", "Sluis", nil],
         [nil, "Maria", "Cornelia Hendrina", nil, "Damen-van Valenberg", nil],
+        [nil, "Maria", "Cornelia Hendrina", nil, "Damen - van Valenberg", nil],
+        [nil, "Maria", "Cornelia Hendrina", nil, "Damen- van Valenberg", nil],
+        [nil, "Maria", "Cornelia Hendrina", nil, "Damen -van Valenberg", nil],
         [nil, "Dirk", "Jan", "van de", "Abeele", nil],
         [nil, "Yolanthe", "Cabau", "van", "Kasbergen", nil],
       ]

data/spec/schema.rb

@@ -1,11 +1,16 @@
 ActiveRecord::Schema.define :version => 0 do
   create_table "people", :force => true do |t|
-    t.string   "name_prefix"
-    t.string   "name_first_name"
-    t.string   "name_middle_name"
-    t.string   "name_intercalation"
-    t.string   "name_last_name"
-    t.string   "name_suffix"
+    PersonName::MigrationSupport.add_name_columns(t, :name)
+  end
+
+  create_table "person_without_names", :force => true do |t|
+    t.boolean   :female
+  end
+
+  create_table "name_people", :force => true do |t|
+    PersonName::MigrationSupport.add_name_columns(t, :name)
+    PersonName::MigrationSupport.add_name_columns(t, :birth_name)
+    t.boolean   :female
   end
 
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: person-name
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 17
   prerelease: false
   segments: 
   - 0
   - 2
-  - 2
-  version: 0.2.2
+  - 3
+  version: 0.2.3
 platform: ruby
 authors: 
 - Matthijs Groen
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-25 00:00:00 +02:00
+date: 2010-09-27 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
@@ -38,6 +38,7 @@ files:
 - lib/person_name/has_person_name.rb
 - lib/person_name/migration_support.rb
 - lib/person_name/name.rb
+- lib/person_name/name_splitter.rb
 - rails/init.rb
 - spec/database.yml
 - spec/database.yml.sample