Class: GEDCOM_DATE_PARSER::DateParser

Inherits:

Object

Object
GEDCOM_DATE_PARSER::DateParser

show all

Defined in:: lib/gedcom_ruby/date_parser.rb

Constant Summary collapse

GEDFNONE =

GEDFBETWEEN =

GEDFFROM =

GEDFINTERP =

GEDFNUMBER =

GEDFMONTH =

GEDFSLASH =

Class Method Summary collapse

Class Method Details

.build_gedcom_date_part_string(date) ⇒ `Object`

# File 'lib/gedcom_ruby/date_parser.rb', line 938

def self.build_gedcom_date_part_string( date )
  # Stringify a GEDCOM date part (class method)
  # Inputs:  date      -  date part (GEDDate)
  # Outputs: buffer    -  output string
  buffer = ""
  buffer += get_date_text( date )
  buffer
end

.build_gedcom_date_string(date) ⇒ `Object`

# File 'lib/gedcom_ruby/date_parser.rb', line 894

def self.build_gedcom_date_string( date )
  # Stringify a GEDCOM date (class method)
  # Inputs:  date      -  date (GEDDateValue)
  # Outputs: buffer    -  output string
  buffer = ""

  case ( date.flags )
    when GCABOUT then       buffer += "abt "
    when GCCALCULATED then  buffer += "cal "
    when GCESTIMATED then   buffer += "est "
    when GCBEFORE then      buffer += "bef "
    when GCAFTER then       buffer += "aft "
    when GCBETWEEN then     buffer += "bet "
    when GCFROM then
    when GCFROMTO then      buffer += "from "
    when GCTO then          buffer += "to "
    when GCINTERPRETED then buffer += "int "

    when GCCHILD then       buffer += "child"; return
    when GCCLEARED then     buffer += "cleared"; return
    when GCCOMPLETED then   buffer += "completed"; return
    when GCINFANT then      buffer += "infant"; return
    when GCPRE1970 then     buffer += "pre-1970"; return
    when GCQUALIFIED then   buffer += "qualified"; return
    when GCSTILLBORN then   buffer += "stillborn"; return
    when GCSUBMITTED then   buffer += "submitted"; return
    when GCUNCLEARED then   buffer += "uncleared"; return
    when GCBIC then         buffer += "BIC"; return
    when GCDNS then         buffer += "DNS"; return
    when GCDNSCAN then      buffer += "DNSCAN"; return
    when GCDEAD then        buffer += "dead"; return
  end

  buffer += get_date_text( date.date1 ) if (date.date1)

  case ( date.flags )
    when GCBETWEEN then buffer += " and "
    when GCFROMTO then  buffer += " to "
  end

  buffer += get_date_text( date.date2 ) if (date.date2)
  buffer
end

.get_date_text(date) ⇒ `Object`

# File 'lib/gedcom_ruby/date_parser.rb', line 516

def self.get_date_text( date )
  # Stringify the GEDCOM Date (class method)
  # Inputs:  date      -  Date Part  (GEDDate)
  # Outputs: buffer    -  Output string
  buffer = ""

  if ( (date.flags & (GFPHRASE | GFNONSTANDARD)) != 0)
    buffer += date.data
    return buffer
  end

  case ( date.type )
    when GCTHEBREW
      months = Hebrew_Months
    when GCTFRENCH
      months = French_Months
    else
      months = Default_Months
  end

  return buffer if not (date.data)

  if ( date.data.flags && (( date.data.flags & GFNODAY ) == 0) )
    buffer += date.data.day.to_s
    buffer += " " if ( (( date.data.flags & GFNOMONTH ) == 0) || (( date.data.flags & GFNOYEAR ) == 0) )
  end

  if ( date.data.flags && (( date.data.flags & GFNOMONTH ) == 0) )
    buffer += months[ date.data.month - 1 ]
    buffer += " " if( ( date.data.flags & GFNOYEAR ) == 0 )
  end

  if ( date.data.flags && (( date.data.flags & GFNOYEAR ) == 0) )
    buffer += date.data.year.to_s
    if ( ( date.data.flags & GFYEARSPAN ) != 0 )
      buffer += "-"
      buffer += date.data.year2.to_s
    end
  end

  buffer += " BC" if ( (date.type == GCTGREGORIAN) && (date.data.adbc != GEDADBCAD) )
  buffer
