person_name 0.1.0

data/.gitignore

@@ -0,0 +1,7 @@
+/pkg/
+Gemfile.lock
+.idea
+*.log
+*.sqlite3
+.bundle
+spec/database.yml

data/Gemfile

@@ -0,0 +1,10 @@
+source :gemcutter
+
+# Rails 3.0
+gem 'rails',        '3.0.0'
+gem 'rspec',        '2.0.0.beta.22'
+gem 'sqlite3-ruby', :require => 'sqlite3'
+gem 'mysql'
+gem 'pg'
+gem 'jeweler'
+gem 'rcov'

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2010 Matthijs Groen
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/README.markdown

@@ -0,0 +1,98 @@
+Person Name
+===========
+Person name is an active record plugin to add support for full names.
+A persons name consists of the following parts: prefix, first_name, middle_name, intercalation, last_name and suffix
+
+If you have to fill in a name for somebody, you have to display all those fields, and fill them in.
+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.
+
+Usage
+=====
+
+Small gem to insert easy person name behaviour into rails models
+
+migration:
+
+    create_table :people do |t|
+        t.person_name :name
+        t.person_name :birth_name
+        t.boolean :female, :null => true
+
+        t.timestamps
+    end
+
+In this case the following fields are created:
+
+    name_prefix
+    name_first_name
+    name_middle_name
+    name_intercalation
+    name_last_name
+    name_suffix
+
+    birth_name_prefix
+    birth_name_first_name
+    birth_name_middle_name
+    birth_name_intercalation
+    birth_name_last_name
+    birth_name_suffix
+
+    female
+    created_at
+    updated_at
+
+model:
+
+    class Person < ActiveRecord::Base
+
+        has_person_name :name, :birth_name
+
+    end
+
+
+Now put this thing to use:
+
+    p = Person.new
+    p.name = "Matthijs Jacobus Groen"
+    p.name.first_name # Matthijs
+    p.name.middle_name # Jacobus
+    p.name.last_name # Groen
+    p.name.short_name # M.J. Groen
+
+    p = Person.new
+    p.name = "Ariejan de Vroom"
+    p.name.first_name # Ariejan
+    p.name.intercalation # de
+    p.name.last_name # Vroom
+    p.name.full_last_name # de Vroom
+
+    p = Person.new
+    p.name = "Cornelia Maria Hendrika Damen-van Valkenberg"
+    p.name.first_name # Cornelia
+    p.name.middle_name # Maria Hendrika
+    p.name.last_name # Damen-van Valkenberg
+
+Sometimes, things can go wrong:
+
+    p = Person.new
+    p.name = "Yolanthe Cabau van Kasbergen"
+    p.name.first_name # Yolanthe
+    p.name.middle_name # Cabau
+    p.name.intercalation # van
+    p.name.last_name # Kasbergen
+
+But, if you correct it, it will remember it:
+
+    p.name.intercalation = nil
+    p.name.middle_name = nil
+    p.name.last_name = "Cabau van Kasbergen"
+
+    # and now change something:
+
+    p.name = "Yolanthe Truuske Cabau van Kasbergen"
+    p.name.first_name # Yolanthe
+    p.name.middle_name # Truuske
+    p.name.intercalation # nil
+    p.name.last_name # Cabau van Kasbergen
+

data/Rakefile

@@ -0,0 +1,62 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "person_name"
+    gem.summary = %Q{Easy editing of person names.}
+    gem.description = %Q{
+      Manages all person name fields (prefix, first name, middle name, intercalation, last name, suffix)
+    }
+    gem.email = "matthijs.groen@gmail.com"
+    gem.homepage = "http://matthijsgroen.posterous.com"
+    gem.authors = ["Matthijs Groen"]
+    #gem.add_development_dependency "shoulda"
+    gem.add_dependency "activerecord", "~> 3.0.0"
+    gem.add_dependency "activesupport", "~> 3.0.0"
+    gem.add_dependency "arel", "~> 1.0.1"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.libs << 'vendor/rails/activerecord/lib'
+  test.libs << 'vendor/rails/activesupport/lib'
+  test.libs << 'vendor/arel/lib'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+# Don't check dependencies since we're testing with vendored libraries
+# task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "meta_where #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/init.rb

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

