motion-addressbook 1.0.0 → 1.2.0

data/.travis.yml

@@ -0,0 +1,6 @@
+language: objective-c
+before_install:
+  - source /Users/travis/.bash_profile
+  - rvm use 1.9.3
+install: bundle install
+script: bundle exec rake spec

data/README.md

@@ -1,4 +1,4 @@
-# Addressbook for RubyMotion
+# Addressbook for RubyMotion[![Build Status](https://secure.travis-ci.org/alexrothenberg/motion-addressbook.png)](http://travis-ci.org/alexrothenberg/motion-addressbook) [![Code Climate](https://codeclimate.com/github/alexrothenberg/motion-addressbook.png)](https://codeclimate.com/github/alexrothenberg/motion-addressbook) [![Gem Version](https://badge.fury.io/rb/motion-addressbook.png)](http://badge.fury.io/rb/motion-addressbook)
 
 A RubyMotion wrapper around the iOS Address Book framework for RubyMotion apps.
 

data/lib/motion-addressbook/version.rb

@@ -1,5 +1,5 @@
 module Motion
   module Addressbook
-    VERSION = "1.0.0"
+    VERSION = "1.2.0"
   end
 end

data/lib/motion-addressbook.rb

@@ -4,7 +4,10 @@ BubbleWrap.require 'motion/address_book.rb' do
   file('motion/address_book.rb').uses_framework('AddressBook')
 end
 BW.require 'motion/address_book/multi_value.rb'
+BW.require 'motion/address_book/addr_book.rb'
 BW.require 'motion/address_book/person.rb'
+BW.require 'motion/address_book/group.rb'
+BW.require 'motion/address_book/multi_valued.rb'
 BW.require 'motion/address_book/picker.rb' do
   file('motion/address_book/picker.rb').uses_framework('AddressBookUI')
 end

data/motion/address_book/addr_book.rb

@@ -0,0 +1,44 @@
+module AddressBook
+  class AddrBook
+    attr_reader :ab
+
+    def initialize
+      @ab = AddressBook.address_book
+    end
+    def people
+      ABAddressBookCopyArrayOfAllPeople(ab).map do |ab_person|
+        AddressBook::Person.new({}, ab_person, :address_book => ab)
+      end
+    end
+    def count
+      ABAddressBookGetPersonCount(@ab)
+    end
+    def new_person(attributes)
+      Person.new(attributes, nil, :address_book => @ab)
+    end
+    def create_person(attributes)
+      p = Person.new(attributes, nil, :address_book => @ab)
+      p.save
+      p
+    end
+    def person(id)
+      (p = ABAddressBookGetPersonWithRecordID(ab, id)) && Person.new(nil, p, :address_book => ab)
+    end
+
+    def groups
+      ABAddressBookCopyArrayOfAllGroups(@ab).map do |ab_group|
+        AddressBook::Group.new(:ab_group => ab_group, :address_book => @ab)
+      end
+    end
+    def new_group(attributes)
+      AddressBook::Group.new(:attributes => attributes, :address_book => @ab)
+    end
+    def group(id)
+      (g = ABAddressBookGetGroupWithRecordID(ab, id)) && Group.new(:ab_group => g, :address_book => @ab)
+    end
+
+    def notify_changes(callback, context)
+      ABAddressBookRegisterExternalChangeCallback(ab, callback, context)
+    end
+  end
+end

data/motion/address_book/group.rb

@@ -0,0 +1,99 @@
+# Wrapper for iOS ABGroup
+#
+# * groups are saved to the database immediately upon new()
+# * members are added with <<
+#
+module AddressBook
+  class Group
+    attr_reader :attributes, :error
+
+    def initialize(opts)
+      @address_book = opts[:address_book]
+      if opts[:ab_group]
+        # import existing
+        @ab_group = opts[:ab_group]
+        @attributes = nil
+      else
+        # create new
+        @ab_group = nil
+        @attributes = opts[:attributes]
+      end
+    end
+
+    def address_book
+      @address_book ||= AddressBook.address_book
+    end
+
+    def save
+      ABAddressBookAddRecord(address_book, ab_group, error)
+      ABAddressBookSave(address_book, error)
+      @attributes = nil
+      @new_record = false
+      self
+    end
+
+    def new?
+      uid == KABRecordInvalidID
+    end
+
+    def delete!
+      unless new?
+        ABAddressBookRemoveRecord(address_book, ab_group, error)
+        ABAddressBookSave(address_book, error)
+        @ab_group = nil
+        self
+      end
+    end
+
+    def ab_group
+      @ab_group || convert_dict_to_ab
+    end
+    alias :ab_record :ab_group
+
+    def uid
+      ABRecordGetRecordID(ab_group)
+    end
+
+    def name
+      ABRecordCopyValue(ab_group, KABGroupNameProperty)
+    end
+
+    def size
+      members.count
+    end
+
+    def members
+      (ABGroupCopyArrayOfAllMembers(ab_group) || []).map do |ab_record|
+        case rectype = ABRecordGetRecordType(ab_record)
+        when KABPersonType
+          AddressBook::Person.new({}, ab_record, :address_book => address_book)
+        when KABGroupType
+          AddressBook::Group.new(:ab_group => ab_record, :address_book => address_book)
+        else
+          warn "Unrecognized record type #{rectype} in AB group #{name}"
+          nil
+        end
+      end
+    end
+
+    def <<(person_or_group)
+      raise "Must save member before adding to group" if person_or_group.new?
+      ABGroupAddMember(ab_group, person_or_group.ab_record, error)
+    end
+
+    private
+
+    def convert_dict_to_ab
+      @ab_group = ABGroupCreate()
+
+      # groups only have a single regular attribute (name)
+      if v = @attributes[:name]
+        ABRecordSetValue(@ab_group, KABGroupNameProperty, v, error)
+      end
+
+      save
+
+      @ab_group
+    end
+  end
+end

