person-name 0.2.0 → 0.2.1

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.2.1

data/lib/person-name.rb

@@ -0,0 +1,16 @@
+require "active_record"
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require "person_name/name"
+require "person_name/migration_support"
+require "person_name/has_person_name"
+
+$LOAD_PATH.shift
+
+if defined?(ActiveRecord::ConnectionAdapters::TableDefinition)
+  ActiveRecord::ConnectionAdapters::TableDefinition.send :include, PersonName::MigrationSupport
+end
+if defined?(ActiveRecord::Base)
+  ActiveRecord::Base.send :include, PersonName::ActiveRecord
+end

data/lib/person_name/name.rb

@@ -1,202 +1,196 @@
-class PersonName::Name
-
-	NAME_PARTS = %w(prefix first_name middle_name intercalation last_name suffix)
-
-	def initialize(naming_prefix, record)
-		@naming_prefix = naming_prefix
-		@record = record
-	end
-
-	def full_name
-		NAME_PARTS.collect { |p| self.send(p) }.compact.join " "
-	end
-
-	def full_name= new_name
-		# Matthijs Jacobus Groen
-		# Patricia Jose Huisman
-		# Thijs van de Biggelaar
-		# Michael Thijssens
-		# Maria Cornelia Hendrina Damen-van Valenberg
-		# Dirk Jan van den Abeele
-		# Yolanthe Cabau van Kasbergen
-		# Yolanthe Sneijder-Cabau
-		return if full_name == new_name # no changes
-
-		parts = new_name.split " "
-		names = []
-		stage = :prefix
-		remember = nil
-		parts.each_with_index do |part, index|
-			is_upcase = part.first == part.first.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|
-			self.send "#{part}=", (new_name[part.to_sym] || "").blank? ? nil : new_name[part.to_sym]
-		end
-	end
-
-	def full_last_name
-		[:intercalation, :last_name, :suffix].collect { |p| self.send(p) }.compact.join " "
-	end
-
-	def short_name include_middle_names = true
-		parts = []
-		parts << "#{self.first_name.first.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}."
-			end
-		end
-		[parts.join, full_last_name] * " "
-	end
-
-	NAME_PARTS.each do |part|
-		define_method part do
-			@record.send("#{@naming_prefix}_#{part}")
-		end
-
-		define_method "#{part}=" do |value|
-			@record.send("#{@naming_prefix}_#{part}=", value)
-		end
-	end
-
-	def to_s
-		full_name
-	end
-
-	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
-
+module PersonName
+  class Name
+
+    NAME_PARTS = %w(prefix first_name middle_name intercalation last_name suffix)
+
+    def initialize(naming_prefix, record)
+      @naming_prefix = naming_prefix
+      @record = record
+    end
+
+    def full_name
+      NAME_PARTS.collect { |p| self.send(p) }.compact.join " "
+    end
+
+    def full_name= new_name
+      return if full_name == new_name # no changes
+
+      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|
+        self.send "#{part}=", (new_name[part.to_sym] || "").blank? ? nil : new_name[part.to_sym]
+      end
+    end
+
+    def full_last_name
+      [:intercalation, :last_name, :suffix].collect { |p| self.send(p) }.compact.join " "
+    end
+
+    def short_name include_middle_names = true
+      parts = []
+      parts << "#{self.first_name.first.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}."
+        end
+      end
+      [parts.join, full_last_name] * " "
+    end
+
+    NAME_PARTS.each do |part|
+      define_method part do
+        @record.send("#{@naming_prefix}_#{part}")
+      end
+
+      define_method "#{part}=" do |value|
+        @record.send("#{@naming_prefix}_#{part}=", value)
+      end
+    end
+
+    def to_s
+      full_name
+    end
+
+    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

data/rails/init.rb

@@ -1,5 +1 @@
-require 'person_name'
-require 'person_name/migration_support'
-
-ActiveRecord::ConnectionAdapters::TableDefinition.send :include, PersonName::MigrationSupport
-ActiveRecord::Base.send :include, PersonName::ActiveRecord
+require 'person-name'

data/spec/person_name/has_person_name_spec.rb

@@ -15,82 +15,55 @@ describe "Has Person Name" do
       @person.should respond_to(:name)
     end
 
-  end
+    it "should read active_record attributes" do
+      @person.name_first_name = "Matthijs"
+      @person.name.first_name.should == "Matthijs"
 
-  describe "Automatic name assignment" do
-    before(:each) do
-      clean_database!
-      @person = Person.new
+      @person.name_last_name = "Groen"
+      @person.name.last_name.should == "Groen"
+
+      @person.name.to_s.should == "Matthijs Groen"
     end
 
