nameable 1.1.3 → 1.1.4

data/lib/nameable.rb

@@ -1,8 +1,8 @@
-require "nameable/version"
-require "nameable/assets"
-require "nameable/error"
-require "nameable/latin"
-require "nameable/extensions"
+require 'nameable/version'
+require 'nameable/error'
+require 'nameable/assets'
+require 'nameable/latin'
+require 'nameable/extensions'
 
 module Nameable
   def self.parse(name)

data/lib/nameable/assets.rb

@@ -1,4 +1,6 @@
-module Nameable::Assets
-  GENDER_TABLE    = File.expand_path(File.join('..', '..', '..', 'data', 'yob2014.txt'), __FILE__)
-  ETHNICITY_TABLE = File.expand_path(File.join('..', '..', '..', 'data', 'app_c.csv'), __FILE__)
+module Nameable
+  module Assets
+    GENDER_TABLE    = File.expand_path(File.join('..', '..', '..', 'data', 'yob2016.txt'), __FILE__)
+    ETHNICITY_TABLE = File.expand_path(File.join('..', '..', '..', 'data', 'app_c.csv'), __FILE__)
+  end
 end

data/lib/nameable/error.rb

@@ -1,5 +1,4 @@
 module Nameable
-  # Raised if something other than a valid Name is supplied
   class InvalidNameError < StandardError
   end
 end

data/lib/nameable/latin.rb

@@ -9,7 +9,6 @@ module Nameable
 
     attr_accessor :prefix, :first, :middle, :last, :suffix
 
-    ##
     def initialize(*args)
       if args.size == 1 && args.first.class == Hash
         parts = args.first
@@ -19,29 +18,28 @@ module Nameable
         @last   = parts[:last]    ? parts[:last]    : nil
         @suffix = parts[:suffix]  ? parts[:suffix]  : nil
       else
-        @first = args.shift if args.size > 0
+        @first = args.shift unless args.empty?
         @middle = args.shift if args.size >= 2 # Only grab a middle name if we've got a last name left
-        @last = args.shift if args.size > 0
+        @last = args.shift unless args.empty?
       end
     end
 
     ##
     # name is an Array
     def extract_prefix(name)
-      return unless name and name.size > 1 and @prefix.nil? and @first.nil?
-      Nameable::Latin::Patterns::PREFIX.each_pair do |pretty, regex|
-        if name.first =~ regex
-          @prefix = pretty
-          name.delete(name.first)
-          return
-        end
+      return unless name && name.size > 1 && @prefix.nil? && @first.nil?
+      Nameable::Latin::Patterns::PREFIX.each do |pretty, regex|
+        next unless name.first =~ regex
+        @prefix = pretty
+        name.delete(name.first)
+        break
       end
     end
 
     ##
     # name is an Array
     def extract_suffix(name)
-      return unless name and name.size >= 3
+      return unless name && name.size >= 3
 
       (name.size - 1).downto(2) do |n|
         suff = nil
@@ -50,48 +48,52 @@ module Nameable
           suff = pretty if name[n] =~ regex
         end
 
-        if name[n] =~ Nameable::Latin::Patterns::SUFFIX_ACADEMIC or name[n] =~ Nameable::Latin::Patterns::SUFFIX_PROFESSIONAL or name[n] =~ Nameable::Latin::Patterns::SUFFIX_GENERATIONAL_ROMAN
-          suff = name[n].upcase.gsub(/\./,'')
+        if name[n] =~ Nameable::Latin::Patterns::SUFFIX_ACADEMIC ||
+           name[n] =~ Nameable::Latin::Patterns::SUFFIX_PROFESSIONAL ||
+           name[n] =~ Nameable::Latin::Patterns::SUFFIX_GENERATIONAL_ROMAN
+          suff = name[n].upcase.delete('.')
         end
 
-        if !suff && name.join != name.join.upcase and name[n].length > 1 and name[n] =~ Nameable::Latin::Patterns::SUFFIX_ABBREVIATION
-          suff = name[n].upcase.gsub(/\./,'')
+        if !suff &&
+           name.join != name.join.upcase &&
+           name[n].length > 1 &&
+           name[n] =~ Nameable::Latin::Patterns::SUFFIX_ABBREVIATION
+          suff = name[n].upcase.delete('.')
         end
 
         if suff
           @suffix = @suffix ? "#{suff}, #{@suffix}" : suff
           name.delete_at(n)
         end
