gedcom 0.9.0

data/lib/gedcom/source_record.rb

@@ -0,0 +1,84 @@
+require 'gedcom_base.rb'
+
+#Internal representation of the GEDCOM SOUR record type
+#Both inline and references to Level 0 Source_records are referenced via the Source_citation_record class.
+#
+#SOURCE_RECORD:=
+#  0 @<XREF:SOUR>@ SOUR                           {0:M}
+#    +1 DATA {0:1}
+#      +2 EVEN <EVENTS_RECORDED>                  {0:M}
+#        +3 DATE <DATE_PERIOD>                    {0:1}
+#        +3 PLAC <SOURCE_JURISDICTION_PLACE>      {0:1}
+#      +2 AGNC <RESPONSIBLE_AGENCY>               {0:1}
+#      +2 <<NOTE_STRUCTURE>>                      {0:M}
+#    +1 AUTH <SOURCE_ORIGINATOR>                  {0:1}
+#      +2 [CONT|CONC] <SOURCE_ORIGINATOR>         {0:M}
+#    +1 TITL <SOURCE_DESCRIPTIVE_TITLE>           {0:1}
+#      +2 [CONT|CONC] <SOURCE_DESCRIPTIVE_TITLE>  {0:M}
+#    +1 ABBR <SOURCE_FILED_BY_ENTRY>              {0:1}
+#    +1 PUBL <SOURCE_PUBLICATION_FACTS>           {0:1}
+#      +2 [CONT|CONC] <SOURCE_PUBLICATION_FACTS>  {0:M}
+#    +1 TEXT <TEXT_FROM_SOURCE>                   {0:1}
+#      +2 [CONT|CONC] <TEXT_FROM_SOURCE>          {0:M}
+#    +1 <<SOURCE_REPOSITORY_CITATION>>            {0:1}
+#    +1 <<MULTIMEDIA_LINK>>                       {0:M}
+#    +1 <<NOTE_STRUCTURE>>                        {0:M}
+#    +1 REFN <USER_REFERENCE_NUMBER>              {0:M}
+#      +2 TYPE <USER_REFERENCE_TYPE>              {0:1}
+#    +1 RIN <AUTOMATED_RECORD_ID>                 {0:1}
+#    +1 <<CHANGE_DATE>>                           {0:1}
+#
+#  Source records are used to provide a bibliographic description of the source cited. (See the
+#  <<SOURCE_CITATION>> structure, page 32, which contains the pointer to this source record.)#
+#
+#Systems not using level 0 source records, inline SOUR records combining SOURCE_RECORDS with SOURCE_CITATIONs.
+#We create both a Source_record object and a Source_citation_record object, as if the transmission had used both.
+#  n SOUR <SOURCE_DESCRIPTION>                    {1:1}
+#    +1 [ CONC | CONT ] <SOURCE_DESCRIPTION>      {0:M}
+#    +1 TEXT <TEXT_FROM_SOURCE>                   {0:M}
+#    +2 [CONC | CONT ] <TEXT_FROM_SOURCE>         {0:M}
+#    +1 <<NOTE_STRUCTURE>>                        {0:M}
+#
+#The attributes are all arrays representing the +1 level of the SOURCE_RECORD. 
+#* Those ending in _ref are GEDCOM XREF index keys
+#* Those ending in _record are array of classes of that type.
+#* The remainder are arrays of attributes that could be present in the SOUR records.
+#
+class Source_record < GEDCOMBase
+  attr_accessor :source_ref, :short_title, :title, :author,  :source_scope_record,  :publication_details
+  attr_accessor :repository_citation_record, :text_record, :note_citation_record, :multimedia_citation_record
+  attr_accessor :refn_record, :automated_record_id, :change_date_record
+
+  ClassTracker <<  :Source_record
+  
+  #to_gedcom sets up the state engine arrays @this_level and @sub_level, which drive the parent class to_gedcom method generating GEDCOM output.
+  #There are two types of SOUR record, inline and reference, so this is done dynamically in to_gedcom rather than the initialize method.
+  #Probably should be two classes, rather than this conditional.
+  def to_gedcom(level=0)
+    if @source_ref != nil
+      @this_level = [ [:xref, "SOUR", :source_ref] ]
+      @sub_level =  [ #level + 1
+                      [:print, "ABBR", :short_title],
+                      [:cont, "TITL", :title],
+                      [:cont, "AUTH", :author],
+                      [:cont, "PUBL", :publication_details],
+                      [:walk, nil,  :repository_citation_record],
+                      [:walk, nil, :text_record],
+                      [:walk, nil, :multimedia_citation_record],
+                      [:walk, nil, :source_scope_record],
+                      [:walk, nil, :note_citation_record],
+                      [:walk, nil, :refn_record],
+                      [:print, "RIN", :automated_record_id],
+                      [:walk,  nil, :change_date_record],
+                    ]
+    else
+      @this_level = [ [:cont, "SOUR", :title] ]
+      @sub_level =  [ #level + 1
+                      [:walk, nil, :text_record],
+                      [:walk, nil, :note_citation_record] ,
+                    ] 
+    end
+    super(level)
+  end
+end
+

