gedcom 0.9.0

data/lib/gedcom/multimedia_record.rb

@@ -0,0 +1,72 @@
+require 'gedcom_base.rb'
+
+#Internal representation of the GEDCOM OBJE record type
+#GEDCOM has both inline OBJE records and references to level 0 OBJE records.
+#both are stored here and referenced through a Multimedia_citation_record class.
+#
+#=MULTIMEDIA_RECORD:=
+#  0 @XREF:OBJE@ OBJE                     {0:M}
+#    +1 FORM <MULTIMEDIA_FORMAT>          {1:1}
+#    +1 TITL <DESCRIPTIVE_TITLE>          {0:1}
+#    +1 <<NOTE_STRUCTURE>>                {0:M}
+#    +1 BLOB                              {1:1}
+#      +2 CONT <ENCODED_MULTIMEDIA_LINE>  {1:M}
+#    +1 OBJE @<XREF:OBJE>@                {0:1} (chain to continued object)
+#    +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}
+#
+#  Large whole multimedia objects embedded in a GEDCOM file would break some systems. For this
+#  purpose, large multimedia files should be divided into smaller multimedia records by using the
+#  subordinate OBJE tag to chain to the next <MULTIMEDIA_RECORD> fragment. This will allow
+#  GEDCOM records to be maintained below the 32K limit for use in systems with limited resources.
+#
+#  n OBJE                                 {1:1} is a reference to an external file, rather than inline.
+#    +1 FORM <MULTIMEDIA_FORMAT>          {1:1}
+#    +1 TITL <DESCRIPTIVE_TITLE>          {0:1}
+#    +1 FILE <MULTIMEDIA_FILE_REFERENCE>  {1:1}
+#    +1 <<NOTE_STRUCTURE>>                {0:M}
+#
+#  This second method allows the GEDCOM context to be connected to an external multimedia file.
+#  GEDCOM defines this in the MULTIMEDIA_LINK definition, but I have put it into the Multimedia_record.
+#  as the attributes are the same, except BLOB becomes FILE. A Multimedia_citation_record is also created
+#  to make all references to Multimedia records consistent.
+#
+#  This process is only managed by GEDCOM in the sense that the appropriate file name is included in
+#  the GEDCOM file in context, but the maintenance and transfer of the multimedia files are external to
+#  GEDCOM. The parser can just treat this as a comment and doesn't check for the file being present.
+#
+#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.
+#* The remainder are arrays of attributes that could be present in this record.
+class Multimedia_record < GEDCOMBase
+  attr_accessor :multimedia_ref, :format, :title, :encoded_line_record, :next_multimedia_ref, :filename
+  attr_accessor :refn_record, :automated_record_id, :note_citation_record, :change_date_record
+
+  ClassTracker <<  :Multimedia_record
+  
+  def to_gedcom(level=0)
+    
+    if @multimedia_ref != nil 
+      @this_level =  [ [:xref, "OBJE", :multimedia_ref]]
+    else
+      @this_level =  [ [:nodata, "OBJE", nil] ]
+    end
+
+    @sub_level =  [#level 1
+                    [:print, "TITL",    :title ],
+                    [:print, "FORM",    :format ],
+                    [:walk, nil,    :encoded_line_record ],
+                    [:xref, nil,     :next_multimedia_ref ],
+                    [:print, "FILE",    :filename ],
+                    [:walk, nil,    :note_citation_record ],
+                    [:walk, nil,     :refn_record ],
+                    [:print, "RIN",    :automated_record_id ],
+                    [:walk, nil,    :change_date_record ],
+                  ]
+    
+    super(level)
+  end
+end

data/lib/gedcom/name_record.rb