end

.get_token(parser) ⇒ `Object`

# File 'lib/gedcom_ruby/date_parser.rb', line 429

def self.get_token( parser )
  # Get a single token from this parser state (class method)
  # Inputs:  parser    -  parser state  (GEDParserState)
  # Outputs: general   -  general token
  #          specific  -  specific token
  startPos = parser.pos

  # if we've got a token saved in the parser, return it
  if ( parser.lastGeneralToken != TKNONE )
    general = parser.lastGeneralToken
    specific = parser.lastSpecificToken
    parser.lastGeneralToken = TKNONE
    parser.lastSpecificToken = TKNONE
    return general, specific
  end

  #eat leading white-space
 parser.pos+=1 while ( parser.buffer[ parser.pos, 1 ]==" " )

  #if the buffer is empty, return TKEOF
  if ( parser.buffer[ parser.pos, 1 ] == nil || parser.buffer[parser.pos, 1] == "")
    specific = TKNONE
    general = TKEOF
    return general, specific
  end

  lexeme = ""
  # if it's a number, parse it out and return it
  if ( parser.buffer[ parser.pos, 1 ] =~ /[0-9]/ )
    while ( parser.buffer[ parser.pos, 1 ] =~ /[0-9]/)
      lexeme << parser.buffer[ parser.pos, 1 ]
      parser.pos+=1
    end
    specific = lexeme.to_i
    general = TKNUMBER
    return general, specific
  end

  currentToken = 0
  lexPos = 0
  # if it is not a number, incrementally look at each token in the table
  while ( TokenTable[ currentToken ].lexeme != 0 )
    lexeme << parser.buffer[ parser.pos, 1 ].upcase
    lexPos+=1
    parser.pos+=1

    if( lexeme[ lexPos-1, 1 ] != TokenTable[ currentToken ].lexeme[ lexPos-1, 1 ] )
      currentToken+=1 while( ( TokenTable[ currentToken ].lexeme != 0 ) &&
             ( (TokenTable[ currentToken ].lexeme[0, lexPos] <=> lexeme[0, lexPos] ) < 0 ) )

      #if the lexeme does not appear in the table, exit with an error
      break if ( TokenTable[ currentToken ].lexeme == 0 || \
          (TokenTable[ currentToken ].lexeme[0, lexPos] <=> lexeme[0, lexPos] ) != 0 )

    end

    #if the lexeme terminates, return the value of the current token
    if( ( ( lexeme[0,1] =~ /[a-zA-Z]/) && ( parser.buffer[ parser.pos, 1 ] !~ /[0-9a-zA-Z]/) ) ||
        ( ( lexeme[0,1] !~ /[a-zA-Z]/ ) && ( lexPos >= TokenTable[ currentToken ].lexeme.length ) ) )
      specific = TokenTable[ currentToken ].specific
      general = TokenTable[ currentToken ].general
      return general, specific
    end

    #if the current token terminates before the lexeme, then we have an error
    break if ( TokenTable[ currentToken ].lexeme[ lexPos, 1 ] == nil )

  end

  parser.pos = startPos

  specific = TKNONE
  general = TKERROR

  return general, specific
end

.parse_date_part(parser, datePart, type) ⇒ `Object`

Raises:

(DateParseException)

# File 'lib/gedcom_ruby/date_parser.rb', line 578