data/motion/address_book/multi_valued.rb

@@ -0,0 +1,91 @@
+module AddressBook
+  class MultiValued
+    def initialize(opts)
+      unless opts.one?
+        raise ArgumentError, "MultiValued requires :attributes *or* :ab_multi_value argument"
+      end
+
+      if opts[:ab_multi_value]
+        # @ab_multi_value = ABMultiValueCreateMutableCopy(opts[:ab_multi_value])
+        @ab_multi_value = opts[:ab_multi_value]
+      else
+        @attributes = opts[:attributes]
+      end
+    end
+
+    def count
+      ABMultiValueGetCount(ab_multi_value)
+    end
+    alias :size :count
+
+    def attributes
+      @attributes ||= convert_multi_value_into_dictionary
+    end
+
+    def convert_multi_value_into_dictionary
+      count.times.map do |i|
+        label = ABMultiValueCopyLabelAtIndex(@ab_multi_value, i)
+        label_val = ABAddressBookCopyLocalizedLabel(label)
+        data = ab_record_to_dict(ABMultiValueCopyValueAtIndex(@ab_multi_value, i))
+        data.merge(:label => label_val)
+      end
+    end
+
+    def ab_multi_value
+      @ab_multi_value ||= convert_dictionary_into_multi_value
+    end
+
+    def convert_dictionary_into_multi_value
+      if @attributes.find {|rec| rec[:value]}
+        mv = ABMultiValueCreateMutable(KABMultiStringPropertyType)
+        @attributes.each do |rec|
+          ABMultiValueAddValueAndLabel(mv, rec[:value], rec[:label], nil)
+        end
+        mv
+      else
+        mv = ABMultiValueCreateMutable(KABMultiDictionaryPropertyType)
+        @attributes.each do |rec|
+          ABMultiValueAddValueAndLabel(mv, dict_to_ab_record(rec), rec[:label], nil)
+        end
+        mv
+      end
+    end
+
+    # these are for mapping fields in a kABMultiDictionaryPropertyType record
+    # to keys in a standard hash (NSDictionary)
+    @@attribute_map = {
+      KABPersonAddressStreetKey => :street,
+      KABPersonAddressCityKey => :city,
+      KABPersonAddressStateKey => :state,
+      KABPersonAddressZIPKey => :postalcode,
+      KABPersonAddressCountryKey => :country,
+      KABPersonAddressCountryCodeKey => :country_code,
+
+      KABPersonSocialProfileURLKey => :url,
+      KABPersonSocialProfileServiceKey => :service,
+      KABPersonSocialProfileUsernameKey => :username,
+      KABPersonSocialProfileUserIdentifierKey => :userid,
+
+      # these keys are identical to the SocialProfile keys above
+      KABPersonInstantMessageServiceKey => :service,
+      KABPersonInstantMessageUsernameKey => :username
+    }
+
+    def dict_to_ab_record(h)
+      @@attribute_map.each_with_object({}) do |(ab_key, attr_key), ab_record|
+        ab_record[ab_key] = h[attr_key] if h[attr_key]
+      end
+    end
+
+    def ab_record_to_dict(ab_record)
+      case ab_record
+      when String
+        {:value => ab_record}
+      else
+        @@attribute_map.each_with_object({}) do |(ab_key, attr_key), dict|
+          dict[attr_key] = ab_record[ab_key] if ab_record[ab_key]
+        end
+      end
+    end
+  end
+end

data/motion/address_book/person.rb

@@ -1,24 +1,25 @@
 module AddressBook
   class Person
-    attr_reader :attributes, :error, :ab_person
+    attr_reader :error
 
-    def initialize(attributes={}, existing_ab_person = nil)
-      @attributes = attributes
+    def initialize(attributes={}, existing_ab_person = nil, opts = {})
+      @address_book = opts[:address_book]
       if existing_ab_person.nil?
-        @new_record = true
+        @ab_person = nil
+        @attributes = attributes
       else
         @ab_person = existing_ab_person
-        load_ab_person
-        @new_record = false
+        @attributes = nil
       end
     end
 
     def self.all
-      ab_people = ABAddressBookCopyArrayOfAllPeople(AddressBook.address_book)
+      ab = AddressBook.address_book
+      ab_people = ABAddressBookCopyArrayOfAllPeople(ab)
       return [] if ab_people.nil?
 
       people = ab_people.map do |ab_person|
