gedcom 0.9.0 → 0.9.1

data/lib/gedcom/gedcom_all.rb

@@ -39,3 +39,5 @@ require 'submitter_record.rb'
 require 'text_record.rb'
 require 'trailer_record.rb'
 require 'transmission_base.rb'
+require 'xref.rb'
+require 'ged_string.rb'

data/lib/gedcom/gedcom_base.rb

@@ -3,7 +3,9 @@ require "instruction.rb"
 
 #base routines shared by all gedcom objects.
 class GEDCOMBase
-  attr_accessor  :class_stack, :indexes
+  #Restriction records only exist in some GEDCOM record types, and we do honor that.
+  #Internally though, my DB allows any record to be restricted, hence this global use of :restriction.
+  attr_accessor :restriction
   @@tabs = false #If true, indent gedcom lines on output a tab per level. Normally wouldn't have tabs in a transmission file.
 
   #Create a new GEDCOMBase or most likely a subclass of GEDCOMBase.
@@ -54,10 +56,12 @@ class GEDCOMBase
   #create a string from the objects instance variables, one per line, in the form "variable = value\n" ... .
   #For an ordered list, see to_s_ordered
   def to_s
+    #This might seem a little obscure, but this will find and print the attributes with get methods defined,
+    #not having prior knowledge of what those attributes are.
     s = ''
     self.instance_variables.each do |v| #look at each of the instance variables
       if self.class.method_defined?(v_sym = v[1..-1].to_sym) #see if there is a method defined for this symbol (strip the :)
-        s += "#{v} = " + pv_byname(v_sym) + "\n" #print it
+        s += "#{v} = " + pv_byname(v_sym).to_s + "\n" #print it
       end
     end
     s
@@ -83,6 +87,30 @@ class GEDCOMBase
     to_db( level, @this_level, @sub_level)
   end
   
+  #Find a XREF within this transmission. All classes inheriting from GEDCOMBase record the parent transmission object.
+  def find(*a)
+    @transmission.find(*a) if @transmission != nil
+  end
+  
+  #Test for a Restriction notice for privacy
+  #People may request that a records contents not be available for public consumption.
+  def private?
+    (@restriction != nil && @restriction == "privacy") ? true : false
+  end
+  
+  #Test for a Restriction notice for a locked record.
+  #Locked records mean that the data is known to be correct, so shouldn't be 
+  #altered without checking with the original source of the data.
+  def locked?
+    (@restriction != nil && @restriction == "locked") ? true : false
+  end
+    
+  #All our values are stored as arrays of words. This is quite useful in word wrapping of NOTES, TEXT, etc, and further parsing records like dates.
+  #It isn't really that helpful when we want to use a value as a string. This is a utility function to join the words into a space separated string.
+  def token_to_s(token)
+    token
+  end
+  
   private
   
   #Somewhat cryptic. This takes the symbol (variable name) and returns the object associatied with it.
@@ -125,7 +153,7 @@ class GEDCOMBase
     #printing aid for tags that can have CONT or CONC sub-tags
     s_out = "#{tabstop(level)}#{level} #{tag}"
     if data != nil
-      data.each do |word|
+      data.each_word do |word|
         if word != "\n"
           s_out +=  " #{word}"
         end
@@ -156,10 +184,10 @@ class GEDCOMBase
     #printing aid for tags that can have CONT or CONC sub-tags
     s_out = "#{tabstop(level)}#{level} #{tag}"
     nlevel = level + (conc ? 0 : 1)
-    
+
     if data != nil
       length = s_out.length
-      data.each_with_index do |word,i|
+      data.each_word_with_index do |word,i|
         if length > 253 && word != "\n" && data.length != i #253 allows for CR LF or LF CR pairs as the line terminator.
           s_tmp =  "#{tabstop(nlevel)}#{nlevel} CONC"
           length = s_tmp.length #new line, so reset length
@@ -188,7 +216,7 @@ class GEDCOMBase
     s_out = "#{tabstop(level)}#{level} CONT"
     
     if data != nil
-      data.each_with_index do |word,i|
+      data.each_word_with_index do |word,i|
         s_out +=  " #{word}"
         if word == "\n"
           s_out +=  "#{tabstop(level)}#{level} CONT"
@@ -203,9 +231,9 @@ class GEDCOMBase
   #Level n GEDCOM records have the @XREF@ after the tag.
   def xref(level, tag, xref)
     if level == 0 
-       "#{tabstop(level)}#{level} @#{xref}@ #{tag}\n"
+       "#{tabstop(level)}#{level} @#{xref.xref_value}@ #{tag}\n"
     else