def self.parse_date_part( parser, datePart, type )
  # Parse out a date part (class method)
  # Inputs:  parser    -  parser state
  #          datePart  -  date part (GEDDate)
  #          type      -  calendar type
  # Outputs: None  (updated date part)
  state = ST_DT_START
  flags = GEDFNONE

  # Initialize the datePart, in case it contains old data
  datePart.type = type
  datePart.flags = GFNONE
  if (type == GCTGREGORIAN)
    datePart.data = GEDDateGreg.new(flags, 0, 0, 0, 0, GEDADBCAD)
  else
    datePart.data = GEDDateGeneral.new(flags, 0, 0, 0)
  end
  number = 0

  while ( ( state != ST_DT_END ) && ( state != ST_DT_ERROR ) )
    general, specific = get_token( parser )
    raise DateParseException, "error parsing datepart, pre-transition" if (general == TKERROR)
    transitionFound = 0

    case ( general )
      when TKNUMBER
      when TKMONTH
      when TKSLASH
      when TKBC
      when TKEOF
      when TKERROR
      when TKTO, TKAND
        put_token( parser, general, specific)
      else
        put_token( parser, general, specific )
        general = TKEOF
        specific = TKNONE
        break
    end

    DateStateTable.each do |dateState|
      break if dateState.state < 1

      if( ( dateState.state == state ) && ( dateState.input == general ) )
        state = dateState.nextState
        transitionFound = 1

        case dateState.action
          # 0: store number, set NUMBER
          when 0
            number = specific
            flags |= GEDFNUMBER

          # 1: if MONTH, then error, else set number to be day, set month, set MONTH
          when 1
            if ( type == GCTFRENCH )
              # if the token is "JOUR", make sure they also typed at least
              # part of "COMPLIMENTAIRES"

              case specific
                when TKJOUR
                  general, specific = get_token( parser )
                  raise DateParseException, "error parsing datepart, post-JOUR (french calendar)" if (general == TKERROR)
                  if ( general != TKMONTH && specific != TKCOMP )
                    state = ST_DT_ERROR
                    put_token( parser, general, specific )
                  end #fall through

                when TKCOMP
                  specific = TKJOUR_COMP
              end
            elsif ( type == GCTHEBREW )
              # if the token is "ADAR", see if it is followed by "SHENI",
              # and if it is, change the month to "ADAR SHENI"

              if( specific == TKADAR )
                general, specific = get_token( parser )
                raise DateParseException, "error parsing datepart, post-ADAR" if (general == TKERROR)
                if( general == TKMONTH && specific == TKSHENI )
                  specific = TKADAR_SHENI
                else
                  put_token( parser, general, specific )
                end
              end
            end

            if ( ( flags & GEDFMONTH ) != 0 )
              state = ST_DT_ERROR
            else
              month = validate_month_for_type( specific, type )
              if ( month < 1 )
                state = ST_DT_ERROR
              else
                datePart.data.day = number
                datePart.data.month = month
              end
              flags |= GEDFMONTH
              number = 0
            end

          # 2: if SLASH, then error, else set SLASH, set number to be year
          when 2
            if ( ( ( flags & GEDFSLASH ) != 0 ) || ( type != GCTGREGORIAN ) )
              state = ST_DT_ERROR
            else
              datePart.data.year = number if ( number > 0 )

              datePart.data.flags |= GFYEARSPAN
              number = 0
              flags |= GEDFSLASH
            end

          # 3: if not SLASH set number to be year, set bc
          # 4: if not SLASH set number to be year, terminate
          # 6: terminate
          when 3, 4, 6
            if (dateState.action == 3)
              if( type != GCTGREGORIAN )
                state = ST_DT_ERROR
                break
              end
              datePart.data.adbc = GEDADBCBC
            end

            if (dateState.action == 3 || dateState.action == 4)
              if( ( number > 0 ) && ( ( flags & GEDFSLASH ) == 0 ) )
                datePart.data.year = number
                number = 0
              end
            end


            datePart.data.flags |= GFNODAY if( datePart.data.day < 1 )

            datePart.data.flags |= GFNOMONTH if( datePart.data.month < 1 )

            datePart.data.flags |= GFNOYEAR if( datePart.data.year < 1 )


          # 5: if NUMBER, set number to be day.  set number to be year, store number, set NUMBER
          when 5
            datePart.data.day = number if( ( number > 0 ) && ( ( flags & GEDFNUMBER ) != 0 ) )

            datePart.data.year = specific

            number = 0
            flags |= GEDFNUMBER

          # 7: set number to be year2  (Gregorian Calendar)
          when 7
            datePart.data.year2 = ( specific % 100 )
            number = 0
        end

        break
      end
    end

    state = ST_DT_ERROR if( transitionFound == 0 )
  end

  raise DateParseException, "error parsing datepart, general" if( state == ST_DT_ERROR )