-    it "should assign name parts to the correct fields" do
-      @person.name = "Matthijs Groen"
-      @person.name.first_name.should == "Matthijs"
+    it "should assign active_record attributes" do
+      @person.name.first_name = "Matthijs"
+      @person.name_first_name.should == "Matthijs"
+
+      @person.name.last_name = "Groen"
+      @person.name_last_name.should == "Groen"
     end
 
-  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 = [
+        [nil, "Matthijs", nil, nil, "Groen", nil],
+        [nil, "Matthijs", "Jacobus", nil, "Groen", nil],
+        [nil, "Frans", nil, "van der", "Sluis", nil],
+        [nil, "Maria", "Cornelia Hendrina", nil, "Damen-van Valenberg", nil],
+        [nil, "Dirk", "Jan", "van de", "Abeele", nil],
+        [nil, "Yolanthe", "Cabau", "van", "Kasbergen", nil],
+      ]
 
-#  it "should provide a class method 'taggable?' that is false for untaggable models" do
-#    UntaggableModel.should_not be_taggable
-#  end
+      test_cases.each do |fields|
+        string = fields.compact.join(" ")
+        @person = Person.new
+        @person.name = string
+
+        test_fields.each_with_index do |field, index|
+          @person.name.send(field).should == fields[index]
+        end
+      end
+    end
 
-#  describe "Taggable Method Generation" do
-#    before(:each) do
-#      clean_database!
-#      TaggableModel.write_inheritable_attribute(:tag_types, [])
-#      TaggableModel.acts_as_taggable_on(:tags, :languages, :skills, :needs, :offerings)
-#      @taggable = TaggableModel.new(:name => "Bob Jones")
-#    end
-#
-#    it "should respond 'true' to taggable?" do
-#      @taggable.class.should be_taggable
-#    end
-#
-#    it "should create a class attribute for tag types" do
-#      @taggable.class.should respond_to(:tag_types)
-#    end
-#
-#    it "should create an instance attribute for tag types" do
-#      @taggable.should respond_to(:tag_types)
-#    end
-#
-#    it "should have all tag types" do
-#      @taggable.tag_types.should == [:tags, :languages, :skills, :needs, :offerings]
-#    end
-#
-#    it "should generate an association for each tag type" do
-#      @taggable.should respond_to(:tags, :skills, :languages)
-#    end
-#
-#    it "should add tagged_with and tag_counts to singleton" do
-#      TaggableModel.should respond_to(:tagged_with, :tag_counts)
-#    end
-#
-#    it "should generate a tag_list accessor/setter for each tag type" do
-#      @taggable.should respond_to(:tag_list, :skill_list, :language_list)
-#      @taggable.should respond_to(:tag_list=, :skill_list=, :language_list=)
-#    end
-#
-#    it "should generate a tag_list accessor, that includes owned tags, for each tag type" do
-#      @taggable.should respond_to(:all_tags_list, :all_skills_list, :all_languages_list)
-#    end
-#  end
+    it "should remember corrections" do
+      @person.name.first_name = "Yolanthe"
+      @person.name.last_name = "Cabau van Kasbergen"
 
-#  describe "Single Table Inheritance" do
-#    before do
-#      @taggable = TaggableModel.new(:name => "taggable")
-#      @inherited_same = InheritingTaggableModel.new(:name => "inherited same")
-#      @inherited_different = AlteredInheritingTaggableModel.new(:name => "inherited different")
-#    end
-#
-#    it "should pass on tag contexts to STI-inherited models" do
-#      @inherited_same.should respond_to(:tag_list, :skill_list, :language_list)
-#      @inherited_different.should respond_to(:tag_list, :skill_list, :language_list)
-#    end
-#
-#    it "should have tag contexts added in altered STI models" do
-#      @inherited_different.should respond_to(:part_list)
-#    end
-#  end
+      @person.name = "Yolanthe Truuske Cabau van Kasbergen"
+      @person.name.middle_name.should == "Truuske"
+      @person.name.last_name.should == "Cabau van Kasbergen"
+    end
+
+  end
 
 end

data/spec/spec_helper.rb

@@ -17,7 +17,7 @@ rescue Bundler::GemNotFound
 end
 
 Bundler.require
-require File.expand_path('../../lib/person_name', __FILE__)
+require File.expand_path('../../lib/person-name', __FILE__)
 
 unless [].respond_to?(:freq)
   class Array

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: person-name
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 21
   prerelease: false
   segments: 
   - 0
   - 2
-  - 0
-  version: 0.2.0
+  - 1
+  version: 0.2.1
 platform: ruby
 authors: 
 - Matthijs Groen
@@ -34,7 +34,8 @@ files:
 - README.markdown
 - Rakefile
 - VERSION
-- lib/person_name.rb
+- lib/person-name.rb
+- lib/person_name/has_person_name.rb
 - lib/person_name/migration_support.rb
 - lib/person_name/name.rb
 - rails/init.rb