-       "#{tabstop(level)}#{level} #{tag} @#{xref}@\n"
+       "#{tabstop(level)}#{level} #{tag} @#{xref.xref_value}@\n"
     end
   end
   
@@ -229,8 +257,8 @@ class GEDCOMBase
   def to_s_r_action(level, action, tag, data=nil)
     case action
     when :xref   then 
-      xref_check(level, tag, data[0], data[1])
-      xref(level, tag, data[1])
+      xref_check(level, tag, data)
+      xref(level, tag, data)
     when :print then single_line(level, tag, data )
     when :conc then  cont_conc(level, tag, true, data )
     when :cont then  cont_conc(level, tag, false, data )
@@ -246,10 +274,10 @@ class GEDCOMBase
   
   #validate that the record referenced by the XREF actually exists in this transmission.
   #Genearte a warning if it does not. It does not stop the processing of this line.
-  def xref_check(level, tag, index, xref)
-    if @transmission != nil && @transmission.find(index, xref) == nil
+  def xref_check( level, tag, xref )
+    if @transmission != nil && @transmission.find(xref.index, xref.xref_value) == nil
       #Warning message that reference points to an unknown target.
-      print "#{level+1} NOTE ****************Key not found: #{index} #{xref}\n"
+      print "#{level+1} NOTE ****************#{level}, #{tag} Key not found: #{xref.index} #{xref.xref_value}\n"
     end
   end
   
@@ -277,8 +305,9 @@ class GEDCOMBase
       if this_level_instruction.data != nil
         data = self.send( this_level_instruction.data ) #gets the contents using the symbol, and sending "self" a message
       else
-        data =  [['']]
+        data =  [GedString.new('')]
       end
+
       if data != nil #could be if the self.send targets a variable that doesn't exist.
         data.each do |data_instance| 
           s_out += to_s_r_action(level, this_level_instruction.action, this_level_instruction.tag, data_instance)
@@ -288,8 +317,9 @@ class GEDCOMBase
             if sub_level_instruction.data != nil
               sub_level_data = self.send( sub_level_instruction.data ) #gets the contents using the symbol, and sending "self" a message
             else
-               sub_level_data = [['']]
+               sub_level_data = [GedString.new('')]
             end
+            
             if sub_level_data != nil  #could be if the self.send targets a variable that doesn't exist.
               sub_level_data.each do |sub_data_instance| 
                 s_out += to_s_r_action(level+1, sub_level_instruction.action, sub_level_instruction.tag, sub_data_instance )

data/lib/gedcom/individual_attribute_record.rb

@@ -51,19 +51,42 @@ class Individual_attribute_record < Event_record
 
   ClassTracker <<  :Individual_attribute_record
   
+  #attr_type= stores the attribute type in the event_type field.
+  #this minor hack lets us share methods with the event class.
   def attr_type=(value)
     @event_type = value
   end
+
+  #attr_type retrieves the attribute type from the Event_record#event_type field.
+  #this minor hack lets us share methods with the event class.
   def attr_type
     @event_type
   end
+  
+  #is_attribute? tests that this Individual_attribute_record is of this attribute type.
+  #The attribute type is stored in the the Event_record#event_type field.
+  #this minor hack lets us share methods with the event class.
+  #This make sense, as the GEDCOM INDIVIDUAL_ATTRIBUTE_STRUCTURE has GEDCOM <<EVENT_DETAIL>> tags at level +1.
+  def is_attribute?(attribute)
+    is_event?(attribute)
+  end
+
+  #value= stores the value in the Event_record#event_status.
+  #this minor hack lets us share methods with the event class.
   def value=(value)
-    @event_status = value
+      @event_status = value 
   end
+
+  #value retrieves the value from the Event_record#event_status.
+  #this minor hack lets us share methods with the event class.
   def value
     @event_status
   end
-
+  
+  private
+  
+  #actually attribute_tag, but we share code with the Event_record class,
+  #as the GEDCOM INDIVIDUAL_ATTRIBUTE_STRUCTURE has GEDCOM <<EVENT_DETAIL>> tags at level +1.
   def event_tag(tag)
     case tag
     when "SEX" then tag

data/lib/gedcom/individual_record.rb

@@ -98,31 +98,454 @@ class Individual_record < GEDCOMBase
     @individual_ref
   end
   
+  #Finds the parent's family record(s) and returns the Family_record object in an array.
+  #This allows for multiple parentage. There is usually only be one FAMC record, but their 
+  #might be another recording an adoption or an alternate family, if parentage is not clear.
+  #Parents_family returns nil if there are no FAMC records (or the FAMC XREFs
+  #don't resolve to a FAM record in the transmission).
+  #
+  #If a block is passed, then each Family_record is yielded to the block.
   def parents_family