data/lib/gedcom/source_scope_record.rb

@@ -0,0 +1,35 @@
+require 'gedcom_base.rb'
+
+#Internal representation of the GEDCOM DATA record type, a record type under the GEDCOM Level 0 SOUR record type
+#
+#=SOURCE_RECORD:= 
+#  0 @<XREF:SOUR>@ SOUR                       {0:M}
+#    +1 DATA                                  {0:1}
+#      +2 EVEN <EVENTS_RECORDED>              {0:M}
+#        +3 DATE <DATE_PERIOD>                {0:1}
+#        +3 PLAC <SOURCE_JURISDICTION_PLACE>  {0:1}
+#      +2 AGNC <RESPONSIBLE_AGENCY>           {0:1}
+#      +2 <<NOTE_STRUCTURE>>                  {0:M}
+#    ...
+#
+#The attributes are all arrays. 
+#* Those ending in _record are array of classes of that type.
+#* The remainder are arrays of attributes that could be present in the SOUR.DATA records.
+
+class Source_scope_record < GEDCOMBase
+  attr_accessor :events_list_record, :agency, :note_citation_record
+
+  ClassTracker <<  :Source_scope_record
+  
+  #new sets up the state engine arrays @this_level and @sub_level, which drive the to_gedcom method generating GEDCOM output.
+  def initialize(*a)
+    super(*a)
+    @this_level = [[:nodata, "DATA", nil]]
+    @sub_level =  [ #level + 1
+                    [:walk, nil, :events_list_record],
+                    [:print, "AGNC",:agency],
+                    [:walk, nil, :note_citation_record],
+                  ]
+  end 
+end
+

data/lib/gedcom/submission_record.rb

@@ -0,0 +1,53 @@
+require 'gedcom_base.rb'
+
+#Internal representation of the GEDCOM SUBN record type
+#
+#=SUBMISSION_RECORD:=
+#  0 @XREF:SUBN@ SUBN                     {0:M}
+#    +1 SUBM @XREF:SUBM@                  {0:1}
+#    +1 FAMF <NAME_OF_FAMILY_FILE>        {0:1}
+#    +1 TEMP <TEMPLE_CODE>                {0:1}
+#    +1 ANCE <GENERATIONS_OF_ANCESTORS>   {0:1}
+#    +1 DESC <GENERATIONS_OF_DESCENDANTS> {0:1}
+#    +1 ORDI <ORDINANCE_PROCESS_FLAG>     {0:1}
+#    +1 RIN <AUTOMATED_RECORD_ID>         {0:1}
+#
+#  I also recognise notes in this record, so I can handle user tags as notes.
+#    +1 <<NOTE_STRUCTURE>>                {0:M}
+#
+#  The sending system uses a submission record to send instructions and information to the receiving
+#  system. TempleReady processes submission records to determine which temple the cleared records
+#  should be directed to. The submission record is also used for communication between Ancestral File
+#  download requests and TempleReady. Each GEDCOM transmission file should have only one
+#  submission record. Multiple submissions are handled by creating separate GEDCOM transmission
+#
+#The attributes are all arrays. 
+#* Those ending in _ref are GEDCOM XREF index keys
+#* Those ending in _record are array of classes of that type.
+#* The remainder are arrays of attributes that could be present in the SUBN records.
+
+
+class Submission_record < GEDCOMBase
+  attr_accessor :submission_ref, :submitter_ref, :lds_family_file, :lds_temple_code
+  attr_accessor :generations_of_ancestor, :generations_of_descendant, :automated_record_id
+  attr_accessor :process_ordinates, :note_citation_record
+
+  ClassTracker <<  :Submission_record
+  
+  #new sets up the state engine arrays @this_level and @sub_level, which drive the to_gedcom method generating GEDCOM output.
+  def initialize(*a)
+    super(*a)
+    @this_level = [ [:xref, "SUBN", :submission_ref] ]
+    @sub_level =  [ #level + 1
+                    [:xref, "SUBM", :submitter_ref],
+                    [:print, "FAMF",    :lds_family_file ],
+                    [:print, "TEMP",    :lds_temple_code ],
+                    [:print, "ANCE",    :generations_of_ancestor ],
+                    [:print, "DESC",    :generations_of_descendant ],
+                    [:print, "ORDI",    :process_ordinates ],
+                    [:print, "RIN",    :automated_record_id ],
+                    [:walk, nil,    :note_citation_record ],
+                  ]
+  end   
+end
+

