namae 1.1.1 → 1.2.0

data/spec/namae/name_spec.rb

@@ -1,133 +0,0 @@
-module Namae
-  describe 'Name' do
-
-    describe '.new' do
-
-      it 'returns an empty name by default' do
-        expect(Name.new).to be_empty
-      end
-
-      it 'sets all passed-in attributes' do
-        expect(Name.new(:given => 'Foo').given).to eq('Foo')
-      end
-
-      it 'ignores unknown attributes' do
-        expect(Name.new(:foo => 'bar')).to be_empty
-      end
-
-    end
-
-    describe '.parse' do
-      it 'returns an empty name for an empty string' do
-        expect(Name.parse('')).to be_empty
-        expect(Name.parse('')).to be_a(Name)
-      end
-
-      it 'returns a single name object if there is more than one name' do
-        expect(Name.parse('Plato and Sokrates').given).to eq('Plato')
-      end
-    end
-
-    describe '#values_at' do
-      it 'returns an array with the given values' do
-        expect(Name.new(:family => 'foo').values_at(:family)).to eq(['foo'])
-      end
-
-      it 'returns an array with the given values' do
-        expect(Name.new(:family => 'foo').values_at(:family)).to eq(['foo'])
-      end
-    end
-
-    describe '#initials' do
-      it "returns the name's initials" do
-        expect(Name.new(:family => 'Poe', :given => 'Edgar A.').initials).to eq('E.A.P.')
-      end
-
-      it "returns the name's initials but leaves the family name expanded" do
-        expect(Name.new(:family => 'Poe', :given => 'Edgar A.').initials(:expand => true)).to eq('E.A. Poe')
-      end
-    end
-
-    describe '#normalize_initials' do
-      it "adds dots to existing initials" do
-        expect(Name.new(:given => 'Edgar A').normalize_initials.given).to eq('Edgar A.')
-        expect(Name.new(:given => 'A').normalize_initials.given).to eq('A.')
-        expect(Name.new(:given => 'E A').normalize_initials.given).to eq('E.A.')
-        expect(Name.new(:given => 'EA').normalize_initials.given).to eq('E.A.')
-        expect(Name.new(:given => 'JFK').normalize_initials.given).to eq('J.F.K.')
-        expect(Name.new(:given => 'E-A').normalize_initials.given).to eq('E.-A.')
-      end
-    end
-
-    describe '#merge' do
-      it 'merges the attributes in the given hash into the name' do
-        expect(Name.new.merge(:family => 'foo').family).to eq('foo')
-      end
-
-      it 'merges the attributes in the given name into the name' do
-        expect(Name.new.merge(Name.new(:family => 'foo')).family).to eq('foo')
-      end
-
-      it 'ignores unknown attributes' do
-        expect(Name.new.merge(:foo => 'bar')).to be_empty
-      end
-
-      it 'ignores nil values' do
-        expect(Name.new(:family => 'foo').merge(:family => nil).family).to eq('foo')
-      end
-    end
-
-    describe '#inspect' do
-      it 'returns the name as a string' do
-        expect(Name.new(:given => 'Ichiro').inspect).to eq('#<Name given="Ichiro">')
-      end
-    end
-
-    describe '#sort_order' do
-      it 'returns an empty string by default' do
-        expect(Name.new.sort_order).to eq('')
-      end
-
-      it 'returns the name in sort order' do
-        expect(Name.new(:given => 'Ichiro', :family => 'Suzuki').sort_order).to eq('Suzuki, Ichiro')
-      end
-
-      it 'returns only the given if there is no family name' do
-        expect(Name.new(:given => 'Ichiro').sort_order).to eq('Ichiro')
-      end
-
-      it 'returns only the family if there is no given name' do
-        expect(Name.new(:family => 'Suzuki').sort_order).to eq('Suzuki')
-      end
-
-      it 'includes the suffix' do
-        expect(Name.new(:family => 'Griffey', :suffix => 'Jr.').sort_order).to eq('Griffey, Jr.')
-        expect(Name.new(:family => 'Griffey', :given => 'Ken', :suffix => 'Jr.').sort_order).to eq('Griffey, Jr., Ken')
-      end
-    end
-
-    describe '#display_order' do
-      it 'returns an empty string by default' do
-        expect(Name.new.display_order).to eq('')
-      end
-
-      it 'returns the name in display order' do
-        expect(Name.new(:given => 'Ichiro', :family => 'Suzuki').display_order).to eq('Ichiro Suzuki')
-      end
-
-      it 'returns only the given if there is no family name' do
-        expect(Name.new(:given => 'Ichiro').display_order).to eq('Ichiro')
-      end
-
-      it 'returns only the family if there is no given name' do
-        expect(Name.new(:family => 'Suzuki').display_order).to eq('Suzuki')
-      end
-
-      it 'includes the suffix' do
-        expect(Name.new(:family => 'Griffey', :suffix => 'Jr.').display_order).to eq('Griffey Jr.')
-        expect(Name.new(:family => 'Griffey', :given => 'Ken', :suffix => 'Jr.').display_order).to eq('Ken Griffey Jr.')
-      end
-    end
-
-  end
-end