end

.parse_gedcom_date(dateString, date, type = GCTDEFAULT) ⇒ `Object`

# File 'lib/gedcom_ruby/date_parser.rb', line 744

def self.parse_gedcom_date( dateString, date, type = GCTDEFAULT )
  # Parse out a GEDCOM date (class method)
  # Inputs:  dateString    - String containing GEDCOM date
  #          date          -  date  (GEDDateValue)
  #          type          -  calendar type
  # Outputs: None  (updated date)

  parser = GEDParserState.new( "", 0, 0, 0 )
  parser.buffer = dateString

  # New date 1 if it's nil
  date.date1 = GEDDate.new( type, GFNONE, nil ) if not date.date1
  datePart = date.date1

  state = ST_DV_START
  flags = GEDFNONE
  datesRead = 0

  while ( ( state != ST_DV_END ) && ( state != ST_DV_ERROR ) )
    savePos = parser.pos
    general, specific = get_token( parser )
    raise DateParseException, "error parsing date" if (general == TKERROR)
    transitionFound = 0

    DateValueStateTable.each do |dateValueState|
      break if dateValueState.state < 1

      if( ( dateValueState.state == state ) && ( dateValueState.input == general ) )

        transitionFound = 1
        state = dateValueState.nextState

        case ( dateValueState.action )
          # 0: inc dates read, parse a date
          when 0
            put_token( parser, general, specific )
            begin
              if (datesRead != 0)
                # New date 2 if it's nil
                date.date2 = GEDDate.new( type, GFNONE, nil ) if not date.date2
                datePart = date.date2
              end
              parse_date_part( parser, datePart, type )
              datesRead+=1
            rescue
              state = ST_DV_ERROR
            end

          # 1: set the approx type
          when 1
            date.flags = case specific
              when TKABOUT      then GCABOUT
              when TKCALCULATED then GCCALCULATED
              when TKESTIMATED  then GCESTIMATED
            end

          # 2: set the range type
          when 2
            date.flags = case specific
            when TKBEFORE then GCBEFORE
            when TKAFTER  then GCAFTER
            when TKBETWEEN
              flags |= GEDFBETWEEN
              GCBETWEEN
            end

          # 3: set the period type
          when 3
            if general == TKTO
              date.flags = GCTO
            elsif specific == TKFROM
              date.flags = GCFROM
              flags |= GEDFFROM
            end

          # 4: set interpreted
          when 4
            date.flags = GCINTERPRETED
            flags |= GEDFINTERP

          # 5: get remaining buffer as phrase
          # 7: if 'interpreted', get remaining buffer as phrase
          when 5, 7
            # This is kind of a sucky way to handle this, but the shared functionality
            # between action 5 and 7 doesn't seem like enough to warrant breaking out
            # into it's own method.
            if dateValueState.action == 7 && ( flags & GEDFINTERP ) == 0
              state = ST_DV_ERROR
              break
            end

            # Strip off trailing whitespace and closing parenthesis
            buffer = parser.buffer.slice( parser.pos, parser.buffer.length ).rstrip.split( ')' )[0]
            datePart.data = buffer
            datePart.flags = GFPHRASE
            parser.pos = parser.buffer.length

          # 6: if 'between' and not second date read, error, else terminate
          when 6
            state = ST_DV_ERROR if( ( ( flags & GEDFBETWEEN ) != 0 ) && datesRead < 2 )

          # else -- nextState is ST_DV_END, so we're done!

          # 7: see above 5

          # 8: if 'between', prepare to read next date
          when 8
            state = ST_DV_ERROR if( ( flags & GEDFBETWEEN ) == 0 )

          # 9: if 'from', set FROMTO, prepare to read next date
          when 9
            if( ( flags & GEDFFROM ) == 0 )
              state = ST_DV_ERROR
            else
              date.flags = GCFROMTO
            end

          # 10: set status
          when 10
            date.flags = case specific
            when TKCHILD     then GCCHILD
            when TKCLEARED   then GCCLEARED
            when TKCOMPLETED then GCCOMPLETED
            when TKINFANT    then GCINFANT
            when TKPRE1970   then GCPRE1970
            when TKQUALIFIED then GCQUALIFIED
            when TKSTILLBORN then GCSTILLBORN
            when TKSUBMITTED then GCSUBMITTED
            when TKUNCLEARED then GCUNCLEARED
            when TKBIC       then GCBIC
            when TKDNS       then GCDNS
            when TKDNSCAN    then GCDNSCAN
            when TKDEAD      then GCDEAD
            end
        end
        break  # ... Out of the DateValueStateTable.each block
      end
    end

    state = ST_DV_ERROR if( transitionFound == 0 )
  end

  if( state == ST_DV_ERROR )
    parser.pos = savePos
    datePart.flags = GFNONSTANDARD
    datePart.data = parser.buffer.slice( parser.pos, parser.buffer.length )
    raise DateParseException, "error parsing date, general"
  end