data/lib/gedcom/submitter_record.rb

@@ -0,0 +1,53 @@
+require 'gedcom_base.rb'
+
+#Internal representation of the GEDCOM SUBM record type
+#
+#=SUBMITTER_RECORD:=
+#  0 @<XREF:SUBM>@ SUBM                 {0:M}
+#    +1 NAME <SUBMITTER_NAME>           {1:1}
+#    +1 <<ADDRESS_STRUCTURE>>           {0:1}
+#    +1 PHON <PHONE_NUMBER>             {0:3} (defined in the Address structure)
+#    +1 <<MULTIMEDIA_LINK>>             {0:M}
+#    +1 LANG <LANGUAGE_PREFERENCE>      {0:3}
+#    +1 RFN <SUBMITTER_REGISTERED_RFN>  {0:1}
+#    +1 RIN <AUTOMATED_RECORD_ID>       {0:1}
+#    +1 <<CHANGE_DATE>>                 {0:1}
+#
+#  I also recognise notes in this record, so I can handle user tags as notes.
+#    +1 <<NOTE_STRUCTURE>>              {0:M}
+#
+#  The submitter record identifies an individual or organization that contributed information contained
+#  in the GEDCOM transmission. All records in the transmission are assumed to be submitted by the
+#  SUBMITTER referenced in the HEADer, unless a SUBMitter reference inside a specific record
+#  points at a different SUBMITTER record.
+#
+#The attributes are all arrays. 
+#* Those ending in _ref are GEDCOM XREF index keys
+#* Those ending in _record are array of classes of that type.
+#* The remainder are arrays of attributes that could be present in the SUBM records.
+
+class Submitter_record < GEDCOMBase
+  attr_accessor :submitter_ref, :name_record, :address_record, :phone, :multimedia_citation_record
+  attr_accessor :language_list, :lds_submitter_id, :automated_record_id, :change_date_record, :note_citation_record
+
+  ClassTracker <<  :Submitter_record
+   
+  #new sets up the state engine arrays @this_level and @sub_level, which drive the to_gedcom method generating GEDCOM output.
+  def initialize(*a)
+    super(*a)
+    @this_level = [ [:xref, "SUBM", :submitter_ref] ]
+    @sub_level =  [ #level + 1
+                    [:walk, nil,    :name_record ],
+                    [:walk, nil,    :address_record ],
+                    [:print, "PHON",    :phone ],
+                    [:print, "LANG",    :language_list ],
+                    [:walk, nil,    :multimedia_citation_record ],
+                    [:walk, nil,    :note_citation_record ],
+                    [:print, "RFN",    :lds_submitter_id ],
+                    [:print, "RIN",    :automated_record_id ],
+                    [:walk, nil,    :change_date_record ],
+                  ]
+  end 
+  
+end
+

data/lib/gedcom/text_record.rb