@@ -0,0 +1,58 @@
+require 'gedcom_base.rb'
+require 'individual_attribute_record.rb'
+
+#Internal representation of the GEDCOM NAME record as described under PERSONAL_NAME_STRUCTURE
+#This sub-classes Individual_attribute_record, which in turn sub-classes Event_record. This may
+#seem odd, but they share most class attributes and event records can be attached to most attributes.
+#
+#=PERSONAL_NAME_STRUCTURE:=
+#  n NAME <NAME_PERSONAL>                 {1:1}
+#    +1 NPFX <NAME_PIECE_PREFIX>          {0:1}
+#    +1 GIVN <NAME_PIECE_GIVEN>           {0:1}
+#    +1 NICK <NAME_PIECE_NICKNAME>        {0:1}
+#    +1 SPFX <NAME_PIECE_SURNAME_PREFIX   {0:1}
+#    +1 SURN <NAME_PIECE_SURNAME>         {0:1}
+#    +1 NSFX <NAME_PIECE_SUFFIX>          {0:1}
+#    +1 <<SOURCE_CITATION>>               {0:M}
+#    +1 <<NOTE_STRUCTURE>>                {0:M}
+#
+#  The name value is formed in the manner the name is normally spoken, with the given name and family
+#   name (surname) separated by slashes (/). (See <NAME_PERSONAL>, page 45.) Based on the
+#  dynamic nature or unknown compositions of naming conventions, it is difficult to provide more
+#  detailed name piece structure to handle every case. The NPFX, GIVN, NICK, SPFX, SURN, and
+#  NSFX tags are provided optionally for systems that cannot operate effectively with less structured
+#  information. For current future compatibility, all systems must construct their names based on the
+#  <NAME_PERSONAL> structure. Those using the optional name pieces should assume that few
+#  systems will process them, and most will not provide the name pieces. Future GEDCOM releases
+#  (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.
+#
+#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.
+#* The remainder are arrays of attributes that could be present in this record.
+class Name_record < Individual_attribute_record
+  attr_accessor :prefix, :given, :nickname, :surname_prefix, :surname, :suffix
+  ClassTracker <<  :Name_record
+  
+  def initialize(*a)
+    super(*a)
+     @sub_level = [
+                       [:print, "NPFX",    :prefix ],
+                       [:print, "GIVN",    :given ],
+                       [:print, "NICK",    :nickname ],
+                       [:print, "SPFX",    :surname_prefix ],
+                       [:print, "SURN",    :surname ],
+                       [:print, "NSFX",    :suffix ],
+                   ] + @sub_level
+  end
+
+  def event_tag(tag)
+    case tag
+    when "NAME" then tag
+    else super(tag)
+    end
+  end
+  
+end
+

data/lib/gedcom/note_citation_record.rb

@@ -0,0 +1,37 @@
+require 'gedcom_base.rb'
+
+#Internal representation of a reference to a GEDCOM NOTE_STRUCTURE, or reference to a Level 0 NOTE.
+#NOTE types can be inline, references to Level 0 NOTEs, or used to store user defined tags. 
+#All NOTES are stored in the Note_record closs and referenced through this class.
+#
+#=NOTE_STRUCTURE:=
+#  n NOTE @<XREF:NOTE>@       {1:1}
+#    +1 <<SOURCE_CITATION>>   {0:M}
+#
+# The inline NOTE, also described as a NOTE_STRUCTURE in the GEDCOM standard, is stored in a Note_record.
+#
+#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.
+#* The remainder are arrays of attributes that could be present in this record.
+class Note_citation_record < GEDCOMBase
+  attr_accessor :note_ref, :note_record, :source_citation_record
+
+  ClassTracker <<  :Note_citation_record
+  
+  def to_gedcom(level=0)
+    if @note_ref != nil
+      @this_level = [ [:xref, "NOTE", :note_ref] ]
+      @sub_level =  [#level 1
+                      [:walk, nil,    :source_citation_record ],
+                      [:walk, nil, :note_record] 
+                    ]
+    else
+      @this_level = [ [:walk, nil, :note_record] ]
+      @sub_level =  [#level 1
+                    ]
+    end
+    super(level)
+  end
+end
+

data/lib/gedcom/note_record.rb

