gedcom 0.9.0 → 0.9.1

data/lib/gedcom/name_record.rb

@@ -27,6 +27,44 @@ require 'individual_attribute_record.rb'
 #  (6.0 and later) will likely apply a very different strategy to resolve this problem, possibly using a
 #  sophisticated parser and a name-knowledge database.
 #
+#==NAME_PERSONAL:=                                                        {Size=1:120}
+#  <TEXT> | /<TEXT>/ | <TEXT> /<TEXT>/ | /<TEXT>/ <TEXT> | <TEXT> /<TEXT>/ <TEXT>
+#
+#  The surname of an individual, if known, is enclosed between two slash (/) characters. The order of the
+#  name parts should be the order that the person would, by custom of their culture, have used when
+#  giving it to a recorder. Early versions of Personal Ancestral File and other products did not use the ®
+#  trailing slash when the surname was the last element of the name. If part of name is illegible, that part
+#  is indicated by an ellipsis (...). Capitalize the name of a person or place in the conventional
+#  manner—capitalize the first letter of each part and lowercase the other letters, unless conventional
+#  usage is otherwise. For example: McMurray.
+#  Examples:
+#    1 NAME William Lee                 (given name only or surname not known)
+#    1 NAME /Parry/                     (surname only)
+#    1 NAME William Lee /Parry/
+#    1 NAME William Lee /Mac Parry/     (both parts (Mac and Parry) are surname parts
+#    1 NAME William /Lee/ Parry         (surname imbedded in the name string)
+#    1 NAME William Lee /Pa.../
+#    1 NAME /HU/ Pan                    (Surname before firstname)
+#
+#==NAME_PIECE:=                                                           {Size=1:90}
+#  The piece of the name pertaining to the name part of interest. The surname part, the given name part,
+#  the name prefix part, or the name suffix part.
+#
+#==NAME_PIECE_GIVEN:=                                                     {Size=1:120}
+#  <NAME_PIECE> | <NAME_PIECE_GIVEN>, <NAME_PIECE>
+#
+#  Given name or earned name. Different given names are separated by a comma.
+#
+#==NAME_PIECE_NICKNAME:=                                                  {Size=1:30}
+#  <NAME_PIECE> | <NAME_PIECE_NICKNAME>, <NAME_PIECE>
+#  A descriptive or familiar name used in connection with one's proper name.
+#
+#==NAME_PIECE_PREFIX:=                                                    {Size=1:30}
+#  <NAME_PIECE> | <NAME_PIECE_PREFIX>, <NAME_PIECE>
+#
+#  Non indexing name piece that appears preceding the given name and surname parts. Different name
+#  prefix parts are separated by a comma.
+#
 #The attributes are all arrays for the level +1 tags/records. 
 #* Those ending in _ref are GEDCOM XREF index keys
 #* Those ending in _record are array of classes of that type.
@@ -54,5 +92,37 @@ class Name_record < Individual_attribute_record
     end
   end
   
+  #return the name as a string. It might be returned be the Individual_attribute_record#value method.
+  # or it might need to be contructed from the Name_record attributes. 99.9999% of all GEDCOM I have
+  # seen does not use the Name_record attributes, and if the do, they are required to fill in the name on the
+  # NAME line (NAME_PERSONAL value), so the value should be set. This helps, as the ordering of the surname and
+  # first names is not standard across all cultures.
+  def name
+    if (name = value) == nil
+      name = "" #could be what we return if none of the Name_record attributes are set
+      if @prefix
+        name += @prefix.first
+        name += ' ' if @given || @nickname || @surname_prefix || @surname || @suffix
+      end
+      if @given
+        name += @given.first  
+        name += ' ' if  @nickname || @surname_prefix || @surname || @suffix
+      end
+      if @nickname
+        name += '(' + @nickname.first + ')'  
+        name += ' ' if @surname_prefix || @surname || @suffix
+      end
+      if @surname_prefix
+        name += @surname_prefix.first
+        name += ' ' if  @surname || @suffix
+      end
+      if @surname
+        name += ( '/' + @surname.first + '/' ) 
+        name += ' ' if  @suffix
+      end
+      name += @suffix.first  if @suffix
+    end
+    return name.first
+  end
 end
 