data/lib/person_name.rb

@@ -0,0 +1,78 @@
+module PersonName
+
+	module ActiveRecord
+
+		def self.included(base) # :nodoc:
+    	base.extend ClassMethods
+    end
+
+		module ClassMethods
+
+			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?
+
+				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
+
+						include PersonName::ActiveRecord::Core
+					end
+				end
+			end
+
+		end
+
+		module Core
+
+			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 %(
+							def #{name_type}
+								person_name_for('#{name_type}')
+							end
+
+							def #{name_type}= new_name
+								set_person_name_for('#{name_type}', new_name)
+							end
+						)
+					end
+				end
+			end
+
+			module InstanceMethods
+
+				def person_name_for field
+					@person_names ||= {}
+					@person_names[field] ||= PersonName::Name.new(field, self)
+				end
+
+				def set_person_name_for field, new_name
+					person_name_for(field).full_name = new_name
+				end
+
+			end
+
+		end
+
+	end
+
+end

data/lib/person_name/migration_support.rb

@@ -0,0 +1,12 @@
+
+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
+
+end

data/lib/person_name/name.rb

@@ -0,0 +1,203 @@
+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
+
+end

data/person_name.gemspec

@@ -0,0 +1,69 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{person_name}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Matthijs Groen"]
+  s.date = %q{2010-09-24}
+  s.description = %q{
+      Manages all person name fields (prefix, first name, middle name, intercalation, last name, suffix)
+    }
+  s.email = %q{matthijs.groen@gmail.com}
+  s.extra_rdoc_files = [
+    "README.markdown"
+  ]
+  s.files = [
+    ".gitignore",
+     "Gemfile",
+     "MIT-LICENSE",
+     "README.markdown",
+     "Rakefile",
+     "VERSION",
+     "init.rb",
+     "lib/person_name.rb",
+     "lib/person_name/migration_support.rb",
+     "lib/person_name/name.rb",
+     "person_name.gemspec",
+     "spec/database.yml.sample",
+     "spec/models.rb",
+     "spec/person_name/has_person_name_spec.rb",
+     "spec/schema.rb",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://matthijsgroen.posterous.com}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Easy editing of person names.}
+  s.test_files = [
+    "spec/person_name/has_person_name_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/models.rb",
+     "spec/schema.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activerecord>, ["~> 3.0.0"])
+      s.add_runtime_dependency(%q<activesupport>, ["~> 3.0.0"])
+      s.add_runtime_dependency(%q<arel>, ["~> 1.0.1"])
+    else
+      s.add_dependency(%q<activerecord>, ["~> 3.0.0"])
+      s.add_dependency(%q<activesupport>, ["~> 3.0.0"])
+      s.add_dependency(%q<arel>, ["~> 1.0.1"])
+    end
+  else
+    s.add_dependency(%q<activerecord>, ["~> 3.0.0"])
+    s.add_dependency(%q<activesupport>, ["~> 3.0.0"])
+    s.add_dependency(%q<arel>, ["~> 1.0.1"])
+  end
+end
+

data/spec/database.yml.sample

@@ -0,0 +1,17 @@
+sqlite3:
+  adapter: sqlite3
+  database: has_person_name.sqlite3
+
+mysql:
+  adapter: mysql
+  hostname: localhost
+  username: root
+  password:
+  database: has_person_name
+
+postgresql:
+  adapter: postgresql
+  hostname: localhost
+  username: postgres
+  password:
+  database: has_person_name

data/spec/models.rb

@@ -0,0 +1,4 @@
+class Person < ActiveRecord::Base
+  has_person_name
+end
+

data/spec/person_name/has_person_name_spec.rb

@@ -0,0 +1,96 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "Has Person Name" do
+  before(:each) do
+    clean_database!
+  end
+
+  describe "Automatic name assignment" do
+    before(:each) do
+      clean_database!
+      @person = Person.new
+    end
+
+    it "should have an accessor for the defined name fields" do
+      @person.should respond_to(:name)
+    end
+
+  end
+
+  describe "Automatic name assignment" do
+    before(:each) do
+      clean_database!
+      @person = Person.new
+    end
+
+    it "should assign name parts to the correct fields" do
+      @person.name = "Matthijs Groen"
+      @person.name.first_name.should == "Matthijs"
+    end
+
+  end
+
+#  it "should provide a class method 'taggable?' that is false for untaggable models" do
+#    UntaggableModel.should_not be_taggable
+#  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
+
+#  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
+
+end

data/spec/schema.rb

@@ -0,0 +1,11 @@
+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"
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,59 @@
+$LOAD_PATH << "." unless $LOAD_PATH.include?(".")
+
+begin
+  require "rubygems"
+  require "bundler"
+
+  if Gem::Version.new(Bundler::VERSION) <= Gem::Version.new("0.9.5")
+    raise RuntimeError, "Your bundler version is too old." +
+     "Run `gem install bundler` to upgrade."
+  end
+
+  # Set up load paths for all bundled gems
+  Bundler.setup
+rescue Bundler::GemNotFound
+  raise RuntimeError, "Bundler couldn't find some gems." +
+    "Did you run `bundle install`?"
+end
+
+Bundler.require
+require File.expand_path('../../lib/person_name', __FILE__)
+
+unless [].respond_to?(:freq)
+  class Array
+    def freq
+      k=Hash.new(0)
+      each {|e| k[e]+=1}
+      k
+    end
+  end
+end
+
+ENV['DB'] ||= 'sqlite3'
+
+database_yml = File.expand_path('../database.yml', __FILE__)
+if File.exists?(database_yml)
+  active_record_configuration = YAML.load_file(database_yml)[ENV['DB']]
+  
+  ActiveRecord::Base.establish_connection(active_record_configuration)
+  ActiveRecord::Base.logger = Logger.new(File.join(File.dirname(__FILE__), "debug.log"))
+  
+  ActiveRecord::Base.silence do
+    ActiveRecord::Migration.verbose = false
+    
+    load(File.dirname(__FILE__) + '/schema.rb')
+    load(File.dirname(__FILE__) + '/models.rb')
+  end  
+  
+else
+  raise "Please create #{database_yml} first to configure your database. Take a look at: #{database_yml}.sample"
+end
+
+def clean_database!
+  models = [Person]
+  models.each do |model|
+    ActiveRecord::Base.connection.execute "DELETE FROM #{model.table_name}"
+  end
+end
+
+clean_database!

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification 
+name: person_name
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Matthijs Groen
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-09-24 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: arel
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 21
+        segments: 
+        - 1
+        - 0
+        - 1
+        version: 1.0.1
+  type: :runtime
+  version_requirements: *id003
+description: "\n      Manages all person name fields (prefix, first name, middle name, intercalation, last name, suffix)\n    "
+email: matthijs.groen@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- .gitignore
+- Gemfile
+- MIT-LICENSE
+- README.markdown
+- Rakefile
+- VERSION
+- init.rb
+- lib/person_name.rb
+- lib/person_name/migration_support.rb
+- lib/person_name/name.rb
+- person_name.gemspec
+- spec/database.yml.sample
+- spec/models.rb
+- spec/person_name/has_person_name_spec.rb
+- spec/schema.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://matthijsgroen.posterous.com
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Easy editing of person names.
+test_files: 
+- spec/person_name/has_person_name_spec.rb
+- spec/spec_helper.rb
+- spec/models.rb
+- spec/schema.rb