@@ -0,0 +1,61 @@
+require 'gedcom_base.rb'
+
+#Internal representation of the GEDCOM NOTE record type
+#Both inline and level 0 NOTEs are stored here and both are referenced through the Note_citation_record class. 
+#NOTES are also used to store user defined tags, so can appear in places the GEDCOM standard doesn't specify NOTEs.
+#
+#=NOTE_RECORD:=
+#  0 @<XREF:NOTE>@ NOTE <SUBMITTER_TEXT>    {0:M}
+#    +1 [ CONC | CONT] <SUBMITTER_TEXT>     {0:M}
+#    +1 <<SOURCE_CITATION>>                 {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}
+#
+#  I also recognise notes in this record, so I can handle user tags as notes.
+#    +1 <<NOTE_STRUCTURE>>                  {0:M}
+#
+#=NOTE_STRUCTURE:= (The inline NOTE, defined in NOTE_STRUCTURE is also stored here)
+#    n NOTE [SUBMITTER_TEXT> | <NULL>] {1:1} p.51
+#      +1 [ CONC | CONT ] <SUBMITTER_TEXT> {0:M}
+#      +1 <<SOURCE_CITATION>> {0:M}
+#
+#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.
+#* The remainder are arrays of attributes that could be present in the NOTE records.
+class Note_record < GEDCOMBase
+  attr_accessor :note_ref, :note, :source_citation_record
+  attr_accessor :restriction, :refn_record, :automated_record_id, :change_date_record
+  attr_accessor :note_citation_record
+  
+  ClassTracker <<  :Note_record
+  
+  def to_gedcom(level=0)
+    if @note_ref != nil
+      @this_level = [ [:xref, "NOTE", :note_ref] ]
+      @sub_level =  [ #level + 1
+                      [:conc, "CONC", :note],
+                      [:print, "RESN", :restriction ],
+                      [:walk, nil,    :source_citation_record ],
+                      [:walk, nil,    :note_citation_record ],
+                      [:walk, nil, :refn_record ],
+                      [:print, "RIN",  :automated_record_id ],
+                      [:walk, nil,    :change_date_record],
+                    ] 
+    else
+      @this_level = [ [:cont, "NOTE", :note] ]
+      @sub_level =  [ #level + 1
+                      [:print, "RESN", :restriction ],
+                      [:walk, nil,    :source_citation_record ],
+                      [:walk, nil,    :note_citation_record ],
+                      [:walk, nil, :refn_record ],
+                      [:print, "RIN",  :automated_record_id ],
+                      [:walk, nil,    :change_date_record],
+                    ]
+    end
+    super(level)
+  end
+end
+

data/lib/gedcom/place_record.rb

@@ -0,0 +1,46 @@
+require 'gedcom_base.rb'
+
+#Internal representation of the GEDCOM PLAC record type. Sub-record of HEAD and EVENT
+#
+#=PLACE_STRUCTURE:=
+#  n PLAC <PLACE_VALUE>         {1:1}
+#    +1 FORM <PLACE_HIERARCHY>  {0:1}
+#    +1 <<SOURCE_CITATION>>     {0:M}
+#    +1 <<NOTE_STRUCTURE>>      {0:M}
+#
+#==PLACE_VALUE:= {Size=1:120}
+# 
+#  <TEXT> | <TEXT>, <PLACE_VALUE>
+#
+#  The jurisdictional name of the place where the event took place. Jurisdictions are separated by
+#  commas, for example, "Cove, Cache, Utah, USA." If the actual jurisdictional names of these places
+#  have been identified, they can be shown using a PLAC.FORM structure either in the HEADER or in
+#  the event structure. (See <PLACE_HIERARCHY>, page 47.)
+#
+#The attributes are all arrays for the level +1 tags/records. 
+#* Those ending in _record are array of classes of that type.
+#* The remainder are arrays of attributes that could be present in the PLAC records.
+class Place_record < GEDCOMBase
+  attr_accessor :place_value, :place_hierachy, :source_citation_record, :note_citation_record
+
+  ClassTracker <<  :Place_record
+  
+  def to_gedcom(level=0)
+    if @place_value != nil
+      @this_level = [  [:print, "PLAC", :place_value] ]
+      @sub_level =  [ #level + 1
+                      [:print, "FORM", :place_hierachy],
+                      [:walk, nil,    :source_citation_record],
+                      [:walk, nil,    :note_citation_record],
+                    ]
+    else
+      @this_level = [  [:nodata, "PLAC", nil] ]
+      @sub_level =  [ #level + 1
+                      [:print, "FORM", :place_hierachy],
+                      [:walk, nil,    :source_citation_record],
+                      [:walk, nil,    :note_citation_record],
+                    ]
+    end
+    super(level)
+  end
+end

data/lib/gedcom/refn_record.rb