data/lib/gedcom/place_record.rb

@@ -43,4 +43,10 @@ class Place_record < GEDCOMBase
     end
     super(level)
   end
+  
+  #When wanting just one place, the GEDCOM standard says to use the first PLAC record.
+  #If you want all the PLAC records, then use @place_value, which is an array PLAC's.
+  def place
+    @place_value ?  @place_value.first : ''
+  end
 end

data/lib/gedcom/transmission.rb

@@ -88,6 +88,15 @@ class  Transmission < TransmissionBase
       end
     end
   end
+  
+  def self_check
+    @family_record.each do |f|
+      f.self_check
+    end
+    @individual_record.each do |i|
+      i.self_check
+    end
+  end
 =begin
   def summary
     @@tabs = true

data/lib/gedcom/transmission_base.rb

@@ -6,6 +6,14 @@ require 'gedcom_base.rb'
 #the fields based on the parsed GEDCOM file.
 class TransmissionBase < GEDCOMBase
   
+  #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.
+  attr_accessor  :class_stack
+
+  #A hash to hold the indexes used in this transmission, each of which is also a hash (though that may change)
+  attr_accessor :indexes
+  
   ClassTracker <<  :TransmissionBase
  
   #new creates initializes the arrays for each of the GEDCOM level 0 record types.
@@ -27,8 +35,19 @@ class TransmissionBase < GEDCOMBase
     #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.
+    #Set up default indexes for the known level 0 types, so we can reference them even if they have no members.
+    @indexes = {
+      :individual => {},
+      :family => {},
+      :note => {},
+      :source => {},
+      :repository => {},
+      :multimedia => {},
+      :submitter => {},
+      :submission => {}
+    }
   end
 
   #summary() prints out the number of each level 0 record type the we have just parsed.
@@ -85,26 +104,30 @@ class TransmissionBase < GEDCOMBase
   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.
+  #If the record exists, then the data is added to the record array. Each record is an array, so we can have multiple instances of a TAG in a GEDCOM record.
+  #If the record doesn't exist, the record 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.
+  #* record 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}]")
+  def add_to_class_field(lineno, record, data)
+    #puts "#{lineno}: Add class instance '#{data.class}' to record #{record} of #{@class_stack.last[0]}"
+    if @class_stack.last[0].class.method_defined?(record) == false
+      #record is missing from the class, so add it using attr_accessor, thus getting the get and set methods.
+      #Unlikely to ever see this case, as we precreated all fields for all class needed for GEDCOM 5.5
+      p "#{lineno}: create a record called #{record} in class #{@class_stack.last[0].class.to_s}" 
+      @class_stack.last[0].class.class_eval("attr_accessor :#{record}")
+      #p "#{lineno}: Add the class #{data.class.to_s} as an array, to the record #{record} in class #{@class_stack.last[0].class.to_s}" 
+      @class_stack.last[0].send( record.to_s + "=", data ? [ data ] : []) #Much faster than eval("@class_stack.last[0].#{record} = [#{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}" 
+      #record exists, get a reference to it, so we can just add the data to the record's data array.
+      if (a = @class_stack.last[0].send( record ) ) != nil
+        #This way is much faster than eval("@class_stack.last[0].#{record} << #{data}")
+        #p "#{lineno}: Add the class #{data.class.to_s} to the record #{record}[] 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 ] : [] )
+        #Got a reference to the attribute in the class, but no value stored as yet.
+        #p "#{lineno}: Add the class #{data.class.to_s} as an array, to the record #{record} in class #{@class_stack.last[0].class.to_s}" 
+        @class_stack.last[0].send( record.to_s + "=", data ? [ data ] : [] )
       end
     end
   end
@@ -118,54 +141,70 @@ class TransmissionBase < GEDCOMBase
     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.
+  #update_field() is part of the parsing process, 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
+  #* data_type gives hints to help validate the data (which we don't yet do).
   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)
