nomen 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 02f10575d1beff1b8eacf5b2c0caf3a79cf9f244
-  data.tar.gz: 1ee6f8c5ab00ba4eaf0dad83721b5db4c32598cf
+  metadata.gz: e25c9721ac53215d2b874c8ffb5a4e72807f884c
+  data.tar.gz: 46f496975c446826abe95f3774678cc550af3870
 SHA512:
-  metadata.gz: 7a6dd75a601cc5c1a647c80fa1652b0a8c6694ca618438c85b00f19102789eff8a30eef5181803366830d8ac7e03a72bae23e765be9a4b8dd69f5961303099b1
-  data.tar.gz: 798ac89b09e2d2995dd72a1510e6fab87adc50b68a2cc5ca2737383f27e1897ae6849e0c35a3fb3cc33c484aeb891285a5db502648d7431fbe3b43f5d519abb9
+  metadata.gz: fb0d3a1c1fef929642b188e8d77bc59fd879856d9b6c954de88aebb6c690493be5c53f98d292f82758743a6dd31c8d9cf528de28a6487b5ed4f993fa0669ea11
+  data.tar.gz: 04d9fd97b8b8c07fe7721ac49dad7e7b7a029aa679586bf7be57a346c93276098a240b1ce37242e21d84fe8bdf322229306cc87cd9d302bea3d49d8456e853ca

data/.travis.yml

@@ -6,4 +6,6 @@ rvm:
   - jruby-19mode
   - jruby-head
   - rbx-19mode
-  - ree
+matrix:
+  allow_failures:
+    - rvm: ruby-head

data/README.md