@@ -0,0 +1,31 @@
+require 'gedcom_base.rb'
+
+#Internal representation of the GEDCOM TEXT record type.
+#
+#This tag is used in SOUR and SOUR.DATA records
+#=TEXT
+#  n  TEXT <TEXT_FROM_SOURCE>            {0:M}
+#  +1 [CONC | CONT ] <TEXT_FROM_SOURCE>  {0:M}
+#
+#==TEXT_FROM_SOURCE:= {Size=1:248}
+#  A verbatim copy of any description contained within the source. This indicates notes or text that are
+#  actually contained in the source document, not the submitter's opinion about the source. This should
+#  be, from the evidence point of view, "what the original record keeper said" as opposed to the
+#  researcher's interpretation. The word TEXT, in this case, means from the text which appeared in the
+#  source record including labels.
+#
+
+class Text_record < GEDCOMBase
+  attr_accessor :text
+  
+  ClassTracker <<  :Text_record
+  
+  #new sets up the state engine arrays @this_level and @sub_level, which drive the to_gedcom method generating GEDCOM output.
+  def initialize(*a)
+    super(*a)
+    @this_level = [ [:cont, "TEXT", :text] ]
+    @sub_level =  [ #level + 1
+                  ]
+  end 
+end
+

data/lib/gedcom/trailer_record.rb

@@ -0,0 +1,22 @@
+require 'gedcom_base.rb'
+
+#Internal representation of the GEDCOM TRLR record that terminates transmissions.
+#The Trailer_record class is just a place marker to ensure we have encountered a termination record in the GEDCOM file.
+#
+#=TRAILER:=
+#    0 TRLR                             {1:1}
+#  At level 0, specifies the end of a GEDCOM transmission.
+
+class Trailer_record < GEDCOMBase
+  
+  ClassTracker <<  :Trailer_record
+  
+  #new sets up the state engine arrays @this_level and @sub_level, which drive the to_gedcom method generating GEDCOM output.
+  def initialize(*a)
+    super(*a)
+    @this_level = [ [:nodata, "TRLR", nil] ]
+    @sub_level =  [ #level + 1
+                  ]
+  end 
+end
+

data/lib/gedcom/transmission.rb