+    add_to_class_field(lineno, field, data == nil ? nil : GedString.new(data))
+  end
+
+  #append_sp_field is part of the parsing process, and inserts a ' ' character in front of the data, then calls append_to_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
+  #* data_type gives hints to help validate the data (which we don't yet do).
+  def append_sp_field(lineno, field, data_type, data)
+    #p "#{lineno}: Append data ' #{data}' to field #{field} of #{@class_stack.last[0]}"
+    the_data = [" "] #want to add a space to the existing data, before adding it to the string.
+    the_data += data if data != nil #add the new data only if it is not null.
+    append_to_field(lineno, field, data_type, the_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().
+  #append_nl_field is part of the parsing process, and inserts a '\n' character in front of the data, then calls append_to_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
+  #* data_type gives hints to help validate the data (which we don't yet do).
   def append_nl_field(lineno, field, data_type, data)
-    #p "#{lineno}: Append data 'nl + #{data}' to field #{field} of #{@class_stack.last[0]}"
+    #p "#{lineno}: Append data '\n#{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)
+    append_to_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.
+  #append_to_field is part of the parsing process, and adds the data to the end of the field's array.
+  #Shared code between append_sp_field and append_nl_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_field(lineno, field, data_type, data)
+  #* data_type gives hints to help validate the data (which we don't yet do).
+  def append_to_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 data != nil  #Only bother if we have some data to append
+        if ( a = @class_stack.last[0].send( field ) ) != nil  #The field is not nil, then we need to add to the last value in the array
           if a != [] #The field is not an empty array
-            if a[-1] != nil #The last element is not null
+            if a[-1] != nil #The last element is not null, so we append to it.
               #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
+              a[-1] << GedString.new(data) 
+            else #The last element is null, so we replace is, rather than append to it.
               #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
+              a[-1] = GedString.new(data)
             end
-          else #Was an empty array, so add the element.
-            a[0] = data
+          else #Was an empty array, the data will be the first member in the array.
+            a[0] = GedString.new(data)
           end
-        else #The field was null
+        else #The field was null. We need to set the first value to our data value, in an array.
           #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])
+          @class_stack.last[0].send( field.to_s + '=',  [ GedString.new(data) ] )
         end
       end
     rescue => exception
-      p "#{exception} : Append data '#{data}' to field '#{field}' of class '#{@class_stack.last[0]}'"
+      p "#{exception} : Append data '#{data}' to field '#{field}' of class '#{@class_stack.last[0].class}'"
       raise exception
     end
   end
@@ -194,7 +233,9 @@ class TransmissionBase < GEDCOMBase
   #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] )
+    #There are many cases where there can be multiple records of the same GEDCOM type, in the parent record, so we store these in an array.
+    #e.g. CHIL xrefs can occur multiple times in FAM record.
+     add_to_class_field(lineno, field_name, Xref.new(index_name, *key) )
   end
 
   #action_handler process the actions in the GedcomParser::TAGS hash, creating classes and populating attributes.
@@ -222,7 +263,7 @@ class TransmissionBase < GEDCOMBase
           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 this instance to an Array of records as an attribute named new_class of the current class.
             add_to_class_field(lineno, do_this[DATA], new_class)
             #Make this class the current one
             @class_stack << [new_class, nclasses]
@@ -236,15 +277,18 @@ class TransmissionBase < GEDCOMBase
             end
           when :append_nl 
             #We want to add a line terminator, then append the new data field from tokens
+            #e.g. We do this with CONT lines being appended to a NOTE.
             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)
+            #e.g. We do this with CONC lines being added to a NOTE.
+            append_sp_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
+            #All the level 0 indexes should exist already, as it helps to have them, even if they are empty.
             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.

data/lib/gedcom/xref.rb

@@ -0,0 +1,8 @@
+#Utility class just to make referencing xrefs clearer.
+
+class Xref
+  attr_accessor :index, :xref_value
+  def initialize(index, xref_value)
+    @index, @xref_value = index, xref_value
+  end
+end

