namae 0.8.7 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4340f8745ce9d99b766c7b97f5b622b5ae8c9e2f
-  data.tar.gz: ce330d12fa284b820121735722bfd24f31837cff
+  metadata.gz: ca79f39aed91f0816566c4374e8a80c2b10d7aef
+  data.tar.gz: 7e8b909610dab34673e3506f9abfbcbdba7f233a
 SHA512:
-  metadata.gz: 1572cf9924176829e68b70ed94a485528ce13808e571cdfb3e2f77ad962a204d5d27520c3975c8012cdd0d93702fd0ec3a26ed10f09a4651ec079f2d2e756c1d
-  data.tar.gz: 8cd73bc608b791c66b2504d1b4a598d4742d0ba1fb9e67b6e11e9bfafb32f35b0776b6e2e6bd9ba81a655327ee3489e47e8b6b5cc025a56f5c20d54ff063ecb4
+  metadata.gz: 1635916f55db9770ebc2b02b25af4b1d306119e5349db2ed6b5a146ab117e222081f7338c4e06a908fc1f1e8f58d887a99290cb4fecc7185f4baf3d508b15620
+  data.tar.gz: 891f0c209b26d0b0aabb79ad0cc1daa85410a900237482a36f0283ee674d603d68be12088ea9c4ae85ce35d1eee02ebb3dbe9b646d8052bd10e1c0e6b59246a8

data/Gemfile

@@ -1,7 +1,7 @@
 source 'https://rubygems.org'
 
 group :test do
-  gem 'rspec', '~>2.14'
+  gem 'rspec', '~>3.0'
   gem 'rake', '~>10.1'
   gem 'cucumber', '~>1.3'
 end

data/features/step_definitions/namae_steps.rb

@@ -13,24 +13,28 @@ end
 
 Then /^the BibTeX parts should be:$/ do |table|
   table.hashes.each do |row|
-    @name.values_at(:given, :particle, :family, :suffix).map(&:to_s).should ==
-      row.values_at('first', 'von', 'last', 'jr')
+    expect(
+      @name.values_at(:given, :particle, :family, :suffix).map(&:to_s)
+    ).to eq(row.values_at('first', 'von', 'last', 'jr'))
   end
 end
 
 Then /^the parts should be:$/ do |table|
   table.hashes.each do |row|
-    @name.values_at(:given, :particle, :family, :suffix, :title, :appellation, :nick).map(&:to_s).should ==
-      row.values_at('given', 'particle', 'family', 'suffix', 'title', 'appellation', 'nick')
+    expect(
+      @name.values_at(:given, :particle, :family, :suffix, :title, :appellation, :nick).map(&:to_s)
+    ).to eq(row.values_at('given', 'particle', 'family', 'suffix', 'title', 'appellation', 'nick'))
   end
 end
 
 Then /^there should be (\d+) names$/ do |count|
-  @names.length.should == count.to_i
+  expect(@names.length).to eq(count.to_i)
 end
 
 Then /^the names should be:$/ do |table|
   table.hashes.each_with_index do |row, i|
-    @names[i].values_at(*row.keys.map(&:to_sym)).map(&:to_s).should == row.values
+    expect(
+      @names[i].values_at(*row.keys.map(&:to_sym)).map(&:to_s)
+    ).to eq(row.values)
   end
-end
+end

data/lib/namae/name.rb

@@ -49,6 +49,27 @@ module Namae
       i.gsub!(/\s+/, '') unless options[:spaces]
       i
     end
+
+    # @param name [String] a name or part of a name
+    # @return [String] the passed-in name with normalized initials
+    def existing_initials_of(name, options = {})
+      return unless name
+
+      i = name.dup
+
+      i.gsub!(/\.+/, '')
+      i.gsub!(/\b[[:upper:]]+\b/) { |m| m.chars.join(' ') }
+
+      if options[:dots]
+        i.gsub!(/\b([[:upper:]])\b/, '\1.')
+      end
+
+      if !options[:spaces]
+        i.gsub!(/\b([[:upper:]]\.?)\s+/, '\1')
+      end
+
+      i
+    end
   end
 
   # A Name represents a single personal name, exposing its constituent
@@ -154,6 +175,13 @@ module Namae
       super(*arguments.flatten.map { |k| k.is_a?(Symbol) ? Name.parts.index(k) : k })
     end
 
+    def normalize_initials(options = {})
+      return self if given.nil?
+
+      options = Name.defaults[:initials].merge(options)
+      self.given = existing_initials_of given, options
+      self
+    end
 
     # @return [String] a string representation of the name
     def inspect

data/lib/namae/version.rb

@@ -1,8 +1,8 @@
 module Namae
   module Version
     MAJOR = 0
-    MINOR = 8
-    PATCH = 7
+    MINOR = 9
+    PATCH = 0
     BUILD = nil
 
     STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.').freeze

