gedcom 0.9.0 → 0.9.1

data/History.txt

@@ -1,4 +1,10 @@
-=== 0.9.0 / 2009-03-14
+=== 0.9.1 / 2012-19-27
+
+* transcription of code from original C source base.
+* Bug fix to GEDCOMBase.xref_check, which didn't qualify index lookup when printing an error message.
+* Added Transmission.self_check, which calls new FamilyRecord.self_check and IndividualRecord.self_check
+  Checks the gedcom file FAMC, FAMS, HUSB, WIFE, CHIL and SUBM xrefs resolve to valid records.
+  Required adding IndividualRecord.child? and IndividualRecord.spouse? for tests.
+  Fixed bug in IndividualRecord.spouses and IndividualRecord.parents_family as neither worked and were used by tests.
 
-* transcription of code from original Rails source base.
 

data/Manifest.txt

@@ -17,6 +17,7 @@ lib/gedcom/event_record.rb
 lib/gedcom/events_list_record.rb
 lib/gedcom/families_individuals.rb
 lib/gedcom/family_record.rb
+lib/gedcom/ged_string.rb
 lib/gedcom/gedcom_all.rb
 lib/gedcom/gedcom_base.rb
 lib/gedcom/gedcom_record.rb
@@ -45,12 +46,15 @@ lib/gedcom/text_record.rb
 lib/gedcom/trailer_record.rb
 lib/gedcom/transmission.rb
 lib/gedcom/transmission_base.rb
+lib/gedcom/xref.rb
 lib/gedcom.rb
 lib/parser/class_tracker.rb
 lib/parser/ged_line.rb
 lib/parser/gedcom_parser.rb
 lib/parser/instruction.rb
 lib/parser/parse_state.rb
+test/ruby_version.rb
+test/lds_gedcom_test.rb
 test/test_gedcom.rb
 test_data/Document.RTF
 test_data/Document.tex

data/README.txt

@@ -15,7 +15,7 @@ unknown tags hierarchies as a Note class.
 * CR line termination causes issues for systems with native LF line termination (CRLF is fine).
 * Dates are currently just strings, but I want to parse these and test their validatity. 
   This is not as easy as it may seem at first, as dates may be in many formats, 
-  they may be partial, or may actually be strings decribing the date. 
+  they may be partial, or may actually be strings describing the date. 
 * For my own use, I bend the GEDCOM 5.5 standard by allowing the reading of the following types in non-standard ways. 
   These will not affect the reading and writing of valid GEDCOM 5.5.
 * * 'NOTE' type to appear in places it is not defined to exist in GEDCOM.

data/Rakefile

@@ -2,12 +2,20 @@
 
 require 'rubygems'
 require 'hoe'
-require 'lib/gedcom.rb'
+#require 'lib/gedcom.rb'
 
-Hoe.new('gedcom', Gedcom::VERSION) do |p|
-  p.rubyforge_name = "gedcom" 
-  p.developer( "Rob Burrowes","rob@burrowes.org")
-  p.remote_rdoc_dir = '' # Release to root
+Hoe.spec 'gedcom' do 
+  self.rubyforge_name = 'gedcom'
+  developer 'Rob Burrowes', 'r.burrowes@auckland.ac.nz'
+  remote_rdoc_dir = '' # Release to root
+  #extra_deps << 'whatevs'
 end
 
+#Old V1 format.
+#Hoe.new('gedcom', Gedcom::VERSION) do |p|
+#  p.rubyforge_name = "gedcom" 
+#  p.developer( "Rob Burrowes","rob@burrowes.org")
+#  p.remote_rdoc_dir = '' # Release to root
+#end
+
 # vim: syntax=Ruby

data/lib/gedcom.rb

@@ -58,11 +58,13 @@ end
 
 $: << "#{path(__FILE__)}gedcom"
 $: << "#{path(__FILE__)}parser"
+$: << "#{path(__FILE__)}chart"
 
 require 'gedcom_parser.rb'
+require 'chart.rb'
 
 class Gedcom
-  VERSION = '0.9.0'
+  VERSION = '0.9.1'
   attr_accessor :transmissions
   
   def initialize(transmission = nil)

data/lib/gedcom/association_record.rb

@@ -59,9 +59,9 @@ class Association_record < 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.
   #Association_records default to :individual, but the TYPE field can override this.
-  def xref_check(level, tag, index, xref)
+  def xref_check(level, tag, xref)
     asso_index = case @associated_record_tag
-    when nil then index
+    when nil then xref.index #this should be the default :individual
     when 'FAM'  then :family
     when 'INDI' then :individual
     when 'NOTE' then :note
@@ -73,7 +73,7 @@ class Association_record < GEDCOMBase
     else :individual #which will be the default individual index.
     end
     