-
       end
     end
 
     ##
     # name is an Array
     def extract_first(name)
-      return unless name and name.size >= 1
+      return unless name && name.size >= 1
 
       @first = name.first
       name.delete_at(0)
 
-      @first.capitalize! unless @first =~ /[a-z]/ and @first =~ /[A-Z]/
+      @first.capitalize! unless @first =~ /[a-z]/ && @first =~ /[A-Z]/
     end
 
     ##
     # name is an Array
     def extract_last(name)
-      return unless name and name.size >= 1
+      return unless name && name.size >= 1
 
       @last = name.last.gsub(/['`"]+/, "'").gsub(/-+/, '-')
       name.delete_at(name.size - 1)
 
-      @last.capitalize! unless @last =~ /[a-z]/ and @last =~ /[A-Z]/
+      @last.capitalize! unless @last =~ /[a-z]/ && @last =~ /[A-Z]/
     end
 
     ##
     # name is an Array
     def extract_middle(name)
-      return unless name and name.size >= 1
+      return unless name && name.size >= 1
 
       (name.size - 1).downto(0) do |n|
         next unless name[n]
@@ -100,9 +102,9 @@ module Nameable
           @last = "#{name[n].downcase.capitalize} #{@last}"
         elsif name[n] =~ Nameable::Latin::Patterns::O_LAST_NAME_PRE_CONCATS
           @last = "O'#{@last}"
-        elsif name[n] =~ /\-/ and n > 0 and name[n-1]
-          @last = "#{name[n-1].gsub(/\-/, '')}-#{@last}"
-          name[n-1] = nil
+        elsif name[n] =~ /\-/ && n > 0 && name[n - 1]
+          @last = "#{name[n - 1].delete('-')}-#{@last}"
+          name[n - 1] = nil
         else
           @middle = @middle ? "#{name[n]} #{@middle}" : name[n]
         end
@@ -110,21 +112,21 @@ module Nameable
         name.delete_at(n)
       end
 
-      @middle.capitalize! if @middle and !(@middle =~ /[a-z]/ and @middle =~ /[A-Z]/)
-      @middle = "#{@middle}." if @middle and @middle.size == 1
+      @middle.capitalize! if @middle && !(@middle =~ /[a-z]/ && @middle =~ /[A-Z]/)
+      @middle = "#{@middle}." if @middle && @middle.size == 1
     end
 
     def parse(name)
       raise InvalidNameError unless name
       if name.class == String
         if name.index(',')
-          name = "#{$2} #{$1}" if name =~ /^([a-z]+)\s*,\s*,*([^,]*)/i
+          name = "#{Regexp.last_match(2)} #{Regexp.last_match(1)}" if name =~ /^([a-z]+)\s*,\s*,*([^,]*)/i
         end
 
         name = name.strip.split(/\s+/)
       end
 
-      name = name.first.split(/[^[:alnum:]]+/) if name.size == 1 and name.first.split(/[^[:alnum:]]+/)
+      name = name.first.split(/[^[:alnum:]]+/) if name.size == 1 && name.first.split(/[^[:alnum:]]+/)
 
       extract_prefix(name)
       extract_suffix(name)
@@ -138,7 +140,7 @@ module Nameable
     end
 
     # http://www.ssa.gov/oact/babynames/limits.html
-    def load_huge_gender_table(gender_table=Nameable::Assets::GENDER_TABLE)
+    def load_huge_gender_table(gender_table = Nameable::Assets::GENDER_TABLE)
       ranked = {}
 
       CSV.read(gender_table).each do |first, gender, rank|
@@ -161,45 +163,45 @@ module Nameable
 
     # http://www.census.gov/genealogy/www/data/2000surnames/index.html
     def load_huge_ethnicity_table
-      CSV.read(File.expand_path(File.join('..', '..', '..', 'data', 'app_c.csv'), __FILE__)).each do |name, rank, count, prop100k, cum_prop100k, pctwhite, pctblack, pctapi, pctaian, pct2prace, pcthispanic|
+      CSV.read(File.expand_path(File.join('..', '..', '..', 'data', 'app_c.csv'), __FILE__)).each do |name, rank, count, _prop100k, _cum_prop100k, pctwhite, pctblack, pctapi, pctaian, pct2prace, pcthispanic|
         next if name == 'name'
         @@last_names[name.downcase] = {
-          rank:rank.to_i,
-          count:count.to_i,
-          percent_white:pctwhite.to_f,
-          percent_black:pctblack.to_f,
-          percent_asian_pacific_islander:pctapi.to_f,
-          percent_american_indian_alaska_native:pctaian.to_f,
-          percent_two_or_more_races:pct2prace.to_f,
-          percent_hispanic:pcthispanic.to_f
+          rank: rank.to_i,
+          count: count.to_i,
+          percent_white: pctwhite.to_f,
+          percent_black: pctblack.to_f,
+          percent_asian_pacific_islander: pctapi.to_f,
+          percent_american_indian_alaska_native: pctaian.to_f,
+          percent_two_or_more_races: pct2prace.to_f,
+          percent_hispanic: pcthispanic.to_f
         }
       end
     end
 
     def gender
       return @gender if @gender
-      load_huge_gender_table unless @@first_names && @@first_names.size > 0
+      load_huge_gender_table unless @@first_names && !@@first_names.empty?
       @gender = @@first_names[@first.to_s.downcase] ? @@first_names[@first.to_s.downcase] : :unknown
       @gender
     end
 
     def ethnicity
       return @ethnicity if @ethnicity
-      load_huge_ethnicity_table unless @@last_names && @@last_names.size > 0
-      @ethnicity = (@last && @@last_names[@last.downcase]) ? @@last_names[@last.downcase] : :unknown
+      load_huge_ethnicity_table unless @@last_names && !@@last_names.empty?
+      @ethnicity = @last && @@last_names[@last.downcase] ? @@last_names[@last.downcase] : :unknown
       @ethnicity
     end
 
     def male?
-      self.gender == :male
+      gender == :male
     end
 
     def female?
-      self.gender == :female
+      gender == :female
     end
 
     def to_s
-      [@prefix, @first, @middle, @last].compact.join(' ') + (@suffix ? ", #{@suffix}" : "")
+      [@prefix, @first, @middle, @last].compact.join(' ') + (@suffix ? ", #{@suffix}" : '')
     end
 
     def to_name
@@ -235,12 +237,12 @@ module Nameable
     end
 
     def to_hash
-      return {
-        :prefix => @prefix,
-        :first => @first,
-        :middle => @middle,
-        :last => @last,
-        :suffix => @suffix
+      {
+        prefix: @prefix,
+        first: @first,
+        middle: @middle,
+        last: @last,
+        suffix: @suffix
       }
     end
   end

data/lib/nameable/latin/patterns.rb

@@ -1,30 +1,35 @@
 module Nameable
   class Latin
-    ##
     # Regex's to match the detritus that people add to their names
     module Patterns
       PREFIX = {
-        "Mr."    => /^\(*(mr\.*|mister)\)*$/i,
-        "Mrs."   => /^\(*(mrs\.*|misses)\)*$/i,
-        "Ms."    => /^\(*(ms\.*|miss)\)*$/i,
-        "Dr."    => /^\(*(dr\.*|doctor)\)*$/i,
-        "Rev."   => /^\(*(rev\.*|reverend)\)*$/i,
-        "Fr."    => /^\(*(fr\.*|friar)\)*$/i,
-        "Master" => /^\(*(master)\)*$/i,
-        "Sir"    => /^\(*(sir)\)*$/i
-      }
+        'Capt.'  => /^\(*(capt\.*|captain)\)*$/i,
+        'Dame'   => /^\(*(dame)\)*$/i,
+        'Dr.'    => /^\(*(dr\.*|doctor)\)*$/i,
+        'Fr.'    => /^\(*(fr\.*|friar|father)\)*$/i,
+        'Hon.'	 => /^\(*(hon\.*|honorable)\)*$/i,
+        'Imam'   => /^\(*(imam)\)*$/i,
+        'Ofc.'   => /^\(*(ofc\.*|officer)\)*$/i,
+        'Mr.'    => /^\(*(mr\.*|mister)\)*$/i,
+        'Mrs.'   => /^\(*(mrs\.*|misses)\)*$/i,
+        'Ms.'    => /^\(*(ms\.*|miss)\)*$/i,
+        'Rev.'   => /^\(*(rev\.*|reverend)\)*$/i,
+        'Master' => /^\(*(master)\)*$/i,
+        'Rabbi'  => /^\(*(rabbi)\)*$/i,
+        'Sir'    => /^\(*(sir)\)*$/i
+      }.freeze
 
       SUFFIX = {
-        "Sr."   => /^\(*(sr\.?|senior)\)*$/i,
-        "Jr."   => /^\(*(jr\.?|junior)\)*$/i,
-        "Esq."  => /^\(*(esq\.?|esquire)\)*$/i,
-        "Ph.D." => /^\(*(p\.?h\.?d\.?)\)*$/i
-      }
+        'Sr.'   => /^\(*(sr\.?|senior)\)*$/i,
+        'Jr.'   => /^\(*(jr\.?|junior)\)*$/i,
+        'Esq.'  => /^\(*(esq\.?|esquire)\)*$/i,
+        'Ph.D.' => /^\(*(p\.?h\.?d\.?)\)*$/i
+      }.freeze
 
       SUFFIX_GENERATIONAL_ROMAN = /^\(*[IVX.]+\)*$/i
       SUFFIX_ACADEMIC = /^(APR|RPh|MD|MA|DMD|DDS|PharmD|EngD|DPhil|JD|DD|DO|BA|BS|BSc|BE|BFA|MA|MS|MSc|MFA|MLA|MBA)$/i
-      SUFFIX_PROFESSIONAL = /^(PE|CSA|CPA|CPL|CME|CEng|OFM|CSV|Douchebag)$/i
-      SUFFIX_ABBREVIATION = /^[A-Z.]+[A-Z.]+$/  # It should be at least 2 letters
+      SUFFIX_PROFESSIONAL = /^(PE|CSA|CPA|CPL|CME|CEng|OFM|CSV)$/i
+      SUFFIX_ABBREVIATION = /^[A-Z]\.?[A-Z]\.?[A-Z]?\.?$/ # 2-3 characters, possibly separated with '.'
 
       # http://www.onlineaspect.com/2009/08/17/splitting-names/
       LAST_NAME_PRE_DANGLERS = /^(mc|vere|von|van|da|de|del|della|di|da|pietro|vanden|du|st|la|ter|ten)$/i

data/lib/nameable/version.rb

@@ -1,3 +1,3 @@
 module Nameable
-  VERSION = "1.1.3"
+  VERSION = '1.1.4'.freeze
 end

data/nameable.gemspec

@@ -1,4 +1,5 @@
 # coding: utf-8
+
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'nameable/version'
@@ -12,20 +13,21 @@ Gem::Specification.new do |spec|
   spec.description   = 'A library that provides parsing and output of person names, as well as Gender & Ethnicity matching.'
   spec.homepage      = 'https://github.com/chorn/nameable'
   spec.license       = 'MIT'
-
   spec.files         = `git ls-files -z`.split("\x0")
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
+  spec.required_ruby_version = '>= 1.9'
 
-  signing_key = File.expand_path("~/.certs/chorn@chorn.com-rubygems.key")
+  signing_key = File.expand_path '~/.certs/chorn@chorn.com-rubygems.key'
   if File.file?(signing_key)
     spec.signing_key = signing_key
     spec.cert_chain = ['certs/chorn.pem']
   end
 
-  spec.add_development_dependency 'bundler', '~> 1.6'
-  spec.add_development_dependency 'codeclimate-test-reporter', '~> 0.4'
-  spec.add_development_dependency 'rake', '~> 10.4'
-  spec.add_development_dependency 'rspec', '~> 3.3'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '~> 3.6'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'codeclimate-test-reporter'
 end

data/spec/nameable/extensions_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Object do
+  it 'returns a string' do
+    expect(Nameable('Chris Horn')).to be_a(String)
+  end
+
+  it 'raises an exception' do
+    expect { Nameable(nil) }.to raise_error Nameable::InvalidNameError
+  end
+end

data/spec/nameable/latin_spec.rb

@@ -1,5 +1,17 @@
 require 'spec_helper'
 
+shared_examples :generalized_parsing do |input, outputs|
+  let(:nameable) { Nameable::Latin.new.parse(input) }
+
+  it "#parse ``#{input}''" do
+    expect(nameable.prefix).to eq outputs[0]
+    expect(nameable.first).to eq outputs[1]
+    expect(nameable.middle).to eq outputs[2]
+    expect(nameable.last).to eq outputs[3]
+    expect(nameable.suffix).to eq outputs[4]
+  end
+end
+
 describe Nameable::Latin do
   describe '.new' do
     it "doesn't raise" do
@@ -7,318 +19,166 @@ describe Nameable::Latin do
     end
   end
 
-  context('with a single word name') do
-    subject(:n) { Nameable::Latin.new.parse("Chris") }
-    it '.parse' do
-      expect(n.prefix).to be_nil
-      expect(n.first).to eq('Chris')
-      expect(n.middle).to be_nil
-      expect(n.last).to be_nil
-      expect(n.suffix).to be_nil
+  describe '#parse' do
+    context 'with a single word name' do
+      it_behaves_like :generalized_parsing, 'Chris', [nil, 'Chris', nil, nil, nil]
     end
-  end
 
-  context('with a simple name') do
-    subject(:n) { Nameable::Latin.new.parse("Chris Horn") }
-    it '.prefix' do
-      expect(n.prefix).to be_nil
+    context 'with a simple first and last name' do
+      it_behaves_like :generalized_parsing, 'Chris Horn', [nil, 'Chris', nil, 'Horn', nil]
     end
-    it '.first' do
-      expect(n.first).to eq('Chris')
-    end
-    it '.middle' do
-      expect(n.middle).to be_nil
-    end
-    it '.last' do
-      expect(n.last).to eq('Horn')
-    end
-    it '.suffix' do
-      expect(n.suffix).to be_nil
-    end
-  end
 
-  context('with an all uppercase name') do
-    subject(:n) { Nameable::Latin.new.parse("CHRIS HORN") }
-    it '.first' do
-      expect(n.first).to eq('Chris')
+    context 'with an uppercase first and last name' do
+      it_behaves_like :generalized_parsing, 'CHRIS HORN', [nil, 'Chris', nil, 'Horn', nil]
     end
-    it '.last' do
-      expect(n.last).to eq('Horn')
-    end
-  end
 
-  context('with an all lowercase name') do
-    subject(:n) { Nameable::Latin.new.parse("chris horn") }
-    it '.first' do
-      expect(n.first).to eq('Chris')
-    end
-    it '.last' do
-      expect(n.last).to eq('Horn')
+    context 'with a lowercase first and last name' do
+      it_behaves_like :generalized_parsing, 'chris horn', [nil, 'Chris', nil, 'Horn', nil]
     end
-  end
 
-  context('with a mixed case name') do
-    subject(:n) { Nameable::Latin.new.parse("DeChris HORN") }
-    it '.first' do
-      expect(n.first).to eq('DeChris')
+    context 'with a mixed case first and last name' do
+      it_behaves_like :generalized_parsing, 'DeChris Horn', [nil, 'DeChris', nil, 'Horn', nil]
     end
-  end
 
-  context('last_name, first_name') do
-    subject(:n) { Nameable::Latin.new.parse("Horn, Chris") }
-    it '.prefix' do
-      expect(n.prefix).to be_nil
+    context 'with last name, first name' do
+      it_behaves_like :generalized_parsing, 'Horn, Chris', [nil, 'Chris', nil, 'Horn', nil]
     end
-    it '.first' do
-      expect(n.first).to eq('Chris')
-    end
-    it '.middle' do
-      expect(n.middle).to be_nil
-    end
-    it '.last' do
-      expect(n.last).to eq('Horn')
-    end
-    it '.suffix' do
-      expect(n.suffix).to be_nil
-    end
-  end
 
-  context('last_name, first_name,') do
-    subject(:n) { Nameable::Latin.new.parse("Horn, Chris,") }
-    it '.prefix' do
-      expect(n.prefix).to be_nil
+    context 'with last name, first name,' do
+      it_behaves_like :generalized_parsing, 'Horn, Chris,', [nil, 'Chris', nil, 'Horn', nil]
     end
-    it '.first' do
-      expect(n.first).to eq('Chris')
-    end
-    it '.middle' do
-      expect(n.middle).to be_nil
-    end
-    it '.last' do
-      expect(n.last).to eq('Horn')
-    end
-    it '.suffix' do
-      expect(n.suffix).to be_nil
-    end
-  end
 
-  context('with a simple middle name') do
-    subject(:n) { Nameable::Latin.new.parse("Chris Derp Horn") }
-    it '.prefix' do
-      expect(n.prefix).to be_nil
+    context 'with first middle last name' do
+      it_behaves_like :generalized_parsing, 'Chris Derp Horn', [nil, 'Chris', 'Derp', 'Horn', nil]
     end
-    it '.first' do
-      expect(n.first).to eq('Chris')
-    end
-    it '.middle' do
-      expect(n.middle).to eq('Derp')
-    end
-    it '.last' do
-      expect(n.last).to eq('Horn')
-    end
-    it '.suffix' do
-      expect(n.suffix).to be_nil
-    end
-  end
 
-  context('with a simple prefix') do
-    subject(:n) { Nameable::Latin.new.parse("Sir Chris Horn") }
-    it '.prefix' do
-      expect(n.prefix).to eq('Sir')
+    context 'with all uppercase first middle last name' do
+      it_behaves_like :generalized_parsing, 'CHRIS DERP HORN', [nil, 'Chris', 'Derp', 'Horn', nil]
     end
-    it '.first' do
-      expect(n.first).to eq('Chris')
-    end
-    it '.middle' do
-      expect(n.middle).to be_nil
-    end
-    it '.last' do
-      expect(n.last).to eq('Horn')
-    end
-    it '.suffix' do
-      expect(n.suffix).to be_nil
-    end
-  end
 
-  context('with a simple suffix') do
-    subject(:n) { Nameable::Latin.new.parse("Chris Horn PhD") }
-    it '.prefix' do
-      expect(n.prefix).to be_nil
-    end
-    it '.first' do
-      expect(n.first).to eq('Chris')
-    end
-    it '.middle' do
-      expect(n.middle).to be_nil
-    end
-    it '.last' do
-      expect(n.last).to eq('Horn')
-    end
-    it '.suffix' do
-      expect(n.suffix).to eq('Ph.D.')
+    context 'with all lowercase first middle last name' do
+      it_behaves_like :generalized_parsing, 'chris derp horn', [nil, 'Chris', 'Derp', 'Horn', nil]
     end
-  end
 
-  context('prefix patterns') do
-    %w{Mr Mr. Mister}.each do |prefix|
-      it prefix do
-       expect(Nameable::Latin.new.parse("#{prefix} Chris Horn").prefix).to eq('Mr.')
-      end
+    context 'with all mixed case first middle last name' do
+      it_behaves_like :generalized_parsing, 'DeChris LeDerp ZeHorn', [nil, 'DeChris', 'LeDerp', 'ZeHorn', nil]
     end
 
-    %w{Mrs Mrs. Misses}.each do |prefix|
-      it prefix do
-        expect(Nameable::Latin.new.parse("#{prefix} Chris Horn").prefix).to eq('Mrs.')
-      end
+    context 'with first last suffix' do
+      it_behaves_like :generalized_parsing, 'Chris Horn DRP', [nil, 'Chris', nil, 'Horn', 'DRP']
     end
 
-    %w{Ms Ms. Miss}.each do |prefix|
-      it prefix do
-        expect(Nameable::Latin.new.parse("#{prefix} Chris Horn").prefix).to eq('Ms.')
-      end
+    context 'with prefix first last suffix' do
+      it_behaves_like :generalized_parsing, 'Mr. Chris Horn DRP', ['Mr.', 'Chris', nil, 'Horn', 'DRP']
     end
 
-    %w{Dr Dr. Doctor}.each do |prefix|
-      it prefix do
-        expect(Nameable::Latin.new.parse("#{prefix} Chris Horn").prefix).to eq('Dr.')
-      end
+    %w[Dame Rabbi Imam Master Sir].each do |prefix|
+      it_behaves_like :generalized_parsing, "#{prefix} Chris Horn", [prefix, 'Chris', nil, 'Horn', nil]
     end
 
-    %w{Rev Rev. Reverend}.each do |prefix|
-      it prefix do
-        expect(Nameable::Latin.new.parse("#{prefix} Chris Horn").prefix).to eq('Rev.')
+    context 'with a normalizing prefix' do
+      %w[Mr Mr. Mister].each do |prefix|
+        it_behaves_like :generalized_parsing, "#{prefix} Chris Horn", ['Mr.', 'Chris', nil, 'Horn', nil]
       end
-    end
 
-    %w{Fr Fr. Friar}.each do |prefix|
-      it prefix do
-        expect(Nameable::Latin.new.parse("#{prefix} Chris Horn").prefix).to eq('Fr.')
+      %w[Mrs Mrs. Misses].each do |prefix|
+        it_behaves_like :generalized_parsing, "#{prefix} Chris Horn", ['Mrs.', 'Chris', nil, 'Horn', nil]
       end
-    end
 
-    %w{Master Sir}.each do |prefix|
-      it prefix do
-        expect(Nameable::Latin.new.parse("#{prefix} Chris Horn").prefix).to eq(prefix)
+      %w[Ms Ms. Miss].each do |prefix|
+        it_behaves_like :generalized_parsing, "#{prefix} Chris Horn", ['Ms.', 'Chris', nil, 'Horn', nil]
       end
-    end
-
-  end
 
-  context('suffix patterns (formatted)') do
-    %w{Sr Sr. Senior}.each do |suffix|
-      it suffix do
-        expect(Nameable::Latin.new.parse("Chris Horn #{suffix}").suffix).to eq('Sr.')
+      %w[Dr Dr. Doctor].each do |prefix|
+        it_behaves_like :generalized_parsing, "#{prefix} Chris Horn", ['Dr.', 'Chris', nil, 'Horn', nil]
       end
-    end
 
-    %w{Jr Jr. Junior}.each do |suffix|
-      it suffix do
-        expect(Nameable::Latin.new.parse("Chris Horn #{suffix}").suffix).to eq('Jr.')
+      %w[Rev Rev. Reverend].each do |prefix|
+        it_behaves_like :generalized_parsing, "#{prefix} Chris Horn", ['Rev.', 'Chris', nil, 'Horn', nil]
       end
-    end
 
-    %w{Esq Esq. Esquire}.each do |suffix|
-      it suffix do
-        expect(Nameable::Latin.new.parse("Chris Horn #{suffix}").suffix).to eq('Esq.')
+      %w[Fr Fr. Friar Father].each do |prefix|
+        it_behaves_like :generalized_parsing, "#{prefix} Chris Horn", ['Fr.', 'Chris', nil, 'Horn', nil]
       end
-    end
 
-    %w{PHD PhD Ph.D Ph.D. P.H.D.}.each do |suffix|
-      it suffix do
-        expect(Nameable::Latin.new.parse("Chris Horn #{suffix}").suffix).to eq('Ph.D.')
+      %w[Hon Hon. Honorable].each do |prefix|
+        it_behaves_like :generalized_parsing, "#{prefix} Chris Horn", ['Hon.', 'Chris', nil, 'Horn', nil]
       end
-    end
 
-  end
-
-  context('suffix patterns (generational)') do
-    %w{ii III iv V VI ix Xiii}.each do |suffix|
-      it suffix do
-        expect(Nameable::Latin.new.parse("Chris Horn #{suffix}").suffix).to eq(suffix.upcase)
+      %w[Capt Capt. Captain].each do |prefix|
+        it_behaves_like :generalized_parsing, "#{prefix} Chris Horn", ['Capt.', 'Chris', nil, 'Horn', nil]
       end
-    end
-  end
 
-  context('suffix patterns (common)') do
-    %w{APR RPh MD MA DMD DDS PharmD EngD DPhil JD DD DO BA BS BSc BE BFA MA MS MSc MFA MLA MBA PE CSA CPA CPL CME CEng OFM CSV}.each do |suffix|
-      it suffix do
-        expect(Nameable::Latin.new.parse("Chris Horn #{suffix}").suffix).to eq(suffix.upcase)
+      %w[Ofc Ofc. Officer].each do |prefix|
+        it_behaves_like :generalized_parsing, "#{prefix} Chris Horn", ['Ofc.', 'Chris', nil, 'Horn', nil]
       end
     end
-  end
-
-  context('suffix patterns (generic uppercase)') do
-    it 'generic DERP suffix' do
-      expect(Nameable::Latin.new.parse("Chris Horn DERP").suffix).to eq('DERP')
-    end
-
-    it 'no generic DERP suffix when all uppercase name' do
-      expect(Nameable::Latin.new.parse("CHRIS HORN DERP").suffix).to be_nil
-    end
-  end
 
-  context('multi word last names') do
-    %w{mc vere von van da de del della di da pietro vanden du st la ter ten}.each do |prefix|
-      it "#{prefix} Last" do
-        expect(Nameable::Latin.new.parse("Chris #{prefix} Last").last).to eq("#{prefix.downcase.capitalize} Last")
+    context 'with a normalizing suffix' do
+      %w[Sr Sr. Senior].each do |suffix|
+        it_behaves_like :generalized_parsing, "Chris Horn #{suffix}", [nil, 'Chris', nil, 'Horn', 'Sr.']
       end
-    end
-  end
 
-  context("o'last-name") do
-    it "O'Horn" do
-      expect(Nameable::Latin.new.parse("Chris O'Horn").last).to eq("O'Horn")
-    end
+      %w[Jr Jr. Junior].each do |suffix|
+        it_behaves_like :generalized_parsing, "Chris Horn #{suffix}", [nil, 'Chris', nil, 'Horn', 'Jr.']
+      end
 
-    it "O`Horn" do
-      expect(Nameable::Latin.new.parse("Chris O`Horn").last).to eq("O'Horn")
-    end
+      %w[Esq Esq. Esquire].each do |suffix|
+        it_behaves_like :generalized_parsing, "Chris Horn #{suffix}", [nil, 'Chris', nil, 'Horn', 'Esq.']
+      end
 
-    it "O' Horn" do
-      expect(Nameable::Latin.new.parse("Chris O' Horn").last).to eq("O'Horn")
-    end
-  end
+      %w[PHD PhD Ph.D Ph.D. P.H.D.].each do |suffix|
+        it_behaves_like :generalized_parsing, "Chris Horn #{suffix}", [nil, 'Chris', nil, 'Horn', 'Ph.D.']
+      end
 
-  context("hyphenated last names") do
-    it "Horn - Derp" do
-      expect(Nameable::Latin.new.parse("Chris Horn - Derp").last).to eq("Horn-Derp")
+      %w[
+        ii III iv V VI ix Xiii APR RPh MD MA DMD DDS PharmD EngD DPhil
+        JD DD DO BA BS BSc BE BFA MA MS MSc MFA MLA MBA PE CSA CPA CPL CME CEng OFM CSV
+      ].each do |suffix|
+        it_behaves_like :generalized_parsing, "Chris Horn #{suffix}", [nil, 'Chris', nil, 'Horn', suffix.upcase]
+      end
     end
 
-    it "Horn-Derp" do
-      expect(Nameable::Latin.new.parse("Chris Horn-Derp").last).to eq("Horn-Derp")
+    context 'with a multi word last name' do
+      %w[mc vere von van da de del della di da pietro vanden du st la ter ten].each do |prefix|
+        it_behaves_like :generalized_parsing, "Chris #{prefix} Horn", [nil, 'Chris', nil, "#{prefix.downcase.capitalize} Horn", nil]
+      end
     end
 
-    it "Horn--Derp" do
-      expect(Nameable::Latin.new.parse("Chris Horn--Derp").last).to eq("Horn-Derp")
+    context "with an o'last-name" do
+      ["O'Horn", 'O`Horn', "O' Horn"].each do |last|
+        it_behaves_like :generalized_parsing, "Chris #{last}", [nil, 'Chris', nil, "O'Horn", nil]
+      end
     end
 
-    it "Horn -- Derp" do
-      expect(Nameable::Latin.new.parse("Chris Horn--Derp").last).to eq("Horn-Derp")
+    context 'with a hyphenated last name' do
+      ['Horn - Derp', 'Horn-Derp',  'Horn--Derp', 'Horn -- Derp'].each do |last|
+        it_behaves_like :generalized_parsing, "Chris #{last}", [nil, 'Chris', nil, 'Horn-Derp', nil]
+      end
     end
   end
 
-  context("gender") do
-    it "Chris is more likely to be male" do
-      expect(Nameable::Latin.new.parse("Chris Horn").male?).to be true
+  context 'gender' do
+    it 'Chris is more likely to be male' do
+      expect(Nameable::Latin.new.parse('Chris Horn').male?).to be true
     end
 
-    it "Janine is more likely to be female" do
-      expect(Nameable::Latin.new.parse("Janine Horn").female?).to be true
+    it 'Janine is more likely to be female' do
+      expect(Nameable::Latin.new.parse('Janine Horn').female?).to be true
     end
 
-    it "Derp has :unknown gender" do
-      expect(Nameable::Latin.new.parse("Derp Horn").gender).to eq(:unknown)
+    it 'Derp has :unknown gender' do
+      expect(Nameable::Latin.new.parse('Derp Horn').gender).to eq(:unknown)
     end
   end
 
-  context("ethnicity") do
-    it "Horn has a hash of ethnicity results" do
-      expect(Nameable::Latin.new.parse("Chris Horn").ethnicity).to be_a Hash
+  context 'ethnicity' do
+    it 'Horn has a hash of ethnicity results' do
+      expect(Nameable::Latin.new.parse('Chris Horn').ethnicity).to be_a Hash
     end
 
     it "Horn's census :percent_white > 80% " do
-      expect(Nameable::Latin.new.parse("Chris Horn").ethnicity[:percent_white]).to be >= 80
+      expect(Nameable::Latin.new.parse('Chris Horn').ethnicity[:percent_white]).to be >= 80
     end
   end
-
 end