@@ -0,0 +1,32 @@
+require 'gedcom_base.rb'
+
+#Internal representation of the GEDCOM REFN record type. A sub-record of the level 0 INDI,FAM,OBJE,NOTE,REPO,SOUR records.
+#
+#=REFN {REFERENCE}:=
+#
+#    n REFN <USER_REFERENCE_NUMBER> {0:M}
+#      +1 TYPE <USER_REFERENCE_TYPE> {0:1}
+#
+#  A description or number used to identify an item for filing, storage, or other reference purposes.
+#
+#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.
+#* The remainder are arrays of attributes that could be present in the REFN records.
+class Refn_record < GEDCOMBase
+  attr_accessor :ref_type, :user_reference_number
+  attr_accessor :note_citation_record
+
+  ClassTracker <<  :Refn_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 =  [ [:print, "REFN", :user_reference_number] ]  
+    @sub_level =  [ #level + 1
+                    [:print, "TYPE", :ref_type],
+                    [:walk, nil,  :note_citation_record],
+                  ]
+  end 
+end
+

data/lib/gedcom/repository_caln.rb

@@ -0,0 +1,33 @@
+require 'gedcom_base.rb'
+
+#Internal representation of the GEDCOM CALN record type, a sub-record of Repository_citation_record.
+#
+#=SOURCE_CALL_NUMBER:=
+#  -1 REPO @XREF:REPO@               {1:1} Parent record
+#    ...
+#    n CALN <SOURCE_CALL_NUMBER>   {0:M} ** CALN record **
+#      +1 MEDI <SOURCE_MEDIA_TYPE>    {0:1}
+#
+#  The number used by a repository to identify the specific items in its collections.
+#
+#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.
+#* The remainder are arrays of attributes that could be present in the CALN records.
+class Repository_caln < GEDCOMBase
+  attr_accessor :media_type, :call_number
+  attr_accessor :note_citation_record
+
+  ClassTracker <<  :Repository_caln
+  
+  #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 =  [ [:print, "CALN", :call_number] ]  
+    @sub_level =  [ #level + 1
+                    [:print, "MEDI",  :media_type],
+                    [:walk, nil,   :note_citation_record],
+                  ]
+  end 
+end
+

data/lib/gedcom/repository_citation_record.rb

@@ -0,0 +1,43 @@
+require 'gedcom_base.rb'
+
+#Internal representation of a reference to the GEDCOM REPO citation record type
+#The actual REPO record is stored in the Repository_record class.
+#
+#=SOURCE_REPOSITORY_CITATION:=
+#
+#  n REPO @XREF:REPO@               {1:1}
+#    +1 <<NOTE_STRUCTURE>>          {0:M}
+#    +1 CALN <SOURCE_CALL_NUMBER>   {0:M}
+#      +2 MEDI <SOURCE_MEDIA_TYPE>  {0:1}
+#
+#  This structure is used within a source record to point to a name and address record of the holder of the
+#  source document. Formal and informal repository name and addresses are stored in the
+#  REPOSITORY_RECORD. Informal repositories include owner's of an unpublished work or of a rare
+#  published source, or a keeper of personal collections. An example would be the owner of a family Bible
+#  containing unpublished family genealogical entries. More formal repositories, such as the Family History
+#  Library, should show a call number of the source at that repository. The call number of that source
+#  should be recorded using a subordinate CALN tag. Systems which do not structure a repository name
+#  and address interface should store the information about where the source record is stored in the
+#  <<NOTE_STRUCTURE>> of this structure.
+#
+#The attributes are all arrays for the +1 level tags/records. 
+#* 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 REPO records.
+#
+class Repository_citation_record < GEDCOMBase
+  attr_accessor :repository_ref, :note_citation_record, :repository_caln
+
+  ClassTracker <<  :Repository_citation_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, "REPO", :repository_ref] ] 
+    @sub_level =  [ #level + 1
+                    [:walk, nil, :repository_caln],
+                    [:walk, nil, :note_citation_record],
+                  ]
+  end 
+end
+

data/lib/gedcom/repository_record.rb

@@ -0,0 +1,41 @@
+require 'gedcom_base.rb'
+
+#Internal representation of the GEDCOM REPO record type
+#This class is referenced through the Repository_citation_record class.
+#
+#=REPOSITORY_RECORD:=
+#  0 @<XREF:REPO>@ REPO               {0:M}
+#    +1 NAME <NAME_OF_REPOSITORY>     {0:1}
+#    +1 <<ADDRESS_STRUCTURE>>         {0:1}
+#    +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}
+#
+#The attributes are all arrays for the +1 level tags/records. 
+#* 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 REPO records.
+class Repository_record < GEDCOMBase
+  attr_accessor :repository_ref, :repository_name, :phonenumber, :address_record,  :note_citation_record 
+  attr_accessor :refn_record, :automated_record_id, :change_date_record
+
+  ClassTracker <<  :Repository_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, "REPO", :repository_ref]]
+    @sub_level =  [#level 1
+                    [:print, "NAME",    :repository_name ],
+                    [:print, "PHON",    :phonenumber ],
+                    [:walk, nil,    :address_record ],
+                    [:walk, nil,    :note_citation_record ],
+                    [:walk, nil,     :refn_record ],
+                    [:print, "RIN",    :automated_record_id ],
+                    [:walk, nil,    :change_date_record ],
+                  ]
+  end 
+end
+