-    parents_family = []
-    @families_individuals.each { |m| parents_family << m.parents_family_ref if m.relationship_type == "FAMC"}
-    parent_family
+    if @families_individuals
+      parent_families = []
+      @families_individuals.each do |p| 
+        if p.relationship_type[0] == "FAMC"
+          if (parent_family = find(:family, p.parents_family_ref.first.xref_value)) != nil
+            parent_families << parent_family
+            yield parent_family if block_given?
+          end
+        end
+      end
+      return parent_families if parent_families.length > 0 #might be a 0 length array.
+    end
+    return nil
+  end
+  
+  #child? is a consistency check, testing that this INDI record has a FAMC record to the given FAM record.
+  def child?(fam)
+    if (pf = parents_family) != nil
+      pf.each do |famc|
+        return true if famc == fam
+      end
+    end
+    return false
   end
   
+  #Finds the family record for each spouse (or fellow parent) and returns the Family_record objects in an array.
+  #This allows for being a parent of multiple families. Spouses will return nil if there are no 
+  #FAMS records (or the FAMS XREFs don't resolve to a FAM record in the transmission).
+  #
+  #If a block is passed, then each Family_record is yielded to the block.
   def spouses
-    spouses = []
-    @families_individuals.each { |m| spouses << m.own_family if m.relationship_type == "FAMS"}
-    spouses
+    if @families_individuals
+      spouses = []
+      @families_individuals.each do |s|
+        if s.relationship_type[0] == "FAMS"
+          #Make sure we can find the spouse's Family_record.
+          if (spouse_family = find(:family, s.family_ref.first.xref_value)) != nil
+            spouses << spouse_family
+            yield spouse_family if block_given?
+          end
+        end
+      end
+      return spouses if spouses.length > 0 #might be a 0 length array.
+    end
+    return nil
   end
   
-  def birth
+  #spouse? is a consistency check, testing that this INDI record has a FAMS record to the given FAM record.
+  def spouse?(fam)
+    if (pf = spouses) != nil
+      pf.each do |fams|
+        return true if fams == fam
+      end
+    end
+    return false
+  end
+
+  #Event looks in the Individual_record for events, as specified by the type argument, 
+  #returning an array of the events found. Returns nil if there were
+  #no events of this type in this Individual_record. 
+  #
+  #If a block is given, then yields each event to the block.
+  def event(type)
     if @event_record != nil