@@ -0,0 +1,103 @@
+require 'gedcom_all.rb'
+
+#Transmission subclasses TransmissionBase, providing a cleaner view for public consumption.
+#
+#TransmissionBase is a subclass of GEDCOMBase, and contains methods used by the parsing process
+#to build the other Gedcom classes, instantiate instances for each GEDCOM record type, and populate
+#the fields based on the parsed GEDCOM file.
+#
+#
+#A Transmission object is encapsulating a LINEAGE_LINKED_GEDCOM. From the GEDCOM 5.5 standard:
+#=LINEAGE_LINKED_GEDCOM:=
+#  This is a model of the lineage-linked GEDCOM structure for submitting data to other lineage-linked
+#  GEDCOM processing systems. A header and a trailer record are required, and they can enclose any
+#  number of data records. Tags from Appendix A (see page 67) must be used in the same context as
+#  shown in the following form. User defined tags (see <NEW_TAG> on page 46) are discouraged but
+#  when used must begin with an under-score.
+#    0 <<HEADER>>               {1:1}
+#    0 <<SUBMISSION_RECORD>>    {0:1}
+#    0 <<FAM_RECORD>>           {0:M}
+#    0 <<INDIVIDUAL_RECORD>>    {0:M}
+#    0 <<MULTIMEDIA_RECORD>>    {0:M}
+#    0 <<NOTE_RECORD>>          {0:M}
+#    0 <<REPOSITORY_RECORD>>    {0:M}
+#    0 <<SOURCE_RECORD>>        {0:M}
+#    0 <<SUBMITTER_RECORD>>     {0:M}
+#    0 TRLR                     {1:1} 
+#
+#Each of the classes attributes is an array of objects representing the level 0 GEDCOM records in the
+#transmission. There is also an :index attribute defined in GEDCOMBase, with an associated 
+#find method (see Transmission#find)
+
+
+class  Transmission < TransmissionBase
+ 
+  attr_accessor :header_record, :submitter_record, :family_record, :individual_record, :source_record
+  attr_accessor :multimedia_record, :note_record, :repository_record, :submission_record, :trailer_record
+
+  def initialize(*a)
+    super(nil, *a[1..-1]) #don't need to put ourselves into @transmission.
+    
+    @this_level = [ [:walk, nil, :header_record],     #Recurse over the HEAD header records (should only be one)
+                    [:walk, nil, :submission_record], #Recurse over the SUBN submission records
+                    [:walk, nil, :submitter_record],  #Recurse over the SUBM submitter record(s)
+                    [:walk, nil, :source_record],     #Recurse over the SOUR Source records
+                    [:walk, nil, :repository_record], #Recurse over the REPO repository records
+                    [:walk, nil, :family_record],     #Recurse over the FAM Family records
+                    [:walk, nil, :individual_record], #Recurse over the INDI Individual records
+                    [:walk, nil, :multimedia_record], #Recurse over the OBJE multimedia records
+                    [:walk, nil, :note_record],       #Recurse over the NOTE records
+                    [:walk, nil, :trailer_record],    #Recurse over the Trailer Record(s). (should only be the one).
+                  ]
+    @sub_level =  [#level + 1
+                  ]
+
+  end
+
+  #Looks in a transmissions indexes for an index called index_name, returning the value associated with the key.
+  #also used by xref_check to validate the XREF entries in a transmission really do point to valid level 0 records.
+  #Standard indexes are the same as the level 0 types that have XREF values:
+  #* :individual
+  #* :family
+  #* :note
+  #* :source
+  #* :repository
+  #* :multimedia
+  #* :submitter
+  #* :submission
+  #Keys in each of these indexes are the XREF values from the GEDCOM file.
+  #The values stored in the indexes are the actual objects that they refer to.
+  #* e.g. 
+  #     if (f = find(:individual,"I14") ) != nil then print f.to_gedcom end
+  #  will find the Individual's record with "0 @I14@ INDI" and print the record and its sub-records.
+  def find(index_name, key)
+    if @indexes != nil && (index = @indexes[index_name.to_sym]) != nil
+      index[key]
+    else
+      nil
+    end
+  end
+  
+  #debugging code to show what indexes were created and what keys are in each
+  #Printing out the index values generates too much output, so these are ignored.
+  def dump_indexes
+    @indexes.each do |key,value|
+      puts "Index #{key}"
+      value.each do |vkey, vvalue|
+        puts "\t#{vkey}"
+      end
+    end
+  end
+=begin
+  def summary
+    @@tabs = true
+    if (f = find(:individual,"PERSON7") ) != nil 
+       s = f.to_gedcom
+       puts s #output window copy gives an error.
+       File.open('/tmp/xx.txt','w') { |fd| fd.print s } #file copy is correct
+       puts s #output window copy gives an error.
+    end 
+    @@tabs = false
+  end
+=end
+end

data/lib/gedcom/transmission_base.rb