-    super(level, tag, asso_index, xref)
+    super(level, tag, Xref.new(asso_index, xref.xref_value) )
   end
 end
 

data/lib/gedcom/date_record.rb

@@ -203,4 +203,22 @@ class Date_record < GEDCOMBase
                     [ :walk,  nil, :note_citation_record]
                   ]
   end
+  
+  #If you want just one date, then this returns the first DATE record (probably the only one).
+  #GEDCOM says that this should be the most vaild record. If you need all the dates, use date_value,
+  #which will give you an array of DATE values.
+  def date
+    if @date_value
+      @date_value.first
+    else
+      ''
+    end
+  end
+
+  #If you want just one date, then this returns the first TIME record (probably the only one).
+  #GEDCOM says that this should be the most vaild record. If you need all the dates, use date_value,
+  #which will give you an array of TIME values.
+  def time
+    @time_value.first
+  end
 end

data/lib/gedcom/event_record.rb

@@ -244,13 +244,23 @@ class Event_record < GEDCOMBase
     end
   end
   
-  def is_event(tag)
-    @event_type.to_s == tag
+  def is_event?(tag)
+    @event_type.first.to_s == tag #all attributes are arrays, even the single value ones.
   end
   
   def date
     if @date_record != nil
-      @date_record[0].date
+      @date_record.first.date
+    else
+      nil
+    end
+  end
+  
+  #where the event took place. We are reporting only the first place as a string. If you want all the places recorded,
+  #then you should access Event_record#place_record, which will return an array of PLAC records in the event. 
+  def place
+    if @place_record != nil
+      @place_record.first.place
     else
       nil
     end

data/lib/gedcom/families_individuals.rb

@@ -61,7 +61,7 @@ class Families_individuals < GEDCOMBase
   
   def parents_family
     if @parents_family_ref != nil
-      find(:family,  @parents_family_ref[0])
+      find(:family,  @parents_family_ref)
     else
       nil
     end
@@ -69,7 +69,7 @@ class Families_individuals < GEDCOMBase
   
   def own_family
     if @family_ref != nil
-      find(:family,  @family_ref[0])
+      find(:family,  @family_ref)
     else
       nil
     end

data/lib/gedcom/family_record.rb

@@ -44,7 +44,7 @@ class Family_record < GEDCOMBase
   attr_accessor :note_citation_record, :refn_record, :automated_record_id, :change_date_record
 
   ClassTracker <<  :Family_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)
@@ -70,20 +70,182 @@ class Family_record < GEDCOMBase
     @family_ref
   end
   
+  #There should only ever be one husband record in a Family_record. If a women has
+  #multiple husbands, as some cultures do, then each should be in their own FAM record.
+  #The reasoning is that we are recording parentage, not marriages, so we want to be 
+  #able to uniquely identify which husband is the actual parent (not that we could be
+  #that certain in the case of polygamy). The term husband is also used loosely. It
+  #refers to the father of children, not necessarily a spouse. 
   def husband
     if @husband_ref != nil
-      find(@husband_ref[0], @husband_ref[1])
+      find(@husband_ref.first.index, @husband_ref.first.xref_value)
     else
       nil
     end
   end
   
+  #There should only ever be one wife record in a Family_record. If a man has
+  #multiple wives, as some cultures do, then each should be in their own FAM record.
+  #The reasoning is that we are recording parentage, not marriages, so we want to be 
+  #able to uniquely identify which wife is the actual parent. The term wife is used
+  #fairly loosely. It refers to the mother of the children, not necessarily a spouse.
   def wife
     if @wife_ref != nil
-      find(@wife_ref[0], @wife_ref[1])
+      find(@wife_ref.first.index, @wife_ref.first.xref_value)
     else
       nil
     end
   end
   