data/test/lds_gedcom_test.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+#Or 1.9 version at
+#!/usr/local/bin/ruby
+require '../lib/gedcom.rb'
+require 'ruby_version.rb'
+
+
+
+puts RubyVersion.to_s
+
+#Parses the LDS GEDCOM test files and them dumps them back out as GEDCOM.
+#This allows me to test for errors in parsing and output. The two files will
+#not be an exact match, as the NOTE/CONT/CONC line breaks could be different
+#and user defined tags will get converted to NOTES.
+
+puts "parse TGC551LF.ged"
+if RubyVersion.have_at_least_version?(1,9)
+  g = Gedcom.file("../test_data/TGC551LF.ged", "r:ASCII-8BIT") #OK with LF line endings.
+else
+  g = Gedcom.file("../test_data/TGC551LF.ged", "r") #OK with LF line endings.
+end
+g.transmissions[0].summary
+puts 
+
+g.transmissions[0].self_check
+
+#puts g.transmissions[0].header_record[0].to_s
+puts
+#f = g.transmissions[0].find(:individual,"PERSON1")
+#puts f.to_s
+
+#puts "parse TGC55CLF.ged"
+#g.file("../test_data/TGC55CLF.ged", "r:ASCII-8BIT") #Ok with CR LF line endings.
+#g.transmissions[1].summary
+#puts 
+
+#g.file("../test_data/TGC551.ged")  #fails to find CR line breaks, as native system uses LF, so reports parse error.
+#g.file("../test_data/TGC55C.ged") #fails to find CR line breaks,  as native system uses LF, so reports parse error.
+
+#print the parsed file to see if it matches the source file.
+#Note CONT and CONC breaks may end up in different places
+#Note Order of TAGS at the same level may be different
+#Note User TAGS are output as Notes.
+if RubyVersion.have_at_least_version?(1,9)
+  File.open( "../test_data/TGC551LF.out", "w:ASCII-8BIT") do |file|
+    file.print g.transmissions[0].to_gedcom
+  end
+else
+  File.open( "../test_data/TGC551LF.out", "w") do |file|
+    file.print g.transmissions[0].to_gedcom
+  end
+end
+
+#File.open( "../test_data/TGC55CLF.out", "w:ASCII-8BIT") do |file|
+#  file.print g.transmissions[1].to_gedcom
+#end
+puts "\nComplete"
+c = Chart.new
+#puts c.output_pedigree_name( f, 10, nil, nil, Bit.new, '', '', nil, '', 0 )
+
+

data/test/ruby_version.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+
+class RubyVersion
+  #self.have_version tests that the versien of RUBY is the one we want.
+  def self.have_version?(major, minor, update = nil, build = nil)
+    v = RUBY_VERSION.split('.')
+    if major == v[0].to_i && minor == v[1].to_i
+      return false if update != nil && update != v[2].to_i
+      return false if build != nil && build !=  RUBY_PATCHLEVEL.to_i
+      return true
+    else
+      return false
+    end
+  end
+  
+  #self.have_at_least_version tests that the versien of RUBY is newer than the one we want.
+  def self.have_at_least_version?(major, minor, update = nil, build = nil)
+    v = RUBY_VERSION.split('.')
+    if major == v[0].to_i #Could true
+      if minor == v[1].to_i #Could be true
+        if update != nil #Being asked to test update level
+          if update == v[2].to_i #Could be true
+            if build != nil #Being asked to test the build version
+              return build <= RUBY_PATCHLEVEL.to_i #have at least the required patch level.
+            end
+            return true #update was equal
+          end
+          return update < v[2].to_i #current version is newer
+        end
+        return true #major and minor was equal.
+      end
+      return minor < v[1].to_i #true if current version is newer
+    end
+    return major < v[0].to_i #true, if current version is newer
+  end
+  
+  def self.to_s
+    "RUBY #{RUBY_VERSION} Build #{RUBY_PATCHLEVEL}"
+  end
+end
+
+#puts RubyVersion.to_s
+#puts RubyVersion.have_version?(1,9)