data/namae.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: namae 0.8.7 ruby lib
+# stub: namae 0.9.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "namae"
-  s.version = "0.8.7"
+  s.version = "0.9.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
   s.authors = ["Sylvester Keil", "Dan Collis-Puro"]
-  s.date = "2014-05-14"
+  s.date = "2014-06-10"
   s.description = " Namae (\u{540d}\u{524d}) is a parser for human names. It recognizes personal names of various cultural backgrounds and tries to split them into their component parts (e.g., given and family names, honorifics etc.). "
   s.email = ["sylvester@keil.or.at", "dan@collispuro.com"]
   s.extra_rdoc_files = [

data/spec/namae/name_spec.rb

@@ -4,117 +4,128 @@ module Namae
     describe '.new' do
 
       it 'returns an empty name by default' do
-        Name.new.should be_empty
+        expect(Name.new).to be_empty
       end
 
       it 'sets all passed-in attributes' do
-        Name.new(:given => 'Foo').given.should == 'Foo'
+        expect(Name.new(:given => 'Foo').given).to eq('Foo')
       end
 
       it 'ignores unknown attributes' do
-        Name.new(:foo => 'bar').should be_empty
+        expect(Name.new(:foo => 'bar')).to be_empty
       end
 
     end
 
     describe '.parse' do
       it 'returns an empty name for an empty string' do
-        Name.parse('').should be_empty
-        Name.parse('').should be_a(Name)
+        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
-        Name.parse('Plato and Sokrates').given.should == 'Plato'
+        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
-        Name.new(:family => 'foo').values_at(:family).should == ['foo']
+        expect(Name.new(:family => 'foo').values_at(:family)).to eq(['foo'])
       end
 
       it 'returns an array with the given values' do
-        Name.new(:family => 'foo').values_at(:family).should == ['foo']
+        expect(Name.new(:family => 'foo').values_at(:family)).to eq(['foo'])
       end
     end
 
     describe '#initials' do
       it "returns the name's initials" do
-        Name.new(:family => 'Poe', :given => 'Edgar A.').initials.should == 'E.A.P.'
+        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
-        Name.new(:family => 'Poe', :given => 'Edgar A.').initials(:expand => true).should == 'E.A. Poe'
+        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
-        Name.new.merge(:family => 'foo').family.should == 'foo'
+        expect(Name.new.merge(:family => 'foo').family).to eq('foo')
       end
 
       it 'merges the attributes in the given name into the name' do
-        Name.new.merge(Name.new(:family => 'foo')).family.should == 'foo'
+        expect(Name.new.merge(Name.new(:family => 'foo')).family).to eq('foo')
       end
 
       it 'ignores unknown attributes' do
-        Name.new.merge(:foo => 'bar').should be_empty
+        expect(Name.new.merge(:foo => 'bar')).to be_empty
       end
 
       it 'ignores nil values' do
-        Name.new(:family => 'foo').merge(:family => nil).family.should == 'foo'
+        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
-        Name.new(:given => 'Ichiro').inspect.should == '#<Name given="Ichiro">'
+        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
-        Name.new.sort_order.should == ''
+        expect(Name.new.sort_order).to eq('')
       end
 
       it 'returns the name in sort order' do
-        Name.new(:given => 'Ichiro', :family => 'Suzuki').sort_order.should == 'Suzuki, Ichiro'
+        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
-        Name.new(:given => 'Ichiro').sort_order.should == 'Ichiro'
+        expect(Name.new(:given => 'Ichiro').sort_order).to eq('Ichiro')
       end
 
       it 'returns only the family if there is no given name' do
-        Name.new(:family => 'Suzuki').sort_order.should == 'Suzuki'
+        expect(Name.new(:family => 'Suzuki').sort_order).to eq('Suzuki')
       end
 
       it 'includes the suffix' do
-        Name.new(:family => 'Griffey', :suffix => 'Jr.').sort_order.should == 'Griffey, Jr.'
-        Name.new(:family => 'Griffey', :given => 'Ken', :suffix => 'Jr.').sort_order.should == 'Griffey, Jr., Ken'
+        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
-        Name.new.display_order.should == ''
+        expect(Name.new.display_order).to eq('')
       end
 
       it 'returns the name in display order' do
-        Name.new(:given => 'Ichiro', :family => 'Suzuki').display_order.should == 'Ichiro Suzuki'
+        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
-        Name.new(:given => 'Ichiro').display_order.should == 'Ichiro'
+        expect(Name.new(:given => 'Ichiro').display_order).to eq('Ichiro')
       end
 
       it 'returns only the family if there is no given name' do
-        Name.new(:family => 'Suzuki').display_order.should == 'Suzuki'
+        expect(Name.new(:family => 'Suzuki').display_order).to eq('Suzuki')
       end
 
       it 'includes the suffix' do
-        Name.new(:family => 'Griffey', :suffix => 'Jr.').display_order.should == 'Griffey Jr.'
-        Name.new(:family => 'Griffey', :given => 'Ken', :suffix => 'Jr.').display_order.should == 'Ken Griffey Jr.'
+        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
 

data/spec/namae/parser_spec.rb

@@ -2,14 +2,14 @@ module Namae
   describe 'Parser' do
 
     it 'does not respond to .new' do
-      Parser.should_not respond_to(:new)
+      expect(Parser).not_to respond_to(:new)
     end
 
     describe '.instance' do
       let(:parser) { Parser.instance }
 
       it 'returns the parser' do
-        parser.should be_a(Parser)
+        expect(parser).to be_a(Parser)
       end
 
       describe '#next_token' do
@@ -19,35 +19,35 @@ module Namae
 
         describe 'when the input is empty' do
           it 'returns nil' do
-            parser.send(:next_token).should be_nil
+            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
-            parser.send(:next_token).should == [:AND, :AND]
+            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
-            parser.send(:next_token).should == [:AND, :AND]
+            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
-            parser.send(:next_token).should == [:COMMA, :COMMA]
+            expect(parser.send(:next_token)).to eq([:COMMA, :COMMA])
           end
         end
 
         describe 'when the next input is " \'foo bar\' "' do
           before { parser.send(:input).string = " 'foo bar' " }
           it 'returns a NICK token' do
-            parser.send(:next_token).should == [:NICK, 'foo bar']
+            expect(parser.send(:next_token)).to eq([:NICK, 'foo bar'])
           end
         end
 
@@ -55,7 +55,7 @@ module Namae
           describe "the next token is #{appellation.inspect}" do
             before { parser.send(:input).string = appellation }
             it 'returns an APPELLATION token' do
-              parser.send(:next_token).should == [:APPELLATION, appellation]
+              expect(parser.send(:next_token)).to eq([:APPELLATION, appellation])
             end
           end
         end
@@ -64,11 +64,11 @@ module Namae
           describe "the next token is #{suffix.inspect}" do
             before { parser.send(:input).string = suffix }
             it 'returns an SUFFIX token' do
-              parser.send(:next_token).should == [:SUFFIX, suffix]
+              expect(parser.send(:next_token)).to eq([:SUFFIX, suffix])
             end
 
             it 'the input matches the suffix pattern' do
-              parser.suffix.should match(suffix)
+              expect(parser.suffix).to match(suffix)
             end
           end
         end
@@ -77,52 +77,52 @@ module Namae
 
       describe '#parse!' do
         it 'returns an empty list by default' do
-          parser.parse!('').should be_empty
+          expect(parser.parse!('')).to be_empty
         end
 
         it 'returns a list of names' do
-          parser.parse!('foo')[0].should be_a(Name)
+          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
-            parser.parse!('Ichiro')[0].given.should == 'Ichiro'
+            expect(parser.parse!('Ichiro')[0].given).to eq('Ichiro')
           end
 
           it 'treats "Lord Byron" as a title and family name' do
-            parser.parse!('Lord Byron')[0].values_at(:family, :title).should == ['Byron', 'Lord']
+            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
-            parser.parse!('Ichiro Suzuki')[0].values_at(:given, :family).should == %w{Ichiro Suzuki}
+            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
-            parser.parse!("Yukihiro 'Matz' Matsumoto")[0].values_at(:given, :family, :nick).should == %w{Yukihiro Matsumoto Matz}
+            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
-            parser.parse!('Yukihiro "Matz" Matsumoto')[0].values_at(:given, :family, :nick).should == %w{Yukihiro Matsumoto Matz}
+            expect(parser.parse!('Yukihiro "Matz" Matsumoto')[0].values_at(:given, :family, :nick)).to eq(%w{Yukihiro Matsumoto Matz})
           end
 
           it 'parses given and family name in "Poe, Edgar A."' do
-            parser.parse!('Poe, Edgar A.')[0].values_at(:given, :family).should == ['Edgar A.', 'Poe']
+            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
-              parser.parse!([appellation, 'Edgar A. Poe'].join(' '))[0].appellation.should == appellation
+              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
-            parser.parse!('Griffey, Jr., Ken')[0].values_at(:given, :family, :suffix).should == ['Ken', 'Griffey', 'Jr.']
-            parser.parse!('Griffey, Ken, Jr.')[0].values_at(:given, :family, :suffix).should == ['Ken', 'Griffey', 'Jr.']
+            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
-            parser.parse!('Ken Griffey Jr.')[0].values_at(:given, :family, :suffix).should == ['Ken', 'Griffey', 'Jr.']
+            expect(parser.parse!('Ken Griffey Jr.')[0].values_at(:given, :family, :suffix)).to eq(['Ken', 'Griffey', 'Jr.'])
           end
 
         end

data/spec/namae/utility_spec.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: namae
 version: !ruby/object:Gem::Version
-  version: 0.8.7
+  version: 0.9.0
 platform: ruby
 authors:
 - Sylvester Keil
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-14 00:00:00.000000000 Z
+date: 2014-06-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: simplecov