@@ -1,20 +1,31 @@
-# Nomen [![Build Status](https://secure.travis-ci.org/abevoelker/nomen.png)](http://travis-ci.org/abevoelker/nomen)
+Nomen
+========
+
+[![Gem Version](https://badge.fury.io/rb/nomen.png)][gem]
+[![Build Status](https://secure.travis-ci.org/abevoelker/nomen.png?branch=master)][travis]
+[![Dependency Status](https://gemnasium.com/abevoelker/nomen.png)][gemnasium]
+
+[gem]: https://rubygems.org/gems/nomen
+[travis]: http://travis-ci.org/abevoelker/nomen
+[gemnasium]: https://gemnasium.com/abevoelker/nomen
 
 Simple library for formatting (and maybe later, parsing) human names.
 
-## Description
+Description
+-----------
 
 The name is latin for "name"; no misandry intended. For now I'm only handling
 my current use case, which is very basic formatting of American-style names.
 
 I am aware of the [complexity of][patio11] human names.
 
-## Synopsis
+Synopsis
+--------
 
 ```ruby
 require 'nomen'
 
-n = Nomen::Name.new(first: 'Katya', middle: 'Verenice', last: 'Voelker', suffix: 'M.D.')
+n = Nomen.new(first: 'Katya', middle: 'Verenice', last: 'Voelker', suffix: 'M.D.')
 n.format # => "Katya Verenice Voelker M.D."
 n.format(:inverted) # => "Voelker, Katya Verenice M.D."
 n.middle = nil
@@ -22,7 +33,8 @@ n.format # => "Katya Voelker M.D."
 n.format(:inverted) # => "Voelker, Katya M.D."
 ```
 
-## Copyright
+Copyright
+---------
 
 Copyright (c) 2013 Abe Voelker. Released under the terms of the MIT license.
 See LICENSE for details.

data/lib/nomen.rb

@@ -1,3 +1,27 @@
+class Nomen
+  FRAGMENTS = [:first, :middle, :last, :suffix]
+  attr_accessor *FRAGMENTS
+
+  def initialize(opts={})
+    name_opts = opts.select{|k,v| FRAGMENTS.include?(k)}
+    name_opts.each{|k,v| send("#{k}=".to_sym, v)}
+    self
+  end
+
+  def format(type=:full)
+    Nomen::Formatters.lookup(type).format(self)
+  end
+
+  def to_h
+    FRAGMENTS.reduce({}){|a,f| a[f] = send(f); a}
+  end
+
+  def ==(other)
+    FRAGMENTS.each{|m| return false if self.send(m) != other.send(m)}
+    true
+  end
+
+end
+
 require 'nomen/version'
-require 'nomen/name'
 require 'nomen/formatters'

data/lib/nomen/formatters.rb

@@ -1,6 +1,6 @@
 Dir[File.expand_path('../formatters/*.rb', __FILE__)].each {|file| require file }
 
-module Nomen
+class Nomen
   module Formatters
     class UnknownFormatterError < StandardError; end
 

data/lib/nomen/formatters/full.rb

@@ -1,19 +1,19 @@
-module Nomen
+class Nomen
   module Formatters
     class Full
 
       def self.format(name)
         String.new.tap do |str|
-          if name.first
+          if name.first && !name.first.empty?
             str << name.first
           end
-          if name.middle
+          if name.middle && !name.middle.empty?
             str << (str.empty? ? name.middle : " #{name.middle}")
           end
-          if name.last
+          if name.last && !name.last.empty?
             str << (str.empty? ? name.last : " #{name.last}")
           end
-          if name.suffix
+          if name.suffix && !name.suffix.empty?
             str << (str.empty? ? name.suffix : " #{name.suffix}")
           end
         end

data/lib/nomen/formatters/inverted.rb

@@ -1,23 +1,23 @@
-module Nomen
+class Nomen
   module Formatters
     class Inverted
 
       def self.format(name)
         String.new.tap do |str|
-          if name.last
+          if name.last && !name.last.empty?
             if [name.first, name.middle, name.suffix].reject(&:nil?).reject(&:empty?).any?
               str << "#{name.last},"
             else
               str << name.last
             end
           end
-          if name.first
+          if name.first && !name.first.empty?
             str << (str.empty? ? name.first : " #{name.first}")
           end
-          if name.middle
+          if name.middle && !name.middle.empty?
             str << (str.empty? ? name.middle : " #{name.middle}")
           end
-          if name.suffix
+          if name.suffix && !name.suffix.empty?
             str << (str.empty? ? name.suffix : " #{name.suffix}")
           end
         end

data/lib/nomen/version.rb

@@ -1,3 +1,3 @@
-module Nomen
-  VERSION = "0.0.1"
+class Nomen
+  VERSION = "0.0.2"
 end

data/spec/formatters/full_spec.rb

@@ -3,156 +3,196 @@ require File.dirname(__FILE__) + '/formatters_helper'
 describe Nomen::Formatters::Full do
   context 'formatting a name' do
 
+    # transforms #<Nomen @first="Bob"> into #<Nomen @first="Bob", @middle=nil, @last=nil, suffix=nil>
+    def nils(nomen)
+      Nomen.new(nomen.to_h)
+    end
+
+    # transforms #<Nomen @first="Bob"> into #<Nomen @first="Bob", @middle="", @last="", suffix="">
+    def blanks(nomen)
+      Nomen.new(nomen.to_h.inject({}){|a,(k,v)| a[k] = (v.nil? ? '' : v); a })
+    end
+
     # name segment combinations were generated with
-    # s = [:first, :middle, :last, :suffix]; s.size.downto(1).map{|i| s.combination(i).to_a}.flatten(1)
+    # f = Nomen::FRAGMENTS; f.size.downto(1).map{|i| f.combination(i).to_a}.flatten(1)
 
     context 'with [:first, :middle, :last, :suffix]' do
       before do
-        @name = Nomen::Name.new(first: 'Katya', middle: 'Verenice', last: 'Voelker', suffix: 'M.D.')
+        @name = Nomen.new(first: 'Katya', middle: 'Verenice', last: 'Voelker', suffix: 'M.D.')
       end
 
       it 'should format correctly' do
-        expect(Nomen::Formatters::Full.format(@name)).to eq('Katya Verenice Voelker M.D.')
+        expect(Nomen::Formatters::Full.format(@name)).to         eq('Katya Verenice Voelker M.D.')
+        expect(Nomen::Formatters::Full.format(nils(@name))).to   eq(Nomen::Formatters::Full.format(@name))
+        expect(Nomen::Formatters::Full.format(blanks(@name))).to eq(Nomen::Formatters::Full.format(@name))
       end
     end
 
     context 'with [:first, :middle, :last]' do
       before do
-        @name = Nomen::Name.new(first: 'Katya', middle: 'Verenice', last: 'Voelker')
+        @name = Nomen.new(first: 'Katya', middle: 'Verenice', last: 'Voelker')
       end
 
       it 'should format correctly' do
-        expect(Nomen::Formatters::Full.format(@name)).to eq('Katya Verenice Voelker')
+        expect(Nomen::Formatters::Full.format(@name)).to         eq('Katya Verenice Voelker')
+        expect(Nomen::Formatters::Full.format(nils(@name))).to   eq(Nomen::Formatters::Full.format(@name))
+        expect(Nomen::Formatters::Full.format(blanks(@name))).to eq(Nomen::Formatters::Full.format(@name))
       end
     end
 
     context 'with [:first, :middle, :suffix]' do
       before do
-        @name = Nomen::Name.new(first: 'Katya', middle: 'Verenice', suffix: 'M.D.')
+        @name = Nomen.new(first: 'Katya', middle: 'Verenice', suffix: 'M.D.')
       end
 
       it 'should format correctly' do
-        expect(Nomen::Formatters::Full.format(@name)).to eq('Katya Verenice M.D.')
+        expect(Nomen::Formatters::Full.format(@name)).to         eq('Katya Verenice M.D.')
+        expect(Nomen::Formatters::Full.format(nils(@name))).to   eq(Nomen::Formatters::Full.format(@name))
+        expect(Nomen::Formatters::Full.format(blanks(@name))).to eq(Nomen::Formatters::Full.format(@name))
       end
     end
 
     context 'with [:first, :last, :suffix]' do
       before do
-        @name = Nomen::Name.new(first: 'Katya', last: 'Voelker', suffix: 'M.D.')
+        @name = Nomen.new(first: 'Katya', last: 'Voelker', suffix: 'M.D.')
       end
 
       it 'should format correctly' do
-        expect(Nomen::Formatters::Full.format(@name)).to eq('Katya Voelker M.D.')
+        expect(Nomen::Formatters::Full.format(@name)).to         eq('Katya Voelker M.D.')
+        expect(Nomen::Formatters::Full.format(nils(@name))).to   eq(Nomen::Formatters::Full.format(@name))
+        expect(Nomen::Formatters::Full.format(blanks(@name))).to eq(Nomen::Formatters::Full.format(@name))
       end
     end
 
     context 'with [:middle, :last, :suffix]' do
       before do
-        @name = Nomen::Name.new(middle: 'Verenice', last: 'Voelker', suffix: 'M.D.')
+        @name = Nomen.new(middle: 'Verenice', last: 'Voelker', suffix: 'M.D.')
       end
 
       it 'should format correctly' do
-        expect(Nomen::Formatters::Full.format(@name)).to eq('Verenice Voelker M.D.')
+        expect(Nomen::Formatters::Full.format(@name)).to         eq('Verenice Voelker M.D.')
+        expect(Nomen::Formatters::Full.format(nils(@name))).to   eq(Nomen::Formatters::Full.format(@name))
+        expect(Nomen::Formatters::Full.format(blanks(@name))).to eq(Nomen::Formatters::Full.format(@name))
       end
     end
 
     context 'with [:first, :middle]' do
       before do
-        @name = Nomen::Name.new(first: 'Katya', middle: 'Verenice')
+        @name = Nomen.new(first: 'Katya', middle: 'Verenice')
       end
 
       it 'should format correctly' do
-        expect(Nomen::Formatters::Full.format(@name)).to eq('Katya Verenice')
+        expect(Nomen::Formatters::Full.format(@name)).to         eq('Katya Verenice')
+        expect(Nomen::Formatters::Full.format(nils(@name))).to   eq(Nomen::Formatters::Full.format(@name))
+        expect(Nomen::Formatters::Full.format(blanks(@name))).to eq(Nomen::Formatters::Full.format(@name))
       end
     end
 
     context 'with [:first, :last]' do
       before do
-        @name = Nomen::Name.new(first: 'Katya', last: 'Voelker')
+        @name = Nomen.new(first: 'Katya', last: 'Voelker')
       end
 
       it 'should format correctly' do
-        expect(Nomen::Formatters::Full.format(@name)).to eq('Katya Voelker')
+        expect(Nomen::Formatters::Full.format(@name)).to         eq('Katya Voelker')
+        expect(Nomen::Formatters::Full.format(nils(@name))).to   eq(Nomen::Formatters::Full.format(@name))
+        expect(Nomen::Formatters::Full.format(blanks(@name))).to eq(Nomen::Formatters::Full.format(@name))
       end
     end
 
     context 'with [:first, :suffix]' do
       before do
-        @name = Nomen::Name.new(first: 'Katya', suffix: 'M.D.')
+        @name = Nomen.new(first: 'Katya', suffix: 'M.D.')
       end
 
       it 'should format correctly' do
-        expect(Nomen::Formatters::Full.format(@name)).to eq('Katya M.D.')
+        expect(Nomen::Formatters::Full.format(@name)).to         eq('Katya M.D.')
+        expect(Nomen::Formatters::Full.format(nils(@name))).to   eq(Nomen::Formatters::Full.format(@name))
+        expect(Nomen::Formatters::Full.format(blanks(@name))).to eq(Nomen::Formatters::Full.format(@name))
       end
     end
 
     context 'with [:middle, :last]' do
       before do
-        @name = Nomen::Name.new(middle: 'Verenice', last: 'Voelker')
+        @name = Nomen.new(middle: 'Verenice', last: 'Voelker')
       end
 
       it 'should format correctly' do
-        expect(Nomen::Formatters::Full.format(@name)).to eq('Verenice Voelker')
+        expect(Nomen::Formatters::Full.format(@name)).to         eq('Verenice Voelker')
+        expect(Nomen::Formatters::Full.format(nils(@name))).to   eq(Nomen::Formatters::Full.format(@name))
+        expect(Nomen::Formatters::Full.format(blanks(@name))).to eq(Nomen::Formatters::Full.format(@name))
       end
     end
 
     context 'with [:middle, :suffix]' do
       before do
-        @name = Nomen::Name.new(middle: 'Verenice', suffix: 'M.D.')
+        @name = Nomen.new(middle: 'Verenice', suffix: 'M.D.')
       end
 
       it 'should format correctly' do
-        expect(Nomen::Formatters::Full.format(@name)).to eq('Verenice M.D.')
+        expect(Nomen::Formatters::Full.format(@name)).to         eq('Verenice M.D.')
+        expect(Nomen::Formatters::Full.format(nils(@name))).to   eq(Nomen::Formatters::Full.format(@name))
+        expect(Nomen::Formatters::Full.format(blanks(@name))).to eq(Nomen::Formatters::Full.format(@name))
       end
     end
 
     context 'with [:last, :suffix]' do
       before do
-        @name = Nomen::Name.new(last: 'Voelker', suffix: 'M.D.')
+        @name = Nomen.new(last: 'Voelker', suffix: 'M.D.')
       end
 
       it 'should format correctly' do
-        expect(Nomen::Formatters::Full.format(@name)).to eq('Voelker M.D.')
+        expect(Nomen::Formatters::Full.format(@name)).to         eq('Voelker M.D.')
+        expect(Nomen::Formatters::Full.format(nils(@name))).to   eq(Nomen::Formatters::Full.format(@name))
+        expect(Nomen::Formatters::Full.format(blanks(@name))).to eq(Nomen::Formatters::Full.format(@name))
       end
     end
 
     context 'with [:first]' do
       before do
-        @name = Nomen::Name.new(first: 'Katya')
+        @name = Nomen.new(first: 'Katya')
       end
 
       it 'should format correctly' do
-        expect(Nomen::Formatters::Full.format(@name)).to eq('Katya')
+        expect(Nomen::Formatters::Full.format(@name)).to         eq('Katya')
+        expect(Nomen::Formatters::Full.format(nils(@name))).to   eq(Nomen::Formatters::Full.format(@name))
+        expect(Nomen::Formatters::Full.format(blanks(@name))).to eq(Nomen::Formatters::Full.format(@name))
       end
     end
 
     context 'with [:middle]' do
       before do
-        @name = Nomen::Name.new(middle: 'Verenice')
+        @name = Nomen.new(middle: 'Verenice')
       end
 
       it 'should format correctly' do
-        expect(Nomen::Formatters::Full.format(@name)).to eq('Verenice')
+        expect(Nomen::Formatters::Full.format(@name)).to         eq('Verenice')
+        expect(Nomen::Formatters::Full.format(nils(@name))).to   eq(Nomen::Formatters::Full.format(@name))
+        expect(Nomen::Formatters::Full.format(blanks(@name))).to eq(Nomen::Formatters::Full.format(@name))
       end
     end
 
     context 'with [:last]' do
       before do
-        @name = Nomen::Name.new(last: 'Voelker')
+        @name = Nomen.new(last: 'Voelker')
       end
 
       it 'should format correctly' do
-        expect(Nomen::Formatters::Full.format(@name)).to eq('Voelker')
+        expect(Nomen::Formatters::Full.format(@name)).to         eq('Voelker')
+        expect(Nomen::Formatters::Full.format(nils(@name))).to   eq(Nomen::Formatters::Full.format(@name))
+        expect(Nomen::Formatters::Full.format(blanks(@name))).to eq(Nomen::Formatters::Full.format(@name))
       end
     end
 
     context 'with [:suffix]' do
       before do
-        @name = Nomen::Name.new(suffix: 'M.D.')
+        @name = Nomen.new(suffix: 'M.D.')
       end
 
       it 'should format correctly' do
-        expect(Nomen::Formatters::Full.format(@name)).to eq('M.D.')
+        expect(Nomen::Formatters::Full.format(@name)).to         eq('M.D.')
+        expect(Nomen::Formatters::Full.format(nils(@name))).to   eq(Nomen::Formatters::Full.format(@name))
+        expect(Nomen::Formatters::Full.format(blanks(@name))).to eq(Nomen::Formatters::Full.format(@name))
       end
     end
   end

data/spec/formatters/inverted_spec.rb

@@ -3,156 +3,196 @@ require File.dirname(__FILE__) + '/formatters_helper'
 describe Nomen::Formatters::Inverted do
   context 'formatting a name' do
 
+    # transforms #<Nomen @first="Bob"> into #<Nomen @first="Bob", @middle=nil, @last=nil, suffix=nil>
+    def nils(nomen)
+      Nomen.new(nomen.to_h)
+    end
+
+    # transforms #<Nomen @first="Bob"> into #<Nomen @first="Bob", @middle="", @last="", suffix="">
+    def blanks(nomen)
+      Nomen.new(nomen.to_h.inject({}){|a,(k,v)| a[k] = (v.nil? ? '' : v); a })
+    end
+
     # name segment combinations were generated with
-    # s = [:first, :middle, :last, :suffix]; s.size.downto(1).map{|i| s.combination(i).to_a}.flatten(1)
+    # f = Nomen::FRAGMENTS; f.size.downto(1).map{|i| f.combination(i).to_a}.flatten(1)
 
     context 'with [:first, :middle, :last, :suffix]' do
       before do
-        @name = Nomen::Name.new(first: 'Katya', middle: 'Verenice', last: 'Voelker', suffix: 'M.D.')
+        @name = Nomen.new(first: 'Katya', middle: 'Verenice', last: 'Voelker', suffix: 'M.D.')
       end
 
       it 'should format correctly' do
-        expect(Nomen::Formatters::Inverted.format(@name)).to eq('Voelker, Katya Verenice M.D.')
+        expect(Nomen::Formatters::Inverted.format(@name)).to         eq('Voelker, Katya Verenice M.D.')
+        expect(Nomen::Formatters::Inverted.format(nils(@name))).to   eq(Nomen::Formatters::Inverted.format(@name))
+        expect(Nomen::Formatters::Inverted.format(blanks(@name))).to eq(Nomen::Formatters::Inverted.format(@name))
       end
     end
 
     context 'with [:first, :middle, :last]' do
       before do
-        @name = Nomen::Name.new(first: 'Katya', middle: 'Verenice', last: 'Voelker')
+        @name = Nomen.new(first: 'Katya', middle: 'Verenice', last: 'Voelker')
       end
 
       it 'should format correctly' do
-        expect(Nomen::Formatters::Inverted.format(@name)).to eq('Voelker, Katya Verenice')
+        expect(Nomen::Formatters::Inverted.format(@name)).to         eq('Voelker, Katya Verenice')
+        expect(Nomen::Formatters::Inverted.format(nils(@name))).to   eq(Nomen::Formatters::Inverted.format(@name))
+        expect(Nomen::Formatters::Inverted.format(blanks(@name))).to eq(Nomen::Formatters::Inverted.format(@name))
       end
     end
 
     context 'with [:first, :middle, :suffix]' do
       before do
-        @name = Nomen::Name.new(first: 'Katya', middle: 'Verenice', suffix: 'M.D.')
+        @name = Nomen.new(first: 'Katya', middle: 'Verenice', suffix: 'M.D.')
       end
 
       it 'should format correctly' do
-        expect(Nomen::Formatters::Inverted.format(@name)).to eq('Katya Verenice M.D.')
+        expect(Nomen::Formatters::Inverted.format(@name)).to         eq('Katya Verenice M.D.')
+        expect(Nomen::Formatters::Inverted.format(nils(@name))).to   eq(Nomen::Formatters::Inverted.format(@name))
+        expect(Nomen::Formatters::Inverted.format(blanks(@name))).to eq(Nomen::Formatters::Inverted.format(@name))
       end
     end
 
     context 'with [:first, :last, :suffix]' do
       before do
-        @name = Nomen::Name.new(first: 'Katya', last: 'Voelker', suffix: 'M.D.')
+        @name = Nomen.new(first: 'Katya', last: 'Voelker', suffix: 'M.D.')
       end
 
       it 'should format correctly' do
-        expect(Nomen::Formatters::Inverted.format(@name)).to eq('Voelker, Katya M.D.')
+        expect(Nomen::Formatters::Inverted.format(@name)).to         eq('Voelker, Katya M.D.')
+        expect(Nomen::Formatters::Inverted.format(nils(@name))).to   eq(Nomen::Formatters::Inverted.format(@name))
+        expect(Nomen::Formatters::Inverted.format(blanks(@name))).to eq(Nomen::Formatters::Inverted.format(@name))
       end
     end
 
     context 'with [:middle, :last, :suffix]' do
       before do
-        @name = Nomen::Name.new(middle: 'Verenice', last: 'Voelker', suffix: 'M.D.')
+        @name = Nomen.new(middle: 'Verenice', last: 'Voelker', suffix: 'M.D.')
       end
 
       it 'should format correctly' do
-        expect(Nomen::Formatters::Inverted.format(@name)).to eq('Voelker, Verenice M.D.')
+        expect(Nomen::Formatters::Inverted.format(@name)).to         eq('Voelker, Verenice M.D.')
+        expect(Nomen::Formatters::Inverted.format(nils(@name))).to   eq(Nomen::Formatters::Inverted.format(@name))
+        expect(Nomen::Formatters::Inverted.format(blanks(@name))).to eq(Nomen::Formatters::Inverted.format(@name))
       end
     end
 
     context 'with [:first, :middle]' do
       before do
-        @name = Nomen::Name.new(first: 'Katya', middle: 'Verenice')
+        @name = Nomen.new(first: 'Katya', middle: 'Verenice')
       end
 
       it 'should format correctly' do
-        expect(Nomen::Formatters::Inverted.format(@name)).to eq('Katya Verenice')
+        expect(Nomen::Formatters::Inverted.format(@name)).to         eq('Katya Verenice')
+        expect(Nomen::Formatters::Inverted.format(nils(@name))).to   eq(Nomen::Formatters::Inverted.format(@name))
+        expect(Nomen::Formatters::Inverted.format(blanks(@name))).to eq(Nomen::Formatters::Inverted.format(@name))
       end
     end
 
     context 'with [:first, :last]' do
       before do
-        @name = Nomen::Name.new(first: 'Katya', last: 'Voelker')
+        @name = Nomen.new(first: 'Katya', last: 'Voelker')
       end
 
       it 'should format correctly' do
-        expect(Nomen::Formatters::Inverted.format(@name)).to eq('Voelker, Katya')
+        expect(Nomen::Formatters::Inverted.format(@name)).to         eq('Voelker, Katya')
+        expect(Nomen::Formatters::Inverted.format(nils(@name))).to   eq(Nomen::Formatters::Inverted.format(@name))
+        expect(Nomen::Formatters::Inverted.format(blanks(@name))).to eq(Nomen::Formatters::Inverted.format(@name))
       end
     end
 
     context 'with [:first, :suffix]' do
       before do
-        @name = Nomen::Name.new(first: 'Katya', suffix: 'M.D.')
+        @name = Nomen.new(first: 'Katya', suffix: 'M.D.')
       end
 
       it 'should format correctly' do
-        expect(Nomen::Formatters::Inverted.format(@name)).to eq('Katya M.D.')
+        expect(Nomen::Formatters::Inverted.format(@name)).to         eq('Katya M.D.')
+        expect(Nomen::Formatters::Inverted.format(nils(@name))).to   eq(Nomen::Formatters::Inverted.format(@name))
+        expect(Nomen::Formatters::Inverted.format(blanks(@name))).to eq(Nomen::Formatters::Inverted.format(@name))
       end
     end
 
     context 'with [:middle, :last]' do
       before do
-        @name = Nomen::Name.new(middle: 'Verenice', last: 'Voelker')
+        @name = Nomen.new(middle: 'Verenice', last: 'Voelker')
       end
 
       it 'should format correctly' do
-        expect(Nomen::Formatters::Inverted.format(@name)).to eq('Voelker, Verenice')
+        expect(Nomen::Formatters::Inverted.format(@name)).to         eq('Voelker, Verenice')
+        expect(Nomen::Formatters::Inverted.format(nils(@name))).to   eq(Nomen::Formatters::Inverted.format(@name))
+        expect(Nomen::Formatters::Inverted.format(blanks(@name))).to eq(Nomen::Formatters::Inverted.format(@name))
       end
     end
 
     context 'with [:middle, :suffix]' do
       before do
-        @name = Nomen::Name.new(middle: 'Verenice', suffix: 'M.D.')
+        @name = Nomen.new(middle: 'Verenice', suffix: 'M.D.')
       end
 
       it 'should format correctly' do
-        expect(Nomen::Formatters::Inverted.format(@name)).to eq('Verenice M.D.')
+        expect(Nomen::Formatters::Inverted.format(@name)).to         eq('Verenice M.D.')
+        expect(Nomen::Formatters::Inverted.format(nils(@name))).to   eq(Nomen::Formatters::Inverted.format(@name))
+        expect(Nomen::Formatters::Inverted.format(blanks(@name))).to eq(Nomen::Formatters::Inverted.format(@name))
       end
     end
 
     context 'with [:last, :suffix]' do
       before do
-        @name = Nomen::Name.new(last: 'Voelker', suffix: 'M.D.')
+        @name = Nomen.new(last: 'Voelker', suffix: 'M.D.')
       end
 
       it 'should format correctly' do
-        expect(Nomen::Formatters::Inverted.format(@name)).to eq('Voelker, M.D.')
+        expect(Nomen::Formatters::Inverted.format(@name)).to         eq('Voelker, M.D.')
+        expect(Nomen::Formatters::Inverted.format(nils(@name))).to   eq(Nomen::Formatters::Inverted.format(@name))
+        expect(Nomen::Formatters::Inverted.format(blanks(@name))).to eq(Nomen::Formatters::Inverted.format(@name))
       end
     end
 
     context 'with [:first]' do
       before do
-        @name = Nomen::Name.new(first: 'Katya')
+        @name = Nomen.new(first: 'Katya')
       end
 
       it 'should format correctly' do
-        expect(Nomen::Formatters::Inverted.format(@name)).to eq('Katya')
+        expect(Nomen::Formatters::Inverted.format(@name)).to         eq('Katya')
+        expect(Nomen::Formatters::Inverted.format(nils(@name))).to   eq(Nomen::Formatters::Inverted.format(@name))
+        expect(Nomen::Formatters::Inverted.format(blanks(@name))).to eq(Nomen::Formatters::Inverted.format(@name))
       end
     end
 
     context 'with [:middle]' do
       before do
-        @name = Nomen::Name.new(middle: 'Verenice')
+        @name = Nomen.new(middle: 'Verenice')
       end
 
       it 'should format correctly' do
-        expect(Nomen::Formatters::Inverted.format(@name)).to eq('Verenice')
+        expect(Nomen::Formatters::Inverted.format(@name)).to         eq('Verenice')
+        expect(Nomen::Formatters::Inverted.format(nils(@name))).to   eq(Nomen::Formatters::Inverted.format(@name))
+        expect(Nomen::Formatters::Inverted.format(blanks(@name))).to eq(Nomen::Formatters::Inverted.format(@name))
       end
     end
 
     context 'with [:last]' do
       before do
-        @name = Nomen::Name.new(last: 'Voelker')
+        @name = Nomen.new(last: 'Voelker')
       end
 
       it 'should format correctly' do
-        expect(Nomen::Formatters::Inverted.format(@name)).to eq('Voelker')
+        expect(Nomen::Formatters::Inverted.format(@name)).to         eq('Voelker')
+        expect(Nomen::Formatters::Inverted.format(nils(@name))).to   eq(Nomen::Formatters::Inverted.format(@name))
+        expect(Nomen::Formatters::Inverted.format(blanks(@name))).to eq(Nomen::Formatters::Inverted.format(@name))
       end
     end
 
     context 'with [:suffix]' do
       before do
-        @name = Nomen::Name.new(suffix: 'M.D.')
+        @name = Nomen.new(suffix: 'M.D.')
       end
 
       it 'should format correctly' do
-        expect(Nomen::Formatters::Inverted.format(@name)).to eq('M.D.')
+        expect(Nomen::Formatters::Inverted.format(@name)).to         eq('M.D.')
+        expect(Nomen::Formatters::Inverted.format(nils(@name))).to   eq(Nomen::Formatters::Inverted.format(@name))
+        expect(Nomen::Formatters::Inverted.format(blanks(@name))).to eq(Nomen::Formatters::Inverted.format(@name))
       end
     end
   end

data/spec/nomen_spec.rb

@@ -0,0 +1,54 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Nomen do
+  context 'initialization' do
+    it 'should accept no parameters' do
+      expect{Nomen.new}.not_to raise_error
+    end
+
+    it 'should ignore non-name segment hash parameters' do
+      name = Nomen.new(first: 'Katya', foo: 'bar')
+      expect(name).to eq(Nomen.new(first: 'Katya'))
+    end
+
+    it 'should only accept one parameter' do
+      expect{Nomen.new({last: 'Voelker'}, 'foo')}.to raise_error
+    end
+  end
+
+  context 'equality' do
+    it 'should match equality based on name segment matching' do
+      a = Nomen.new(first: 'Katya',  middle: 'Verenice', last: 'Voelker')
+      b = Nomen.new(last: 'Voelker', middle: 'Verenice', first: 'Katya')
+      expect(a).to eq(b)
+      expect(b).to eq(a)
+      a.suffix = "M.D."
+      expect(a).not_to eq(b)
+      expect(b).not_to eq(a)
+    end
+  end
+
+  context 'formatting' do
+    it 'should defer formatting to the proper format object' do
+      a = Nomen.new(first: 'Katya', middle: 'Verenice', last: 'Voelker', suffix: 'M.D.')
+      expect(a.format(:inverted)).to eq(Nomen::Formatters::Inverted.format(a))
+    end
+
+    it 'should default to the :full formatter' do
+      a = Nomen.new(first: 'Katya', middle: 'Verenice', last: 'Voelker', suffix: 'M.D.')
+      expect(a.format).to eq(a.format(:full))
+    end
+  end
+
+  context 'to_h' do
+    it 'should convert to hash using FRAGMENTS' do
+      full = Nomen.new(first: 'Katya', middle: 'Verenice', last: 'Voelker', suffix: 'M.D.')
+      expect(full.to_h).to eq({first: 'Katya', middle: 'Verenice', last: 'Voelker', suffix: 'M.D.'})
+    end
+
+    it 'should save empty fragments as null values' do
+      first = Nomen.new(first: 'Katya')
+      expect(first.to_h).to eq({first: 'Katya', middle: nil, last: nil, suffix: nil})
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nomen
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Abe Voelker
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-07 00:00:00.000000000 Z
+date: 2013-08-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -69,14 +69,13 @@ files:
 - lib/nomen/formatters.rb
 - lib/nomen/formatters/full.rb
 - lib/nomen/formatters/inverted.rb
-- lib/nomen/name.rb
 - lib/nomen/version.rb
 - nomen.gemspec
 - spec/formatters/formatters_helper.rb
 - spec/formatters/full_spec.rb
 - spec/formatters/inverted_spec.rb
 - spec/formatters_spec.rb
-- spec/name_spec.rb
+- spec/nomen_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/abevoelker/nomen
 licenses:
@@ -88,12 +87,12 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
@@ -107,5 +106,5 @@ test_files:
 - spec/formatters/full_spec.rb
 - spec/formatters/inverted_spec.rb
 - spec/formatters_spec.rb
-- spec/name_spec.rb
+- spec/nomen_spec.rb
 - spec/spec_helper.rb

data/lib/nomen/name.rb

@@ -1,23 +0,0 @@
-module Nomen
-  class Name
-    attr_accessor :first, :middle, :last, :suffix
-
-    def initialize(opts={})
-      name_opts = opts.select{|k,v| [:first, :middle, :last, :suffix].include?(k)}
-      name_opts.each{|k,v| send("#{k}=".to_sym, v)}
-      self
-    end
-
-    def format(type=:full)
-      Nomen::Formatters.lookup(type).format(self)
-    end
-
-    def ==(other)
-      [:first, :middle, :last, :suffix].each do |m|
-        return false if self.send(m) != other.send(m)
-      end
-      true
-    end
-
-  end
-end

data/spec/name_spec.rb

@@ -1,42 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-describe Nomen::Name do
-  context 'initialization' do
-    it 'should accept no parameters' do
-      expect{Nomen::Name.new}.not_to raise_error
-    end
-
-    it 'should ignore non-name segment hash parameters' do
-      name = Nomen::Name.new(first: 'Katya', foo: 'bar')
-      expect(name).to eq(Nomen::Name.new(first: 'Katya'))
-    end
-
-    it 'should only accept one parameter' do
-      expect{Nomen::Name.new({last: 'Voelker'}, 'foo')}.to raise_error
-    end
-  end
-
-  context 'equality' do
-    it 'should match equality based on name segment matching' do
-      a = Nomen::Name.new(first: 'Katya',  middle: 'Verenice', last: 'Voelker')
-      b = Nomen::Name.new(last: 'Voelker', middle: 'Verenice', first: 'Katya')
-      expect(a).to eq(b)
-      expect(b).to eq(a)
-      a.suffix = "M.D."
-      expect(a).not_to eq(b)
-      expect(b).not_to eq(a)
-    end
-  end
-
-  context 'formatting' do
-    it 'should defer formatting to the proper format object' do
-      a = Nomen::Name.new(first: 'Katya', middle: 'Verenice', last: 'Voelker', suffix: 'M.D.')
-      expect(a.format(:inverted)).to eq(Nomen::Formatters::Inverted.format(a))
-    end
-
-    it 'should default to the :full formatter' do
-      a = Nomen::Name.new(first: 'Katya', middle: 'Verenice', last: 'Voelker', suffix: 'M.D.')
-      expect(a.format).to eq(a.format(:full))
-    end
-  end
-end