-      @event_record.each { |e| if e.is_event('BIRT') then return e end }
+      events = []
+      @event_record.each do |e| 
+        if e.is_event?(type)
+          yield e if block_given?
+          events << e
+        end
+      end
+      return events if events.length > 0
+    end
+    return nil
+  end
+  
+  #Short hand for event('BIRT')
+  #passes on any block to the event method.
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def birth(&p)
+    if block_given? then event('BIRT',&p) else event('BIRT') end
+  end
+  
+  #Short hand for event('CHR')
+  #passes on any block to the event method.
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def christening(&p)
+    if block_given? then event('CHR',&p) else event('CHR') end
+  end
+  
+  #Short hand for event('ADOP')
+  #passes on any block to the event method.
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def adoption(&p)
+    if block_given? then event('ADOP',&p) else event('ADOP') end
+  end
+  
+  #Short hand for event('DEAT')
+  #passes on any block to the event method.
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def death(&p)
+    if block_given? then event('DEAT',&p) else event('DEAT') end
+  end
+  
+  #Short hand for event('BURI')
+  #passes on any block to the event method.
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def burial(&p)
+    if block_given? then event('BURI',&p) else event('BURI') end
+  end
+  
+  #Short hand for event('CREM')
+  #passes on any block to the event method.
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def cremation(&p)
+    if block_given? then event('CREM',&p) else event('CREM') end
+  end
+  
+  #Short hand for event('WILL')
+  #passes on any block to the event method.
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def will(&p)
+    if block_given? then event('WILL',&p) else event('WILL') end
+  end
+  
+  #Short hand for event('PROB')
+  #passes on any block to the event method.
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def probate(&p)
+    if block_given? then event('PROB',&p) else event('PROB') end
+  end
+  
+  #Short hand for event('CENS')
+  #passes on any block to the event method.
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def census(&p)
+    if block_given? then event('CENS',&p) else event('CENS') end
+  end
+  
+  #Short hand for event('GRAD')
+  #passes on any block to the event method.
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def graduation(&p)
+    if block_given? then event('GRAD',&p) else event('GRAD') end
+  end
+  
+  #Short hand for event('RETI')
+  #passes on any block to the event method.
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def retirement(&p)
+    if block_given? then event('RETI',&p) else event('RETI') end
+  end
+  
+  #Short hand for event('BAPM')
+  #passes on any block to the event method.
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def baptism(&p)
+    if block_given? then event('BAPM',&p) else event('BAPM') end
+  end
+  
+  #Short hand for event('BARM')
+  #passes on any block to the event method.
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def bar_mitzvah(&p)
+    if block_given? then event('BARM',&p) else event('BARM') end
+  end
+  
+  #Short hand for event('BASM')
+  #passes on any block to the event method.
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def bas_mitzvah(&p)
+    if block_given? then event('BASM',&p) else event('BASM') end
+  end
+  
+  #Short hand for event('BLES')
+  #passes on any block to the event method.
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def blessing(&p)
+    if block_given? then event('BLES',&p) else event('BLES') end
+  end
+  
+  #Short hand for event('ORDN')
+  #passes on any block to the event method.
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def ordination(&p)
+    if block_given? then event('ORDN',&p) else event('ORDN') end
+  end
+  
+  #Short hand for event('CHRA')
+  #passes on any block to the event method.
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def adult_christening(&p)
+    if block_given? then event('CHRA',&p) else event('CHRA') end
+  end
+  
+  #Short hand for event('CONF')
+  #passes on any block to the event method.
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def confirmation(&p)
+    if block_given? then event('CONF',&p) else event('CONF') end
+  end
+  
+  #Short hand for event('FCOM')
+  #passes on any block to the event method.
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def first_communion(&p)
+    if block_given? then event('FCOM',&p) else event('FCOM') end
+  end
+  
+  #Short hand for event('NATU')
+  #passes on any block to the event method.
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def naturalization(&p)
+    if block_given? then event('NATU',&p) else event('NATU') end
+  end
+  
+  #Short hand for event('EMIG')
+  #passes on any block to the event method.
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def emigration(&p)
+    if block_given? then event('EMIG',&p) else event('EMIG') end
+  end
+  
+  #Short hand for event('IMMI')
+  #passes on any block to the event method.
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def immigration(&p)
+    if block_given? then event('IMMI',&p) else event('IMMI') end
+  end
+  
+  #Short hand for the event('BAPL') LDS Ordinance 
+  #passes on any block to the event method.
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def lds_baptism(&p)
+    if block_given? then event('BAPL',&p) else event('BAPL') end
+  end
+  
+  #Short hand for the event('CONL') LDS Ordinance 
+  #passes on any block to the event method.
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def lds_confirmation(&p)
+    if block_given? then event('CONL',&p) else event('CONL') end
+  end
+  
+  #Short hand for the event('ENDL') LDS Ordinance 
+  #passes on any block to the event method.
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def lds_endowment(&p)
+    if block_given? then event('ENDL',&p) else event('ENDL') end
+  end
+  
+  #Short hand for the event('SLGC') LDS Ordinance 
+  #passes on any block to the event method.
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def lds_child_sealing(&p)
+    if block_given? then event('SLGC',&p) else event('SLGC') end
+  end
+  
+  #Short hand for the event('SLGS') LDS Sealing 
+  #passes on any block to the event method.
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def lds_spouse_sealing(&p)
+    if block_given? then event('SLGS',&p) else event('SLGS') end
+  end
+  
+  #Attribute looks in the Individual_record for attributes, as specified by the attribute argument, 
+  #returning an array of the attrbutes found. This may be a 0 length array, if there were
+  #no attrbutes of this type in this Individual_record. 
+  #
+  #If a block is given, then yields each event to the block.
+  def attribute(attribute)
+    if @individual_attribute_record != nil
+      attributes = [] #collect the individual_attribute_record's of type attribute in this array.
+      @individual_attribute_record.each do |a| 
+        #Look for the attribute in question.
+        if a.is_attribute?(attribute)
+          yield a if block_given? 
+          attributes << a #add this record to the attributes array.
+        end
+      end
+      return attributes if attributes.length > 0 #if we found any, return the array.
+    end
+    return nil #if we found none, then return nil.
+  end
+  
+  #Short hand for attribute('SEX')
+  #passes on any block to the event method.
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def sex(&p)
+    if block_given? then attribute('SEX',&p) else attribute('SEX') end
+  end
+  
+  #Short hand for attribute('CAST')
+  #passes on any block to the event method.
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def caste_name(&p)
+    if block_given? then attribute('CAST',&p) else attribute('CAST') end
+  end
+  
+  #Short hand for attribute('DSCR')
+  #passes on any block to the event method.
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def physical_description(&p)
+    if block_given? then attribute('DSCR',&p) else attribute('DSCR') end
+  end
+  
+  #Short hand for attribute('EDUC')
+  #passes on any block to the event method.
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def education(&p)
+    if block_given? then attribute('EDUC',&p) else attribute('EDUC') end
+  end
+  
+  #Short hand for attribute('IDNO')
+  #passes on any block to the event method.
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def national_id_number(&p)
+    if block_given? then attribute('IDNO',&p) else attribute('IDNO') end
+  end
+  
+  #Short hand for attribute('NATI')
+  #passes on any block to the event method.
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def national_origin(&p)
+    if block_given? then attribute('NATI',&p) else attribute('NATI') end
+  end
+  
+  #Short hand for attribute('NCHI')
+  #passes on any block to the event method.
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def number_children(&p)
+    if block_given? then attribute('NCHI',&p) else attribute('NCHI') end
+  end
+  
+  #Short hand for attribute('NMR')
+  #passes on any block to the event method.
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def marriage_count(&p)
+    if block_given? then attribute('NMR',&p) else attribute('NMR') end
+  end
+  
+  #Short hand for attribute('OCCU')
+  #passes on any block to the event method.
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def occupation(&p)
+    if block_given? then attribute('OCCU',&p) else attribute('OCCU') end
+  end
+  
+  #Short hand for attribute('PROP')
+  #passes on any block to the event method.
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def possessions(&p)
+    if block_given? then attribute('PROP',&p) else attribute('PROP') end
+  end
+  
+  #Short hand for attribute('RELI')
+  #passes on any block to the event method.
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def religion(&p)
+    if block_given? then attribute('RELI',&p) else attribute('RELI') end
+  end
+  
+  #Short hand for attribute('RESI')
+  #passes on any block to the event method.
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def residence(&p)
+    if block_given? then attribute('RESI',&p) else attribute('RESI') end
+  end
+  
+  #Short hand for attribute('SSN')
+  #passes on any block to the event method.
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def social_security_number(&p)
+    if block_given? then attribute('SSN',&p) else attribute('SSN') end
+  end
+  
+  #Short hand for attribute('TITL')
+  #passes on any block to the event method 
+  #(The block is the &p argument, so you don't pass any arguments to this method).
+  def title(&p)
+    if block_given? then attribute('TITL',&p) else attribute('TITL') end
+  end
+
+  #Test to see if we have a NAME record stored for this individual.
+  def has_name?
+    @name_record != nil && @name_record.length > 0
+  end
+  
+  #Names looks in the Individual_record for Name_records, returning an array of the Name_records found. 
+  #This may be a 0 length array, if there were no NAME tags in this GEDCOM record for this Individual_record. 
+  #
+  #If a block is given, then yields each event to the block.
+  def names
+    if has_name?
+      if block_given?
+        @name_record.each { |n| yield n }
+      end
+      return @name_record
     else