-        new({}, ab_person)
+        new({}, ab_person, :address_book => ab)
       end
       people.sort! { |a,b| "#{a.first_name} #{a.last_name}" <=> "#{b.first_name} #{b.last_name}" }
       people
@@ -32,9 +33,26 @@ module AddressBook
 
     def save
       ABAddressBookAddRecord(address_book, ab_person, error)
-      ABAddressBookSave(address_book, error )
-      @address_book = nil #force refresh
-      @new_record = false
+      ABAddressBookSave(address_book, error)
+      @attributes = nil # force refresh
+      uid
+    end
+
+    def attributes
+      @attributes || import_ab_person
+    end
+
+    def ab_person
+      if @ab_person.nil?
+        @ab_person = ABPersonCreate()
+        load_ab_person
+      end
+      @ab_person
+    end
+    alias :ab_record :ab_person
+
+    def uid
+      ABRecordGetRecordID(ab_person)
     end
 
     def self.where(conditions)
@@ -45,16 +63,27 @@ module AddressBook
 
     def meets?(conditions)
       conditions.keys.all? do |attribute|
-        send(attribute) == conditions[attribute]
+        case attribute
+        when :email
+          emails.attributes.map {|rec| rec[:value]}.any? {|v| v == conditions[attribute]}
+        else
+          send(attribute) == conditions[attribute]
+        end
       end
     end
 
     def self.attribute_map