data/spec/namae/parser_spec.rb

@@ -1,263 +0,0 @@
-module Namae
-  describe 'Parser' do
-    describe '.instance' do
-      let(:parser) { Parser.instance }
-
-      it 'returns the parser' do
-        expect(parser).to be_a(Parser)
-      end
-
-      describe '#next_token' do
-				before(:each) do
-					Parser.instance.reset
-				end
-
-        describe 'when the input is empty' do
-          it 'returns nil' do
-            expect(parser.send(:next_token)).to be_nil
-          end
-        end
-
-        describe 'when the next input is " and "' do
-          before { parser.send(:input).string = ' and ' }
-          it 'returns an AND token' do
-            expect(parser.send(:next_token)).to eq([:AND, :AND])
-          end
-        end
-
-        describe 'when the next input is " & "' do
-          before { parser.send(:input).string = ' & ' }
-          it 'returns an AND token' do
-            expect(parser.send(:next_token)).to eq([:AND, :AND])
-          end
-        end
-
-        describe 'when the next input is " , "' do
-          before { parser.send(:input).string = ' , ' }
-          it 'returns a COMMA token' do
-            expect(parser.send(:next_token)).to eq([:COMMA, :COMMA])
-          end
-        end
-
-        describe 'when the next input is ", "' do
-          before { parser.send(:input).string = ', ' }
-          it 'returns a COMMA token' do
-            expect(parser.send(:next_token)).to eq([:COMMA, :COMMA])
-          end
-        end
-
-        describe 'when the next input is "; "' do
-          before { parser.send(:input).string = '; ' }
-          it 'returns an AND token' do
-            expect(parser.send(:next_token)).to eq([:AND, :AND])
-          end
-        end
-
-        describe 'when the next input is "foo;"' do
-          before { parser.send(:input).string = 'foo;' }
-          it 'returns an LWORD token "foo"' do
-            expect(parser.send(:next_token)).to eq([:LWORD, 'foo'])
-          end
-        end
-
-        describe 'when the next input is " \'foo bar\' "' do
-          before { parser.send(:input).string = " 'foo bar' " }
-          it 'returns a NICK token' do
-            expect(parser.send(:next_token)).to eq([:NICK, 'foo bar'])
-          end
-        end
-
-        %w{Mr. Mr Mrs. Ms Herr Frau Miss}.each do |appellation|
-          describe "the next token is #{appellation.inspect}" do
-            before { parser.reset.send(:input).string = appellation }
-            it 'returns an APPELLATION token' do
-              expect(parser.send(:next_token)).to eq([:APPELLATION, appellation])
-            end
-          end
-        end
-
-        %w{Jr. Jr Sr. Sr II II. VII IX}.each do |suffix|
-          describe "the next token is #{suffix.inspect}" do
-            before { parser.send(:input).string = suffix }
-            it 'returns an SUFFIX token' do
-              expect(parser.send(:next_token)).to eq([:SUFFIX, suffix])
-            end
-
-            it 'the input matches the suffix pattern' do
-              expect(parser.suffix).to match(suffix)
-            end
-          end
-        end
-
-        %w{Ph.D. PhD PHD Dr. Dr Prof.}.each do |title|
-          describe "the next token is #{title.inspect}" do
-            before { parser.send(:input).string = title }
-            it 'returns a TITLE token' do
-              expect(parser.send(:next_token)).to eq([:TITLE, title])
-            end
-
-            it 'the input matches the suffix pattern' do
-              expect(parser.title).to match(title)
-            end
-          end
-        end
-
-        %w{Gen. Adm Col. Maj Capt. Cmdr. Lt. Sgt. Cpl Pvt.}.each do |title|
-          describe "the next token is #{title.inspect}" do
-            before { parser.send(:input).string = title }
-            it 'returns a TITLE token' do
-              expect(parser.send(:next_token)).to eq([:TITLE, title])
-            end
-
-            it 'the input matches the suffix pattern' do
-              expect(parser.title).to match(title)
-            end
-          end
-        end
-
-        %w{Pastor Pr. Reverend Rev. Elder Deacon Deaconess Father Fr. Vicar Rabbi Cantor}.each do |title|
-          describe "the next token is #{title.inspect}" do
-            before { parser.send(:input).string = title }
-            it 'returns a TITLE token' do
-              expect(parser.send(:next_token)).to eq([:TITLE, title])
-            end
-
-            it 'the input matches the suffix pattern' do
-              expect(parser.title).to match(title)
-            end
-          end
-        end
-      end
-
-      describe '#parse!' do
-        it 'returns an empty list by default' do
-          expect(parser.parse!('')).to be_empty
-        end
-
-        it 'returns a list of names' do
-          expect(parser.parse!('foo')[0]).to be_a(Name)
-        end
-
-        describe 'when parsing a single name' do
-
-          it 'treats "Ichiro" as a given name' do
-            expect(parser.parse!('Ichiro')[0].given).to eq('Ichiro')
-          end
-
-          it 'treats "Lord Byron" as a title and family name' do
-            expect(parser.parse!('Lord Byron')[0].values_at(:family, :title)).to eq(['Byron', 'Lord'])
-          end
-
-          it 'parses given and family part name in "Ichiro Suzuki"' do
-            expect(parser.parse!('Ichiro Suzuki')[0].values_at(:given, :family)).to eq(%w{Ichiro Suzuki})
-          end
-
-          it 'parses given, nick and family part name in "Yukihiro \'Matz\' Matsumoto"' do
-            expect(parser.parse!("Yukihiro 'Matz' Matsumoto")[0].values_at(:given, :family, :nick)).to eq(%w{Yukihiro Matsumoto Matz})
-          end
-
-          it 'parses given, nick and family part name in \'Yukihiro "Matz" Matsumoto\'' do
-            expect(parser.parse!('Yukihiro "Matz" Matsumoto')[0].values_at(:given, :family, :nick)).to eq(%w{Yukihiro Matsumoto Matz})
-          end
-
-          it 'parses appellation and nick in \'Mr. Yukihiro "Matz" Matsumoto\'' do
-            expect(parser.parse!('Mr. Yukihiro "Matz" Matsumoto')[0].values_at(:appellation, :nick)).to eq(%w{Mr. Matz})
-          end
-
-          it 'parses suffix and nick in \'Yukihiro "Matz" Matsumoto Jr.\'' do
-            expect(parser.parse!('Yukihiro "Matz" Matsumoto Jr.')[0].values_at(:suffix, :nick)).to eq(%w{Jr. Matz})
-          end
-
-          it 'parses given and family name in "Poe, Edgar A."' do
-            expect(parser.parse!('Poe, Edgar A.')[0].values_at(:given, :family)).to eq(['Edgar A.', 'Poe'])
-          end
-
-          %w{Mr. Mr Mrs. Ms Herr Frau Miss}.each do |appellation|
-            it "recognizes #{appellation.inspect} as an appellation" do
-              expect(parser.parse!([appellation, 'Edgar A. Poe'].join(' '))[0].appellation).to eq(appellation)
-            end
-          end
-
-          it 'parses common Jr. as a suffix in sort order' do
-            expect(parser.parse!('Griffey, Jr., Ken')[0].values_at(:given, :family, :suffix)).to eq(['Ken', 'Griffey', 'Jr.'])
-            expect(parser.parse!('Griffey, Ken, Jr.')[0].values_at(:given, :family, :suffix)).to eq(['Ken', 'Griffey', 'Jr.'])
-          end
-
-          it 'parses common Jr. as a suffix in display order' do
-            expect(parser.parse!('Ken Griffey Jr.')[0].values_at(:given, :family, :suffix)).to eq(['Ken', 'Griffey', 'Jr.'])
-          end
-
-          it 'parses Ph.D. title suffix in display order' do
-            expect(parser.parse!('Bernado Franecki Ph.D.')[0].values_at(:given, :family, :title)).to eq(['Bernado', 'Franecki', 'Ph.D.'])
-            #expect(parser.parse!('Bernado Franecki, Ph.D.')[0].values_at(:given, :family, :title)).to eq(['Bernado', 'Franecki', 'Ph.D.'])
-          end
-
-          it 'parses consecutive titles in display order' do
-            expect(parser.parse!('Lt. Col. Bernado Franecki')[0].values_at(:given, :family, :title)).to eq(['Bernado', 'Franecki', 'Lt. Col.'])
-          end
-
-          context 'when include_particle_in_family is false' do
-            let(:parser) { Parser.new(include_particle_in_family: false) }
-
-            it 'parses common capitalized particles as the family name in display order' do
-              expect(parser.parse!('Carlos De Silva')[0].values_at(:given, :family, :particle)).to eq(['Carlos', 'Silva', 'De'])
-            end
-
-            it 'parses common capitalized particles with punctuation as the family name in display order' do
-              expect(parser.parse!('Matt St. Hilaire')[0].values_at(:given, :family, :particle)).to eq(['Matt', 'Hilaire', 'St.'])
-            end
-
-            it 'parses multiple common capitalized particles as the family name in display order' do
-              expect(parser.parse!('Tom Van De Weghe')[0].values_at(:given, :family, :particle)).to eq(['Tom', 'Weghe', 'Van De'])
-            end
-
-            it 'parses common lowercase particles as a particle, not family name in display order' do
-              expect(parser.parse!('Carlos de Silva')[0].values_at(:given, :family, :particle)).to eq(['Carlos', 'Silva', 'de'])
-            end
-
-            it 'parses common capitalized particles as the family name in sort order' do
-              expect(parser.parse!('De Silva, Carlos')[0].values_at(:given, :family, :particle)).to eq(['Carlos', 'Silva', 'De'])
-            end
-
-            it 'parses common lowercase particles as a particle, not family name in sort order' do
-              expect(parser.parse!('de Silva, Carlos')[0].values_at(:given, :family, :particle)).to eq(['Carlos', 'Silva', 'de'])
-            end
-
-            it 'parses common capitalized particles with punctuation as the family name in display order' do
-              expect(parser.parse!('St. Hilaire, Matt')[0].values_at(:given, :family, :particle)).to eq(['Matt', 'Hilaire', 'St.'])
-            end
-          end
-
-          context 'when include_particle_in_family is true' do
-            let(:parser) { Parser.new(include_particle_in_family: true) }
-
-            it 'parses common capitalized particles as the family name in display order' do
-              expect(parser.parse!('Carlos De Silva')[0].values_at(:given, :family, :particle)).to eq(['Carlos', 'De Silva', nil])
-            end
-
-            it 'parses common capitalized particles with punctuation as the family name in display order' do
-              expect(parser.parse!('Matt St. Hilaire')[0].values_at(:given, :family, :particle)).to eq(['Matt', 'St. Hilaire', nil])
-            end
-
-            it 'parses common lowercase particles as family name in display order' do
-              expect(parser.parse!('Carlos de Silva')[0].values_at(:given, :family, :particle)).to eq(['Carlos', 'de Silva', nil])
-            end
-
-            it 'parses common capitalized particles as the family name in sort order' do
-              expect(parser.parse!('De Silva, Carlos')[0].values_at(:given, :family, :particle)).to eq(['Carlos', 'De Silva', nil])
-            end
-
-            it 'parses common lowercase particles as family name in sort order' do
-              expect(parser.parse!('de Silva, Carlos')[0].values_at(:given, :family, :particle)).to eq(['Carlos', 'de Silva', nil])
-            end
-
-            it 'parses common capitalized particles with punctuation as the family name in display order' do
-              expect(parser.parse!('St. Hilaire, Matt')[0].values_at(:given, :family, :particle)).to eq(['Matt', 'St. Hilaire', nil])
-            end
-          end
-        end
-      end
-
-    end
-  end
-end