@@ -0,0 +1,267 @@
+require 'pp'
+require 'gedcom_base.rb'
+
+#TransmissionBase is a subclass of GEDCOMBase, and contains methods used by the parsing process
+#to build the other Gedcom classes, instantiate instances for each GEDCOM record type, and populate
+#the fields based on the parsed GEDCOM file.
+class TransmissionBase < GEDCOMBase
+  
+  ClassTracker <<  :TransmissionBase
+ 
+  #new creates initializes the arrays for each of the GEDCOM level 0 record types.
+  def initialize(*a)
+    super(*a)
+     #Create the initial top level arrays of records that can exist in a transmission.
+    @header_record = []
+    @submission_record = []
+    @submitter_record = []
+    @individual_record = []
+    @family_record = []
+    @source_record = []
+    @repository_record = []
+    @multimedia_record = []
+    @note_record = []
+    @trailer_record = []
+
+    #Class_stack is for the parsing process to hold the classes we create as we walk down the levels of a gedcom record.
+    #The class we are currently working with is on the top of the stack.
+    #The put ourselves on the top of the stack. The number represents the number of class to pop to go back one level of gedcom.
+    @class_stack = [[self, 0]]
+    #Create a hash to hold the indexes used in this transmission
+    @indexes = {} #find is defined in GEDCOMBase, as it gets used by a private method of that class.
+  end
+
+  #summary() prints out the number of each level 0 record type the we have just parsed.
+  def summary
+    puts "HEAD count = #{@header_record.length}"
+    puts "SUBM count = #{@submission_record.length}"
+    puts "SUBN count = #{@submitter_record.length}"
+    puts "INDI count = #{@individual_record.length}"
+    puts "FAM count = #{@family_record.length}"
+    puts "SOUR count = #{@source_record.length}"
+    puts "REPO count = #{@repository_record.length}"
+    puts "OBJE count = #{@multimedia_record.length}"
+    puts "NOTE count = #{@note_record.length}"
+    puts "TRLR count = #{@trailer_record.length}"
+    
+    #p ClassTracker #Debugging line.
+    #pp @indexes[:individual]["IPB4"] #debugging test to find and print an indivual's record with xref @IPB4@
+    #pp @indexes[:family]["F1"] #debugging test to find and print a family record with the xref @F1@
+    #pp @indexes[:note] #debugging test to print all NOTE records
+    #p find(:individual,"IB1024").to_gedcom #debugging test to find an individual record with xref @IB1024@ and print the record and its sub-records.
+  end
+
+  #validate() is part of the parsing process, and checks that the GEDCOM line falls within the data length specified by the standard
+  #A warning is printed if the data is longer than allowed by the standard. As most programs seem to ignore the maximum data lengths,
+  #including the test file from LDS, the line is accepted regardless.
+  def validate lineno, tokens, max_data_size
+    #Validate the length of the data field is in bounds.
+    if tokens.data != nil
+      length = tokens.data.inject(0) { |l,element| l += element.length + 1 }
+      if length - 1 > max_data_size
+        p "Warning Line #{lineno}: Data portion may be too long for some databases. (Length = #{length - 1}, MAX = #{max_data_size})"
+      end
+    end
+  end
+
+  #create_class() is part of the parsing process, and looks in the ClassTracker class to see if this class exists.
+  #if it doesn't already exist, the class is created and an instance is returned.
+  #if it already exists, then a new instance of the class is returned.
+  def create_class(lineno, class_name)
+    if class_name != nil
+      new_class = class_name.to_s.capitalize
+      if defined(new_class) == nil
+        p "#{lineno}: Create class #{new_class}"
+        define(new_class)
+        new_class = Object.const_set("#{new_class}", Class.new) #creates a Class and assigns it the constant given
+      end 
+      #p "#{lineno}: instance class #{class_name}"
+      class_instance = eval "#{new_class}.new(self)" #create an instance of the new class.
+      if class_instance == nil
+        raise "class #{class_name} instance nil"
+      end
+    end
+    class_instance
+  end
+
+  #add_to_class_field() is part of the parsing process, and checks to see if the field exists in the current states, target object.
+  #If the field exists, then the data is added to the field array. Each field is an array, so we can have multiple instances of a TAG in a GEDCOM record.
+  #If the field doesn't exist, the field is added to the target object, along with attr_accessors. The data is then added as above.
+  #* lineno is the current GEDCOM files line number, so we can report errors.
+  #* field is a symbol naming the attribute we want to store the data in in the class.
+  #* data is a word array, holding the GEDCOM lines data value
+  def add_to_class_field(lineno, field, data)
+    #puts "#{lineno}: Add class instance '#{data.class}' to field #{field} of #{@class_stack.last[0]}"
+    if @class_stack.last[0].class.method_defined?(field) == false
+      p "#{lineno}: create a field called #{field} in class #{@class_stack.last[0].class.to_s}" 
+      @class_stack.last[0].class.class_eval("attr_accessor :#{field}")
+      #p "#{lineno}: Add the class #{data.class.to_s} as an array, to the field #{field} in class #{@class_stack.last[0].class.to_s}" 
+      @class_stack.last[0].send( field.to_s + "=", data ? [ data ] : []) #Much faster than eval("@class_stack.last[0].#{field} = [#{data}]")
+    else
+      if a = @class_stack.last[0].send( field )
+        #Much faster than eval("@class_stack.last[0].#{field} << #{data}")
+        #p "#{lineno}: Add the class #{data.class.to_s} to the field #{field}[] in class #{@class_stack.last[0].class.to_s}" 
+        a << data if data != nil
+      else
+        #p "#{lineno}: Add the class #{data.class.to_s} as an array, to the field #{field} in class #{@class_stack.last[0].class.to_s}" 
+        @class_stack.last[0].send( field.to_s + "=", data ? [ data ] : [] )
+      end
+    end
+  end
+
+  #pop() is part of the parsing process, and removes target objects from their stack, which must remain aligned with the ParseState stack.
+  #Multiple object may be removed, as we may step back multiple levels in the ParseState stack.
+  #The object removed will have been placed into their parent GEDCOM records object before being removed from the stack.
+  def pop
+    #this is to catch multiple classes added to the stack, for one gedcom line.
+    i = @class_stack.last[1]
+    i.times { @class_stack.pop }
+  end
+
+  #update_field() is part of the parsing process, and discards the data_type and calls add_to_class_field.
+  #I'm sure there is a reason I did this. I just can't think what it was.
+  #* lineno is the current GEDCOM files line number, so we can report errors.
+  #* field is a symbol naming the attribute we want to store the data in in the class.
+  #* data is a word array, holding the GEDCOM lines data value
+  def update_field(lineno, field, data_type, data)
+    #p "#{lineno}: Add data '#{data}' to field #{field} of #{@class_stack.last[0]}"
+    add_to_class_field(lineno, field, data)
+  end
+
+  #append_nl_field() is part of the parsing process, and inserts a '\n' character in front of the data, then calls append_field().
+  #* lineno is the current GEDCOM files line number, so we can report errors.
+  #* field is a symbol naming the attribute we want to store the data in in the class.
+  #* data is a word array, holding the GEDCOM lines data value
+  def append_nl_field(lineno, field, data_type, data)
+    #p "#{lineno}: Append data 'nl + #{data}' to field #{field} of #{@class_stack.last[0]}"
+    the_data = ["\n"] #want to add a new line to the existing data
+    the_data += data if data != nil #add the new data only if it is not null.
+    append_field(lineno, field,data_type, the_data)
+  end
+
+  #append_field() is part of the parsing process, and adds the data to the end of the field's array.
+  #* lineno is the current GEDCOM files line number, so we can report errors.
+  #* field is a symbol naming the attribute we want to store the data in in the class.
+  #* data is a word array, holding the GEDCOM lines data value
+  def append_field(lineno, field, data_type, data)
+    #p "#{lineno}: Append data '#{data}' to field #{field} of #{@class_stack.last[0]}"
+    begin
+      if data != nil#Only bother if we have some data
+        if a = @class_stack.last[0].send( field ) #The field is not nil
+          if a != [] #The field is not an empty array
+            if a[-1] != nil #The last element is not null
+              #p "Add the class #{data.class.to_s} to the field #{field}[] in class #{@class_stack.last[0].class.to_s}"
+              a[-1] += data 
+            else #The last element is null
+              #p "Add the class #{data.class.to_s} as an array, to the field #{field} in class #{@class_stack.last[0].class.to_s}"
+              a[-1] = data
+            end
+          else #Was an empty array, so add the element.
+            a[0] = data
+          end
+        else #The field was null
+          #p "Add the class #{data.class.to_s} as an array, to the field #{field} in class #{@class_stack.last[0].class.to_s}"
+          @class_stack.last[0].send( field.to_s + '=',  [data])
+        end
+      end
+    rescue => exception
+      p "#{exception} : Append data '#{data}' to field '#{field}' of class '#{@class_stack.last[0]}'"
+      raise exception
+    end
+  end
+
+  #create_index is part of the parsing process, and adds the key, value pair to the index index_name, creating the index if it didn't already exist.
+  #* lineno is the current GEDCOM files line number, so we can report errors.
+  #* index_name is the category of the index. e.g. it could be an index of individual records , or family records, etc.
+  #* key is  a GEDCOM XREF we want to be able to track.
+  #* value is the target object that was created to hold the referenced GEDCOM record.
+  def create_index(lineno, index_name, key, value)
+    if index_name != nil
+      if @indexes[index_name] == nil
+        #puts "#{lineno}: create index #{index_name}"
+        @indexes[index_name] = {} #empty hash
+      end
+      if key != nil
+        #p "#{lineno}: Add (key,value) #{key} => #{@class_stack.last[0]} to index #{index_name}"
+        if @indexes[index_name][key] != nil
+          raise "duplicate key #{key} in index #{index_name}"
+        end
+        @indexes[index_name][key] = value
+      end
+    end
+  end
+
+  #add_to_index is part of the parsing process, and adds references into the current target object to the index (i.e fills in the XREFs with index references]
+  def add_to_index(lineno, field_name, index_name, key)
+    #p "#{lineno}: Add key #{key} to index #{index_name} to field #{field_name} of #{@class_stack.last[0]}"
+     add_to_class_field(lineno, field_name, [index_name, *key] )
+  end
+
+  #action_handler process the actions in the GedcomParser::TAGS hash, creating classes and populating attributes.
+  # Actions:
+  # [:class, :class_name] inidicates this line, and any further data, will be stored in the class  :class_name
+  # [:pop] indicates that data will now be stored in the previous class.
+  # [:field, :fieldname] indicates that the data part of the line will be stored in the field :field_name
+  # [:field, [:fieldname, value]]  fieldname stores the given value.
+  # [:append, :fieldname] indicates that the data part of the line will be appended to this field
+  # [:append_nl, :fieldname] indicates that the data part of the line will be appended to this field, after first appending a nl
+  # [:xref, [:field, :record_type]] indicates that the xref value of the line will get stored in the named field and points to the record_type.
+  # [:key, :index_name] means we need to create an index entry, in the index index_name, for this items xref value.
+  # nil in this field indicates that we should ignore this TAG and its children.
+  ACTION = 0
+  DATA = 1
+  def action_handler( lineno, tokens, child_record = nil, min_occurances = 0, max_occurances = nil, data_type = nil, max_data_size = nil, action = nil, data_description = '' )
+
+    validate(lineno, tokens, max_data_size)
+
+    if action != nil
+      nclasses = 1
+      new_class = nil
+      action.each do |do_this| #We have instructions for handling this line.
+        case do_this[ACTION]
+          when :class 
+            #create a new class, making an instance of it, and making the instance the default one.
+            new_class = create_class(lineno, do_this[DATA])
+            #Add this instance to an Array field of the current class, of the same name as the new class.
+            add_to_class_field(lineno, do_this[DATA], new_class)
+            #Make this class the current one
+            @class_stack << [new_class, nclasses]
+            nclasses += 1 #We want to be able to unwind the stack in sync with the gedcom.
+                          #Hence we need to know how many classes we created at each point.
+          when :field
+            if do_this[DATA].class == Array #Then the value we are storing is given, rather than derived from the source file.
+              update_field(lineno, do_this[DATA][0], data_type, do_this[DATA][1])
+            else
+              update_field(lineno, do_this[DATA], data_type, tokens.data)
+            end
+          when :append_nl 
+            #We want to add a line terminator, then append the new data field from tokens
+            append_nl_field(lineno, do_this[DATA], data_type, tokens.data)
+          when :append 
+            #we want to append the data field in tokens, to the named field.
+            append_field(lineno, do_this[DATA], data_type, tokens.data)
+          when :xref 
+            #we want to record the reference (xref) from the token object.
+            add_to_index(lineno, do_this[DATA][0], do_this[DATA][1], tokens.xref)
+          when :key
+            #will only occur after a class that is the thing we want the xref index to point to. ie xref => new_class
+            create_index(lineno, do_this[DATA], tokens.xref, new_class )
+          when :pop
+            @class_stack.pop #In this instance, we want to remove only the last item, even if there were several added.
+          when :push
+            @class_stack << @class_stack.last #We need to have dummy entries when the gedcom has another level, but we build no class for it.
+        end
+      end
+    end    
+  end
+  
+  def defined(class_name)
+    ClassTracker::exists? class_name
+  end
+  
+  def define(class_name)
+    ClassTracker <<  class_name
+  end
+       
+end
+