data/lib/gedcom/source_citation_record.rb

@@ -0,0 +1,74 @@
+require 'gedcom_base.rb'
+
+#Internal representation of a reference to the GEDCOM SOUR record type.
+#Both inline SOUR records and references to a Level 0 SOUR records are referenced via this class.
+#We store inline SOUR records in Source_record objects, not Source_citation_record objects.
+#
+#=SOURCE_CITATION:= (within another record, referencing a SOURCE_RECORD)
+#  n SOUR @<XREF:SOUR>@                         {1:1} (pointer to source record)
+#    +1 PAGE <WHERE_WITHIN_SOURCE>              {0:1}
+#    +1 EVEN <EVENT_TYPE_CITED_FROM>            {0:1}
+#      +2 ROLE <ROLE_IN_EVENT>                  {0:1}
+#    +1 DATA                                    {0:1}
+#      +2 DATE <ENTRY_RECORDING_DATE>           {0:1}
+#      +2 TEXT <TEXT_FROM_SOURCE>               {0:M}
+#        +3 [ CONC | CONT ] <TEXT_FROM_SOURCE>  {0:M}
+#    +1 QUAY <CERTAINTY_ASSESSMENT>             {0:1}
+#    +1 <<MULTIMEDIA_LINK>>                     {0:M}
+#    +1 <<NOTE_STRUCTURE>>                      {0:M}
+#
+#  The data provided in the <<SOURCE_CITATION>> structure is source-related information specific
+#  to the data being cited. (See GEDCOM examples starting on page 57.) Systems that do not use
+#  SOURCE_RECORDS must use the second SOURce citation structure option. When systems which
+#  support SOURCE_RECORD structures encounter source citations which do not contain pointers to
+#  source records, that system will need to create a SOURCE_RECORD and store the
+#  <SOURCE_DESCRIPTION> information found in the non-structured source citation in either the
+#  title area of that SOURCE_RECORD, or if the title field is not large enough, place a "(See Notes)"
+#  text in the title area, and place the unstructured source description in the source record's note field.
+#
+#  The information intended to be placed in the citation structure includes:
+#  * A pointer to the SOURCE_RECORD, which contains a more general description of the source.
+#  * Information, such as a page number, on how to find the cited data within the source.
+#  * Actual text from the source that was used in making assertions, for example a date phrase as
+#    actually recorded or an applicable sentence from a letter, would be appropriate.
+#  * Data that allows an assessment of the relative value of one source over another for making the
+#    recorded assertions (primary or secondary source, etc.). Data needed for this assessment is how
+#    much time from the asserted fact and when the source event was recorded, what type of event
+#    was cited, and what was the role of this person in the cited event.
+#    - Date when the entry was recorded in source document, ".SOUR.DATA.DATE."
+#    - Event that initiated the recording, ".SOUR.EVEN."
+#    - Role of this person in the event, ".SOUR.EVEN.ROLE".
+#
+#The attributes are all arrays representing all the +1 TAGS/Records. 
+#* 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_citation_record < GEDCOMBase
+  attr_accessor :source_ref, :source_record, :page, :citation_event_type_record, :citation_data_record, :quality 
+  attr_accessor :note_citation_record, :multimedia_citation_record 
+
+  ClassTracker <<  :Source_citation_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, "PAGE", :page],
+                      [:walk, nil,    :citation_event_type_record],
+                      [:walk, nil,    :citation_data_record],
+                      [:print, "QUAY",  :quality],
+                      [:walk, nil,  :multimedia_citation_record],
+                      [:walk, nil,  :note_citation_record],
+                    ]
+     elsif @source_record != nil
+       @this_level = [ [:walk, nil,  :source_record] ]
+       @sub_level =  []
+     end
+     super(level)
+  end
+end
+