end

.put_token(parser, general, specific) ⇒ `Object`

# File 'lib/gedcom_ruby/date_parser.rb', line 506

def self.put_token( parser, general, specific )
  # Update the parser state (class method)
  # Inputs:  parser    -  parser state  (GEDParserState)
  #          general   -  general token
  #          specific  -  specific token
  # Outputs: None
  parser.lastGeneralToken = general
  parser.lastSpecificToken = specific
end

.validate_month_for_type(month, calType) ⇒ `Object`

# File 'lib/gedcom_ruby/date_parser.rb', line 560

def self.validate_month_for_type( month, calType )
  # Make sure this is a valid month for this calendar type (class method)
  # Inputs:  parser    -  parser state
  # Outputs: general   -  general token
  #          specific  -  specific token
  case calType
    when GCTGREGORIAN || GCTJULIAN
      return ( month - TKJANUARY + 1 ) if( month >= TKJANUARY && month <= TKDECEMBER )

    when GCTHEBREW
      return ( month - TKTISHRI + 1 ) if( month >= TKTISHRI && month <= TKELUL )

    when GCTFRENCH
      return ( month - TKVENDEMIAIRE + 1 )if( month >= TKVENDEMIAIRE && month <= TKJOUR_COMP )
  end
  return -1
end

Class: GEDCOM_DATE_PARSER::DateParser

Constant Summary collapse

Class Method Summary collapse

Class Method Details

.build_gedcom_date_part_string(date) ⇒ Object

.build_gedcom_date_string(date) ⇒ Object

.get_date_text(date) ⇒ Object

.get_token(parser) ⇒ Object

.parse_date_part(parser, datePart, type) ⇒ Object

.parse_gedcom_date(dateString, date, type = GCTDEFAULT) ⇒ Object

.put_token(parser, general, specific) ⇒ Object

.validate_month_for_type(month, calType) ⇒ Object

.build_gedcom_date_part_string(date) ⇒ `Object`

.build_gedcom_date_string(date) ⇒ `Object`

.get_date_text(date) ⇒ `Object`

.get_token(parser) ⇒ `Object`

.parse_date_part(parser, datePart, type) ⇒ `Object`

.parse_gedcom_date(dateString, date, type = GCTDEFAULT) ⇒ `Object`

.put_token(parser, general, specific) ⇒ `Object`

.validate_month_for_type(month, calType) ⇒ `Object`