+  #Returns an array of children, or if a block is present, yields them one by one.
+  def children
+    if @child_ref != nil
+      children = []
+      @child_ref.each do |c| 
+        if (child = find(c.index, c.xref_value)) != nil
+          yield child if block_given?
+          children << c
+        end
+      end
+      return children if children.length > 0
+    end
+    return nil
+  end
+  
+  #Event looks in the Family_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 Family_record. 
+  #
+  #If a block is given, then yields each event to the block.
+  def event(type)
+    if @event_record != nil
+      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('ENGA')
+  #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 engagement(&p)
+    if block_given? then event('ENGA',&p) else event('ENGA') end
+  end
+  
+  #Short hand for event('MARB')
+  #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_bann(&p)
+    if block_given? then event('MARB',&p) else event('MARB') end
+  end
+  
+  #Short hand for event('MARL')
+  #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_license(&p)
+    if block_given? then event('MARL',&p) else event('MARL') end
+  end
+  
+  #Short hand for event('MARC')
+  #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_contract(&p)
+    if block_given? then event('MARC',&p) else event('MARC') end
+  end
+  
+  #Short hand for event('MARS')
+  #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_settlement(&p)
+    if block_given? then event('MARS',&p) else event('MARS') end
+  end
+  
+  #Short hand for event('MARR')
+  #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(&p)
+    if block_given? then event('MARR',&p) else event('MARR') end
+  end
+  
+  #Short hand for event('ANUL')
+  #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 annulment(&p)
+    if block_given? then event('ANUL',&p) else event('ANUL') end
+  end
+  
+  #Short hand for event('DIVF')
+  #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 divorce_filed(&p)
+    if block_given? then event('DIVF',&p) else event('DIVF') end
+  end
+  
+  #Short hand for event('DIV')
+  #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 divorce(&p)
+    if block_given? then event('DIV',&p) else event('DIV') 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
+  
+  #Check the xrefs are valid.
+  def self_check
+    if @husband_ref != nil
+      puts "More than one HUSB? in FAM #{@family_ref.first.xref_value}" if @husband_ref.length > 1  #should be just one
+      @husband_ref.each do |h| 
+        if (husb = find(h.index, h.xref_value))  == nil
+          puts "Missing INDI record #{h.xref_value} for HUSB in FAM #{@family_ref.first.xref_value}"
+        else
+          puts "Husband's INDI #{h.xref_value} record doesn't have FAMS #{@family_ref.first.xref_value}" if husb.spouse?(self) == false
+          if (sex = husb.sex) != nil
+            sex.each do |s| 
+              puts "Husband Female? INDI #{h.xref_value}, FAMS #{@family_ref.first.xref_value}" if s.value.first == 'F' 
+            end
+          end
+        end
+      end
+    end
+    if @wife_ref != nil
+      puts "More than one WIFE? in FAM #{@family_ref.first.xref_value}" if @wife_ref.length > 1  #should be just one
+      @wife_ref.each do |w| 
+        if (wife = find(w.index, w.xref_value))  == nil
+          puts "Missing INDI record #{w.xref_value} for WIFE in FAM #{@family_ref.first.xref_value}" 
+        else
+          puts "Wife's INDI #{w.xref_value} record doesn't have FAMS #{@family_ref.first.xref_value}" if wife.spouse?(self) == false
+          if (sex = wife.sex) != nil
+            sex.each { |s| puts "Wife Male? INDI #{w.xref_value}, FAMS #{@family_ref.first.xref_value}" if s.value.first == 'M' }
+          end
+        end
+      end 
+    end
+    if @child_ref != nil
+      #1..many Children
+      @child_ref.each  do |c| 
+        if (child = find(c.index, c.xref_value))  == nil
+          puts "Missing INDI record for #{c.xref_value} for CHIL in FAM #{@family_ref.first.xref_value}" 
+        else
+          puts "Child's INDI #{c.xref_value} record doesn't have FAMC #{@family_ref.first.xref_value}" if child.child?(self) == false
+        end
+      end
+    end
+    if @submitter_ref != nil
+      @submitter_ref.each  do |s| 
+        puts "Missing SUBM record for #{s.xref_value} in FAM #{@family_ref.first.xref_value}" if find(s.index, s.xref_value)  == nil
+      end
+    end
+  end
+  
 end

data/lib/gedcom/ged_string.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby1.9
+#Our parser tokenize strings into word arrays. This is helpful in word wrapping for CONT and CONC,
+#but pretty silly for most other uses. I'm still thinking about the best way to deal with this.
+#
+#The current thought is to flatten the array and store the value as a space separated string, and tokenize
+#tokenize it again if we output GEDCOM. Most of the time, this is what we want, and it makes dealing with
+#Data bases easier too.
+
+class GedString < String
+  
+  #takes a word array from the parser and creates a space separated string.
+  #Also excepts a String, assigning this to the 
+  def initialize(word_array)
+    if(word_array.class == String)
+      super word_array
+    elsif(word_array.class == Array)
+      super(word_array.inject('') do |v, w|
+        if v == '' 
+          w 
+        elsif w == "\n" || v[-1,1] == "\n"
+          v + w
+        else
+          v + ' ' + w
+        end
+      end 
+      )
+    else
+      raise "GedString word_array passed in as #{word_array.class}"
+    end
+  end
+  
+  #yields the string word by word. Line separators in the string will also be yielded as words.
+  def each_word
+    self.gsub(/\n/," \n ").split(/ /).each { |w| yield w }
+  end
+  
+  #yields the string word by word. Line separators in the string will also be yielded as words.
+  def each_word_with_index
+    self.gsub(/\n/," \n ").split(/ /).each_with_index { |w,i| yield(w, i) }
+  end
+    
+  #We aren't an array, but to simplify some code, the method each is defined to return our 1 value.  
+  def each
+    yield self
+  end
+  
+  alias each_with_index each_word_with_index
+  
+end