data/spec/namae/utility_spec.rb

@@ -1,21 +0,0 @@
-describe 'Namae' do
-
-  describe '.parse' do
-    it 'returns an empty list by default' do
-      expect(Namae.parse('')).to be_empty
-    end
-  end
-
-  describe '.parse!' do
-    it 'returns an empty list by default' do
-      expect(Namae.parse!('')).to be_empty
-    end
-  end
-    
-  describe '.options' do
-    it 'returns the parse options' do
-      expect(Namae.options).to equal(Namae::Parser.instance.options)
-    end
-  end
-
-end

data/spec/spec_helper.rb

@@ -1,32 +0,0 @@
-begin
-  require 'simplecov'
-  require 'coveralls' if ENV['CI']
-rescue LoadError
-  # ignore
-end unless RUBY_VERSION < '1.9'
-
-begin
-  case
-  when defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
-    require 'rubinius/debugger'
-  when RUBY_VERSION > '2.0'
-    require 'byebug'
-  else
-    require 'debugger'
-  end
-rescue LoadError
-  # ignore
-end
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-require 'rspec'
-require 'namae'
-
-# Requires supporting files with custom matchers and macros, etc,
-# in ./support/ and its subdirectories.
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
-
-RSpec.configure do |config|
-
-end

data/spec/thread_safety_spec.rb

@@ -1,25 +0,0 @@
-module Namae
-  describe 'Parser using threads' do
-    let(:name_1_str) { "Foo Bar" }
-    let(:name_2_str) { "Baz" }
-    let(:name_1) { Namae.parse(name_1_str).first }
-    let(:name_2) { Namae.parse(name_2_str).first }
-
-    def compare(string, expectation)
-      name = Namae.parse(string).first
-      given_name_match = expectation.given == name.given
-      family_name_match = expectation.family == name.family
-      raise unless given_name_match && family_name_match
-    end
-
-    it 'has no conflicts' do
-      [[name_1_str, name_1], [name_2_str, name_2]].map do |string, expectation|
-        Thread.new do
-          1000.times do
-            compare(string, expectation)
-          end
-        end
-      end.each(&:join)
-    end
-  end
-end