-      { :first_name   => KABPersonFirstNameProperty,
+      {
+        :first_name   => KABPersonFirstNameProperty,
+        :middle_name   => KABPersonMiddleNameProperty,
         :last_name    => KABPersonLastNameProperty,
+        :suffix    => KABPersonSuffixProperty,
+        :nickname    => KABPersonNicknameProperty,
         :job_title    => KABPersonJobTitleProperty,
         :department   => KABPersonDepartmentProperty,
-        :organization => KABPersonOrganizationProperty
+        :organization => KABPersonOrganizationProperty,
+        # :dob    => KABPersonBirthdayProperty,
+        :note    => KABPersonNoteProperty
       }
     end
     def attribute_map
@@ -136,14 +165,26 @@ module AddressBook
       attributes[attribute_name.to_sym] = value
     end
 
+    def self.find_by_uid(criteria)
+      find_by :uid, criteria
+    end
+
     def self.find_all_by(attribute_name, criteria)
       where({attribute_name.to_sym => criteria})
     end
     def self.find_by(attribute_name, criteria)
       find_all_by(attribute_name, criteria).first
     end
+    def self.new_by(attribute_name, criteria)
+      case attr_sym = attribute_name.to_sym
+      when :email
+        new({:emails => [{:value => criteria}]})
+      else
+        new({attr_sym => criteria})
+      end
+    end
     def self.find_or_new_by(attribute_name, criteria)
-      find_by(attribute_name, criteria) || new({attribute_name.to_sym => criteria})
+      find_by(attribute_name, criteria) || new_by(attribute_name, criteria)
     end
 
     def photo
@@ -154,39 +195,51 @@ module AddressBook
       ABPersonSetImageData(ab_person, photo_data, error)
     end
 
+    def get_multi_valued(field)
+      MultiValued.new(:ab_multi_value => ABRecordCopyValue(ab_person, field))
+    end
 
-    def phone_numbers
-      get_multi_field(KABPersonPhoneProperty)
+    def phones
+      get_multi_valued(KABPersonPhoneProperty)
     end
 
-    def phone_number_values
-      phone_numbers.values
+    def phone_values
+      phones.attributes.map {|r| r[:value]}
     end
 
     def emails
-      get_multi_field(KABPersonEmailProperty )
+      get_multi_valued(KABPersonEmailProperty)
     end
 
     def email_values
-      emails.values
+      emails.attributes.map {|r| r[:value]}
     end
 
-    # UGH - kinda arbitrary way to deal with multiple values.  DO SOMETHING BETTER.
-    def email
-      @attributes[:email] ||= email_values.first
+    def addresses
+      get_multi_valued(KABPersonAddressProperty)
     end
-    def phone_number
-      @attributes[:phone_number] ||= phone_number_values.first
+
+    def urls
+      get_multi_valued(KABPersonURLProperty)
     end
 
-    def ab_person
-      if @ab_person.nil?
-        @ab_person = ABPersonCreate()
-        load_ab_person
-      end
-      @ab_person
+    def social_profiles
+      get_multi_valued(KABPersonSocialProfileProperty)
+    end
+
+    def im_profiles
+      get_multi_valued(KABPersonInstantMessageProperty)
+    end
+
+    def related_names
+      get_multi_valued(KABPersonRelatedNamesProperty)
     end
 
+    def email; email_values.first; end
+    def phone; phone_values.first; end
+    def url; urls.attributes.first[:value]; end
+    def address; addresses.attributes.first; end
+
     def find_or_new
       if new_record?
         new_ab_person
@@ -196,45 +249,129 @@ module AddressBook
     end
 
     def new_record?
-      !!@new_record
+      uid == KABRecordInvalidID
     end
+    alias :new? :new_record?
     def exists?
       !new_record?
     end
-    def inspect
-      # ensure all attributes loaded
-      attribute_map.keys.each do |attribute|
-        self.send(attribute)
+
+    def delete!
+      unless new_record?
+        ABAddressBookRemoveRecord(address_book, ab_person, error)
+        ABAddressBookSave(address_book, error)
+        @ab_person = nil
+        self
       end
+    end
 
-      super
+    def composite_name
+      ABRecordCopyCompositeName(ab_person)
+    end
+
+    def person?
+      get_field(KABPersonKindProperty) == KABPersonKindPerson
+    end
+    def organization?
+      get_field(KABPersonKindProperty) == KABPersonKindOrganization
+    end
+
+    # must stash date values in instance variables or RubyMotion throws a malloc error
+    def creation_date
+      @creation_date = get_field(KABPersonCreationDateProperty)
+    end
+
+    def modification_date
+      @modification_date = get_field(KABPersonModificationDateProperty)
     end
 
     private
 
+    def single_value_property_map
+      {
+        KABPersonFirstNameProperty => :first_name,
+        KABPersonLastNameProperty => :last_name,
+        KABPersonMiddleNameProperty => :middle_name,
+        KABPersonSuffixProperty => :suffix,
+        KABPersonNicknameProperty => :nickname,
+        KABPersonJobTitleProperty => :job_title,
+        KABPersonDepartmentProperty => :department,
+        KABPersonOrganizationProperty => :organization,
+        # KABPersonBirthdayProperty => :dob,
+        KABPersonNoteProperty => :note
+      }
+    end
+
+    def multi_value_property_map
+      {
+        KABPersonPhoneProperty => :phones,
+        KABPersonEmailProperty => :emails,
+        KABPersonAddressProperty => :addresses,
+        KABPersonURLProperty => :urls,
+        KABPersonSocialProfileProperty => :social_profiles,
+        KABPersonInstantMessageProperty => :im_profiles,
+        KABPersonRelatedNamesProperty => :related_names
+      }
+    end
+
+    # instantiates ABPerson record from attributes
     def load_ab_person
-      set_field(KABPersonFirstNameProperty,    attributes[:first_name  ]) unless attributes[:first_name  ].nil?
-      set_field(KABPersonLastNameProperty,     attributes[:last_name   ]) unless attributes[:last_name   ].nil?
-      set_field(KABPersonJobTitleProperty,     attributes[:job_title   ]) unless attributes[:job_title   ].nil?
-      set_field(KABPersonDepartmentProperty,   attributes[:department  ]) unless attributes[:department  ].nil?
-      set_field(KABPersonOrganizationProperty, attributes[:organization]) unless attributes[:organization].nil?
-      set_multi_field(KABPersonPhoneProperty,  :mobile => attributes[:mobile_phone], :work => attributes[:office_phone])
-      set_multi_field(KABPersonEmailProperty,  :work => attributes[:email])
+      @attributes ||= {}
+
+      single_value_property_map.each do |ab_property, attr_key|
+        if attributes[attr_key]
+          set_field(ab_property, attributes[attr_key])
+        end
+      end
+
+      if attributes[:is_org]
+        set_field(KABPersonKindProperty, KABPersonKindOrganization)
+      else
+        set_field(KABPersonKindProperty, KABPersonKindPerson)
+      end
+
+      multi_value_property_map.each do |ab_property, attr_key|
+        if attributes[attr_key]
+          set_multi_valued(ab_property, attributes[attr_key])
+        end
+      end
+    end
+
+    def import_ab_person
+      @attributes = {}
+      single_value_property_map.each do |ab_property, attr_key|
+        if value = get_field(ab_property)
+          @attributes[attr_key] = value
+        end
+      end
+
+      if organization?
+        @attributes[:is_org] = true
+      end
+
+      multi_value_property_map.each do |ab_property, attr_key|
+        if (value = get_multi_valued(ab_property).attributes) && value.any?
+          @attributes[attr_key] = value
+        end
+      end
+
+      @attributes
     end
 
     def set_field(field, value)
-      ABRecordSetValue(ab_person, field, value, error)
+      if value
+        ABRecordSetValue(ab_person, field, value, error)
+      end
     end
     def get_field(field)
       ABRecordCopyValue(ab_person, field)
     end
 
-    def set_multi_field(field, values)
-      multi_field = MultiValue.new(values, ABRecordCopyValue(ab_person, field))
-      ABRecordSetValue(ab_person, field, multi_field.ab_multi_values, error )
-    end
-    def get_multi_field(field)
-      MultiValue.new({}, ABRecordCopyValue(ab_person, field))
+    def set_multi_valued(field, values)
+      if values && values.any?
+        multi_field = MultiValued.new(:attributes => values)
+        ABRecordSetValue(ab_person, field, multi_field.ab_multi_value, nil)
+      end
     end
 
     def existing_records
@@ -253,6 +390,5 @@ module AddressBook
     def address_book
       @address_book ||= AddressBook.address_book
     end
-
   end
 end

data/motion/address_book.rb

@@ -9,6 +9,10 @@ module AddressBook
     end
   end
 
+  def count
+    ABAddressBookGetPersonCount(address_book)
+  end
+
   def ios6_create
     error = nil
     @address_book = ABAddressBookCreateWithOptions(nil, error)
@@ -17,7 +21,7 @@ module AddressBook
   end
 
   def ios5_create
-    ABAddressBookCreate()
+    @address_book = ABAddressBookCreate()
   end
 
   def request_authorization(&block)

data/spec/address_book/group_spec.rb

@@ -0,0 +1,59 @@
+describe AddressBook::Group do
+  before do
+    @ab = AddressBook::AddrBook.new
+  end
+
+  describe 'an empty group' do
+    before do
+      @group = @ab.new_group(:name => 'Test Group')
+    end
+    after do
+      @group.delete!
+    end
+
+    it "should have a name" do
+      @group.name.should.equal 'Test Group'
+    end
+
+    it "should be empty" do
+      @group.members.should.be.empty
+      @group.size.should.equal 0
+    end
+
+    it "should not be new" do
+      @group.should.not.be.new
+    end
+  end
+
+  describe 'a group with members' do
+    before do
+      @p1 = @ab.new_person({:first_name => 'Alice', :emails => [{:label => 'home', :value => 'alice@example.com'}]})
+      @p1.save
+      @p2 = @ab.new_person({:first_name => 'Bob', :emails => [{:label => 'home', :value => 'bob@example.com'}]})
+      @p2.save
+      @group = @ab.new_group(:name => 'Test Group')
+      @group << @p1
+      @group << @p2
+      @group.save
+    end
+    after do
+      @group.delete!
+      @p1.delete!
+      @p2.delete!
+    end
+
+    it "should have 2 members" do
+      @group.size.should.equal 2
+    end
+
+    it "should have the expected members" do
+      @group.members.map {|person| person.first_name}.should.equal ['Alice', 'Bob']
+    end
+
+    it "should search by id" do
+      @ab.group(@group.uid).name.should.equal @group.name
+    end
+  end
+
+  # TODO: nested groups
+end

data/spec/address_book/multi_valued_spec.rb

@@ -0,0 +1,66 @@
+describe AddressBook::MultiValued do
+  describe 'a string multi-value' do
+    before do
+      @attributes = [
+        {
+          :label => 'home page',
+          :value => "http://www.mysite.com/"
+        }, {
+          :label => 'work',
+          :value => 'http://dept.bigco.com/'
+        }, {
+          :label => 'school',
+          :value => 'http://state.edu/college'
+        }
+      ]
+      @mv = AddressBook::MultiValued.new(:attributes => @attributes)
+    end
+
+    it 'should be countable' do
+      @mv.count.should.equal 3
+    end
+
+    it 'should be reversible' do
+      abmv = @mv.ab_multi_value
+      mv2 = AddressBook::MultiValued.new(:ab_multi_value => abmv)
+      mv2.attributes.should.equal @attributes
+    end
+  end
+
+  describe 'a dictionary multi-value' do
+    before do
+      @attributes = [
+        {
+          :label => 'home',
+          :street => '123 Boring St',
+          :city => 'Snoozeville',
+          :state => "CA"
+        }, {
+          :label => 'work',
+          :street => '99 Exciting Ave, Suite #200',
+          :city => 'Las Vegas',
+          :state => "NV"
+        }
+      ]
+      @mv = AddressBook::MultiValued.new(:attributes => @attributes)
+    end
+
+    it 'should count the records' do
+      @mv.count.should.equal 2
+      @mv.size.should.equal 2
+    end
+
+    it 'should store the initial data correctly' do
+      @mv.attributes.should.equal @attributes
+    end
+
+    it 'should have correct internal representation' do
+      internal = @mv.ab_multi_value
+      ABMultiValueGetCount(internal).should.equal 2
+      ABMultiValueCopyLabelAtIndex(internal, 0).should.equal "home"
+      ABMultiValueCopyLabelAtIndex(internal, 1).should.equal "work"
+      ABMultiValueCopyValueAtIndex(internal, 0).keys.count.should.equal 3
+      ABMultiValueCopyValueAtIndex(internal, 1).keys.count.should.equal 3
+    end
+  end
+end

data/spec/address_book/person_spec.rb

@@ -1,28 +1,54 @@
 describe AddressBook::Person do
+  before do
+    @ab = AddressBook::AddrBook.new
+  end
   describe 'ways of creating and finding people' do
     describe 'new' do
       before do
-        @alex = AddressBook::Person.new(:first_name => 'Alex', :last_name => 'Testy', :email => 'alex_testy@example.com')
+        @data = new_alex
+        @alex = @ab.new_person(@data)
       end
       it 'should create but not save in the address book' do
         @alex.should.be.new_record
+      end
+      it 'should have initial values' do
         @alex.first_name.should == 'Alex'
         @alex.last_name.should  == 'Testy'
-        @alex.email_values.should     == ['alex_testy@example.com']
+        @alex.email_values.should == [@data[:emails][0][:value]]
+        @alex.email.should == @data[:emails][0][:value]
+      end
+      it "should round-trip attributes without loss" do
+        @alex.attributes.should.equal @data
+      end
+      it 'should have a composite name' do
+        @alex.composite_name.should == 'Alex Testy'
       end
     end
 
     describe 'existing' do
       before do
         @email = unique_email
-        @alex = AddressBook::Person.create(:first_name => 'Alex', :last_name => 'Testy', :email => @email)
+        @alex = @ab.create_person(new_alex(@email))
+      end
+      after do
+        @alex.delete!
       end
-      describe '.find_by_all_email' do
+      describe '.find_by_uid' do
+        it 'should find match' do
+          alex = @ab.person(@alex.uid)
+          alex.uid.should == @alex.uid
+          alex.email_values.should.include? @email
+          alex.first_name.should == 'Alex'
+          alex.last_name.should  == 'Testy'
+          alex.attributes.should.equal @alex.attributes
+        end
+      end
+      describe '.find_all_by_email' do
         it 'should find matches' do
           alexes = AddressBook::Person.find_all_by_email @email
           alexes.should.not.be.empty
           alexes.each do |alex|
-            alex.email.should == @email
+            alex.email_values.should.include? @email
             alex.first_name.should == 'Alex'
             alex.last_name.should  == 'Testy'
           end
@@ -35,7 +61,7 @@ describe AddressBook::Person do
       describe '.find_by_email' do
         it 'should find match' do
           alex = AddressBook::Person.find_by_email @email
-          alex.email.should == @email
+          alex.email_values.should.include? @email
           alex.first_name.should == 'Alex'
           alex.last_name.should  == 'Testy'
         end
@@ -49,7 +75,7 @@ describe AddressBook::Person do
           alexes = AddressBook::Person.where(:email => @email)
           alexes.should.not.be.empty
           alexes.each do |alex|
-            alex.email.should == @email
+            alex.email_values.should.include? @email
             alex.first_name.should == 'Alex'
             alex.last_name.should  == 'Testy'
           end
@@ -62,16 +88,17 @@ describe AddressBook::Person do
 
       describe '.all' do
         it 'should have the person we created' do
-          all_names = AddressBook::Person.all.map do |person|
+          all_names = @ab.people.map do |person|
             [person.first_name, person.last_name]
           end
           all_names.should.include? [@alex.first_name, @alex.last_name]
         end
 
         it 'should get bigger when we create another' do
-          initial_people_count = AddressBook::Person.all.size
-          @person = AddressBook::Person.create({:first_name => 'Alex2', :last_name=>'Rothenberg2'})
-          AddressBook::Person.all.size.should == (initial_people_count + 1)
+          initial_people_count = @ab.people.size
+          @person = @ab.create_person({:first_name => 'Alex2', :last_name=>'Rothenberg2'})
+          @ab.people.size.should == (initial_people_count + 1)
+          @person.delete!
         end
       end
     end
@@ -79,37 +106,64 @@ describe AddressBook::Person do
     describe '.find_or_new_by_XXX - new or existing' do
       before do
         @email = unique_email
-        AddressBook::Person.create(:first_name => 'Alex', :last_name => 'Testy', :email => @email)
+        @alex = @ab.create_person(new_alex(@email))
+      end
+      after do
+        @alex.delete!
       end
+
       it 'should find an existing person' do
         alex = AddressBook::Person.find_or_new_by_email(@email)
         alex.should.not.be.new_record
-        alex.email.should      == @email
         alex.first_name.should == 'Alex'
         alex.last_name.should  == 'Testy'
+        alex.emails.attributes.map{|r| r[:value]}.should == [@email]
       end
       it 'should return new person when no match found' do
         never_before_used_email = unique_email
-        alex = AddressBook::Person.find_or_new_by_email(never_before_used_email)
-        alex.should.be.new_record
-        alex.email.should == never_before_used_email
-        alex.first_name.should == nil
+        new_person = AddressBook::Person.find_or_new_by_email(never_before_used_email)
+        new_person.should.be.new_record
+        new_person.email_values.should == [never_before_used_email]
+        new_person.first_name.should == nil
       end
     end
   end
 
   describe 'save' do
     before do
-      @attributes = {:first_name=>'Alex', :last_name=>'Testy',
-                     :job_title => 'Developer', :department => 'Development', :organization => 'The Company',
-                     :mobile_phone => '123 456 7890', :office_phone => '987 654 3210',
-                     :email => unique_email
-                    }
+      @attributes = {
+        :first_name=>'Alex',
+        :middle_name=>'Q.',
+        :last_name=>'Testy',
+        :suffix => 'III',
+        :nickname => 'Geekster',
+        :job_title => 'Developer',
+        :department => 'Development',
+        :organization => 'The Company',
+        :note => 'some important guy',
+        # :mobile_phone => '123 456 7890', :office_phone => '987 654 3210',
+        :phones => [
+          {:label => 'mobile', :value => '123 456 7899'},
+          {:label => 'office', :value => '987 654 3210'}
+        ],
+        # :email => unique_email,
+        :emails => [
+          {:label => 'work', :value => unique_email}
+        ],
+        :addresses => [
+          {:label => 'home', :city => 'Dogpatch', :state => 'KY'}
+        ],
+        :urls => [
+          { :label => 'home page', :value => "http://www.mysite.com/" },
+          { :label => 'work', :value => 'http://dept.bigco.com/' },
+          { :label => 'school', :value => 'http://state.edu/college' }
+        ]
+      }
     end
 
     describe 'a new person' do
       before do
-        @ab_person = AddressBook::Person.new(@attributes)
+        @ab_person = @ab.new_person(@attributes)
       end
 
       it 'should not be existing' do
@@ -120,9 +174,21 @@ describe AddressBook::Person do
       it 'should be able to get each of the single value fields' do
         @ab_person.first_name.should.equal   @attributes[:first_name  ]
         @ab_person.last_name.should.equal    @attributes[:last_name   ]
+        @ab_person.middle_name.should.equal    @attributes[:middle_name   ]
+        @ab_person.suffix.should.equal    @attributes[:suffix   ]
+        @ab_person.nickname.should.equal    @attributes[:nickname   ]
         @ab_person.job_title.should.equal    @attributes[:job_title   ]
         @ab_person.department.should.equal   @attributes[:department  ]
         @ab_person.organization.should.equal @attributes[:organization]
+        @ab_person.note.should.equal @attributes[:note]
+        @ab_person.should.be.person?
+      end
+
+      it 'should get a value back for singular requests against multi-value attributes' do
+        @ab_person.email.should.equal @attributes[:emails].first[:value]
+        @ab_person.phone.should.equal @attributes[:phones].first[:value]
+        @ab_person.url.should.equal @attributes[:urls].first[:value]
+        @ab_person.address.should.equal @attributes[:addresses].first
       end
 
       describe 'setting each field' do
@@ -147,7 +213,7 @@ describe AddressBook::Person do
           @ab_person.organization.should.equal 'new organization'
         end
 
-        it 'should be able to set the phot' do
+        it 'should be able to set the photo' do
           image = CIImage.emptyImage
           data = UIImagePNGRepresentation(UIImage.imageWithCIImage image)
           @ab_person.photo = data
@@ -155,31 +221,90 @@ describe AddressBook::Person do
         end
       end
 
-      it 'should be able to get the phone numbers' do
-        @ab_person.phone_number_values.should.equal [@attributes[:mobile_phone], @attributes[:office_phone] ]
+      it 'should be able to count & get the phone numbers' do
+        @ab_person.phones.size.should.equal 2
+        @ab_person.phones.attributes.should.equal @attributes[:phones]
+      end
+
+      it 'should be able to count & get the emails' do
+        @ab_person.emails.size.should.equal 1
+        @ab_person.emails.attributes.should.equal @attributes[:emails]
       end
 
-      it 'should be able to get the emails' do
-        @ab_person.email_values.should.equal [@attributes[:email] ]
+      it 'should be able to count & inspect the addresses' do
+        @ab_person.addresses.count.should.equal 1
+        @ab_person.addresses.attributes.should.equal @attributes[:addresses]
       end
-      describe 'saving' do
+
+      it 'should be able to count & inspect the URLs' do
+        @ab_person.urls.count.should.equal 3
+        @ab_person.urls.attributes.should.equal @attributes[:urls]
+      end
+
+      describe 'once saved' do
         before do
+          @before_count = AddressBook.count
           @ab_person.save
         end
-        it 'after saving it should not be existing' do
+        after do
+          @ab_person.delete!
+        end
+
+        it 'should no longer be new' do
           @ab_person.should.not.be.new_record
           @ab_person.should.be.exists
         end
+
+        it "should increment the count" do
+          AddressBook.count.should.equal @before_count+1
+        end
+
+        it 'should round-trip all attributes without loss' do
+          @ab_person.attributes.should.equal @attributes
+        end
+
+        it 'should have scalar properties' do
+          [:first_name, :middle_name, :last_name, :job_title, :department, :organization, :note].each do |attr|
+            @ab_person.send(attr).should.equal @attributes[attr]
+          end
+        end
+
+        it 'should have a composite name' do
+          @ab_person.composite_name.should == 'Alex Q. Testy III'
+        end
+
+        it 'should be able to count the emails' do
+          @ab_person.emails.size.should.equal 1
+        end
+
+        it 'should be able to count the addresses' do
+          @ab_person.addresses.count.should.equal 1
+        end
+
+        it 'should be able to retrieve the addresses' do
+          @ab_person.addresses.attributes.should.equal @attributes[:addresses]
+        end
+      end
+
+      describe 'once deleted' do
+        before do
+          @ab_person.save
+          @ab_person.delete!
+        end
+        it 'should no longer exist' do
+          @ab_person.should.not.be.exists
+          # @ab_person.should.be.new_record
+        end
       end
     end
 
-    describe 'updating an existing person' do
+    describe 'an existing person' do
       before do
-        AddressBook::Person.new(@attributes).save
-        @attributes[:job_title   ] = 'i got promoted'
-        @attributes[:office_phone] = '111 222 3333'
-        @attributes[:department  ] = nil
-        @ab_person = AddressBook::Person.find_or_new_by_email(@attributes[:email])
+        @orig_ab_person = @ab.create_person(@attributes)
+        @ab_person = AddressBook::Person.find_or_new_by_email(@attributes[:emails][0][:value])
+      end
+      after do
+        @ab_person.delete!
       end
 
       it 'should know it is not new' do
@@ -189,23 +314,75 @@ describe AddressBook::Person do
         @ab_person.department.should == 'Development'
       end
 
-      describe 'updating' do
-        it 'should be able to get each of the single value fields' do
+      it 'should not change ID' do
+        @ab_person.uid.should.equal @orig_ab_person.uid
+      end
+
+      describe 'when updated' do
+        before do
+          @ab_person.first_name = 'New First Name'
           @ab_person.save
-          @new_ab_person = AddressBook::Person.find_by_email @ab_person.email
-          @new_ab_person.first_name = 'New First Name'
-          @new_ab_person.save
-          AddressBook::Person.find_by_email(@ab_person.email).first_name.should == 'New First Name'
         end
+
+        it 'should be able to get each of the single value fields' do
+          @match = AddressBook::Person.find_by_email(@ab_person.email_values.first)
+          @match.first_name.should == 'New First Name'
+          @match.uid.should.equal @ab_person.uid
+        end
+      end
+    end
+
+    describe "input with bad attributes" do
+      before do
+        @attributes[:junk] = 'this should be ignored'
+        @attributes[:last_name] = nil
+        @attributes[:urls] = [
+          { :value => "http://www.mysite.com/" },
+          { :label => 'work' },
+          { :label => 'work', :url => 'http://state.edu/college' }
+        ]
+        @ab_person = @ab.create_person(@attributes)
+      end
+      after do
+        @ab_person.delete!
+      end
+
+      # entries with missing label should be OK
+      # entries with missing value should be ignored
+      # entries with illegal fields should raise an exception
+      it "should save without errors" do
+        @ab_person.should.be.exists
+      end
+
+      it "should have the expected values" do
+        @ab_person.urls.count.should.equal 1
+        urldata = [{:value => "http://www.mysite.com/", :label => ""}]
+        @ab_person.urls.attributes.should.equal urldata
+        @ab_person.attributes.keys.should.not.include?(:junk)
+        @ab_person.last_name.should.equal nil
       end
+    end
+  end
 
+  describe "organization record" do
+    before do
+      @person = @ab.new_person(
+        :first_name => 'John',
+        :last_name => 'Whorfin',
+        :organization => 'Acme Inc.',
+        :is_org => true,
+        :note => 'big important company'
+      )
     end
 
+    it "should know that it is an organization" do
+      @person.should.be.organization?
+    end
   end
 
   describe 'method missing magic' do
     before do
-      @person = AddressBook::Person.new
+      @person = @ab.new_person({})
     end
     describe 'getters' do
       it 'should have a getter for each attribute' do
@@ -236,6 +413,9 @@ describe AddressBook::Person do
         @person.setter?('find_all_by_email').should.be falsey
         @person.setter?('find_by_email'    ).should.be falsey
       end
+      it 'should not have a setter for uid' do
+        @person.setter?('uid=').should.be falsey
+      end
     end
     describe 'all_finders' do
       it 'should have a finder for each attribute' do

data/spec/helpers/person_helpers.rb

@@ -2,3 +2,11 @@ def unique_email(email='alex_testy@example.com')
   name, domain = email.split('@')
   "#{name}_#{Time.now.to_i}_#{rand(1000)}@#{domain}"
 end
+
+def new_alex(emailaddr = unique_email)
+  {
+    :first_name => 'Alex',
+    :last_name => 'Testy',
+    :emails => [{:label => 'home', :value => emailaddr}]
+  }
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: motion-addressbook
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-14 00:00:00.000000000 Z
+date: 2013-04-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bubble-wrap
@@ -67,6 +67,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .travis.yml
 - Gemfile
 - LICENSE
 - README.md
@@ -75,10 +76,15 @@ files:
 - lib/motion-addressbook/version.rb
 - motion-addressbook.gemspec
 - motion/address_book.rb
+- motion/address_book/addr_book.rb
+- motion/address_book/group.rb
 - motion/address_book/multi_value.rb
+- motion/address_book/multi_valued.rb
 - motion/address_book/person.rb
 - motion/address_book/picker.rb
+- spec/address_book/group_spec.rb
 - spec/address_book/multi_value_spec.rb
+- spec/address_book/multi_valued_spec.rb
 - spec/address_book/person_spec.rb
 - spec/address_book/picker_spec.rb
 - spec/helpers/bacon_matchers.rb
@@ -98,7 +104,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3801596602075157460
+      hash: 3256350264444301144
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -107,7 +113,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3801596602075157460
+      hash: 3256350264444301144
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24
@@ -115,7 +121,9 @@ signing_key:
 specification_version: 3
 summary: A RubyMotion wrapper around the iOS Address Book framework
 test_files:
+- spec/address_book/group_spec.rb
 - spec/address_book/multi_value_spec.rb
+- spec/address_book/multi_valued_spec.rb
 - spec/address_book/person_spec.rb
 - spec/address_book/picker_spec.rb
 - spec/helpers/bacon_matchers.rb