-      nil
+      return []
     end
   end
   
-  def death
-    if @event_record != nil
-      @event_record.each { |e| if e.is_event('DEAT') then return e end }
+  #Primary_name returns the first name (as a string) defined in the @name_record array (and probably the only name defined).
+  #The GEDCOM standard states that if multiple TAGS of the same type are present, then the first is the most
+  #preferred, with the last the least preferred. I'm not certain that programs generating GEDCOM follow that rule,
+  #but if there are multiple NAME records, and you want one to display, then picking the first is what the standard
+  #says to do.
+  #
+  #Returns "" if no name is recorded in this Individual_record and if the individual requested privacy for this record.
+  def primary_name
+    if has_name? 
+      if  self.private? || @name_record[0].private?
+        ""
+      else
+         @name_record[0].name 
+      end 
+    else 
+      "" 
+    end
+  end
+  
+  def self_check
+    if @families_individuals
+      @families_individuals.each do |p| 
+        if p.relationship_type[0] == "FAMC"
+          if find(:family, p.parents_family_ref.first.xref_value) == nil
+            puts "INDI #{@individual_ref.first.xref_value} FAMC #{p.parents_family_ref.first.xref_value} record has no FAM record"
+          end
+        elsif p.relationship_type[0] == "FAMS"
+          if find(:family, p.family_ref.first.xref_value) == nil
+            puts "INDI #{@individual_ref.first.xref_value} FAMS #{p.family_ref.first.xref_value} record has no FAM record"
+          end
+        else
+          puts "Unrecognised relationship #{p.relationship_type[0]}"
+        end
+      end
     else
-      nil
+      puts "INDI #{@individual_ref.first.xref_value} has no FAMC or FAMS record"
     end
   end
+  
 end