Module: ScientificNameDirty

Includes:

ScientificNameClean, Treetop::Runtime

Included in:

ScientificNameCanonical, ScientificNameDirtyParser

Defined in:

lib/biodiversity/parser/scientific_name_dirty.rb

Defined Under Namespace

Modules: ApproximateYear0, ApproximateYear1, DoubleYear0, DoubleYear1, Garbage0, Garbage1, Infraspecies0, Infraspecies1, Infraspecies2, Infraspecies3, LatinWord0, LatinWord1, LeftParen0, PageNumber0, PageNumber1, RightParen0, Root0, Root1, ScientificName50, ScientificName51, Species0, Species1, ValidNameLetters0, Year0, Year1, Year2, Year3, YearNumberWithPunctuation0, YearNumberWithPunctuation1

Instance Method Summary

• #_nt_approximate_year ⇒ Object
• #_nt_double_year ⇒ Object
• #_nt_garbage ⇒ Object
• #_nt_infraspecies ⇒ Object
• #_nt_latin_word ⇒ Object
• #_nt_left_paren ⇒ Object
• #_nt_page_number ⇒ Object
• #_nt_right_paren ⇒ Object
• #_nt_root ⇒ Object
• #_nt_scientific_name_5 ⇒ Object
• #_nt_species ⇒ Object
• #_nt_string_authorship_inconsistencies ⇒ Object
• #_nt_valid_name_letters ⇒ Object
• #_nt_year ⇒ Object
• #_nt_year_number_with_punctuation ⇒ Object
• #root ⇒ Object

Methods included from ScientificNameClean

#_nt_abbreviated_genus, #_nt_annotation_identification, #_nt_author_name, #_nt_author_name_without_postfix, #_nt_author_postfix_word, #_nt_author_prefix_word, #_nt_author_separator, #_nt_author_word, #_nt_authors_names, #_nt_authorship, #_nt_basionym_authorship_with_parenthesis, #_nt_cap_digraph, #_nt_cap_latin_word, #_nt_cap_latin_word_pair, #_nt_capped_dotted_char, #_nt_ex_authorship, #_nt_ex_sep, #_nt_genus, #_nt_hybrid_character, #_nt_infragenus, #_nt_infraspecies_mult, #_nt_infraspecies_string, #_nt_multinomial_name, #_nt_multiplication_sign, #_nt_multiuninomial_name, #_nt_rank, #_nt_rank_uninomial, #_nt_scientific_name_1, #_nt_scientific_name_2, #_nt_scientific_name_3, #_nt_scientific_name_4, #_nt_simple_authorship, #_nt_space, #_nt_space_hard, #_nt_species_string, #_nt_species_word, #_nt_species_word_hybrid, #_nt_status_part, #_nt_status_word, #_nt_taxon_concept_rank, #_nt_uninomial_name, #_nt_uninomial_string, #_nt_unknown_auth, #_nt_unparsed, #_nt_valid_name_letter, #_nt_year_number, #_nt_year_number_with_character

Instance Method Details

#_nt_approximate_year ⇒ Object

# File 'lib/biodiversity/parser/scientific_name_dirty.rb', line 808

def _nt_approximate_year
  start_index = index
  if node_cache[:approximate_year].has_key?(index)
    cached = node_cache[:approximate_year][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?("[", false, index)
    r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
    @index += 1
  else
    terminal_parse_failure("[")
    r1 = nil
  end
  s0 << r1
  if r1
    r2 = _nt_space
    s0 << r2
    if r2
      r3 = _nt_year_number
      s0 << r3
      if r3
        r4 = _nt_space
        s0 << r4
        if r4
          s5, i5 = [], index
          loop do
            if has_terminal?("]", false, index)
              r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
              @index += 1
            else
              terminal_parse_failure("]")
              r6 = nil
            end
            if r6
              s5 << r6
            else
              break
            end
          end
          if s5.empty?
            @index = i5
            r5 = nil
          else
            r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
          end
          s0 << r5
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(ApproximateYear0)
    r0.extend(ApproximateYear1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:approximate_year][start_index] = r0

  r0
end

#_nt_double_year ⇒ Object

# File 'lib/biodiversity/parser/scientific_name_dirty.rb', line 899

def _nt_double_year
  start_index = index
  if node_cache[:double_year].has_key?(index)
    cached = node_cache[:double_year][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_year_number
  s0 << r1
  if r1
    if has_terminal?("-", false, index)
      r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
      @index += 1
    else
      terminal_parse_failure("-")
      r2 = nil
    end
    s0 << r2
    if r2
      s3, i3 = [], index
      loop do
        if has_terminal?('\G[0-9]', true, index)
          r4 = true
          @index += 1
        else
          r4 = nil
        end
        if r4
          s3 << r4
        else
          break
        end
      end
      if s3.empty?
        @index = i3
        r3 = nil
      else
        r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
      end
      s0 << r3
      if r3
        if has_terminal?('\G[A-Za-z]', true, index)
          r6 = true
          @index += 1
        else
          r6 = nil
        end
        if r6
          r5 = r6
        else
          r5 = instantiate_node(SyntaxNode,input, index...index)
        end
        s0 << r5
        if r5
          if has_terminal?('\G[\\?]', true, index)
            r8 = true
            @index += 1
          else
            r8 = nil
          end
          if r8
            r7 = r8
          else
            r7 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r7
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(DoubleYear0)
    r0.extend(DoubleYear1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:double_year][start_index] = r0

  r0
end

#_nt_garbage ⇒ Object

# File 'lib/biodiversity/parser/scientific_name_dirty.rb', line 1162

def _nt_garbage
  start_index = index
  if node_cache[:garbage].has_key?(index)
    cached = node_cache[:garbage][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  i1, s1 = index, []
  r2 = _nt_space
  s1 << r2
  if r2
    if has_terminal?('\G["\',]', true, index)
      r3 = true
      @index += 1
    else
      r3 = nil
    end
    s1 << r3
    if r3
      r4 = _nt_space
      s1 << r4
      if r4
        s5, i5 = [], index
        loop do
          if has_terminal?('\G[^щ]', true, index)
            r6 = true
            @index += 1
          else
            r6 = nil
          end
          if r6
            s5 << r6
          else
            break
          end
        end
        r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
        s1 << r5
      end
    end
  end
  if s1.last
    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
    r1.extend(Garbage0)
  else
    @index = i1
    r1 = nil
  end
  if r1
    r0 = r1
  else
    i7, s7 = index, []
    r8 = _nt_space_hard
    s7 << r8
    if r8
      s9, i9 = [], index
      loop do
        if has_terminal?('\G[^ш]', true, index)
          r10 = true
          @index += 1
        else
          r10 = nil
        end
        if r10
          s9 << r10
        else
          break
        end
      end
      if s9.empty?
        @index = i9
        r9 = nil
      else
        r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
      end
      s7 << r9
    end
    if s7.last
      r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
      r7.extend(Garbage1)
    else
      @index = i7
      r7 = nil
    end
    if r7
      r0 = r7
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:garbage][start_index] = r0

  r0
end

#_nt_infraspecies ⇒ Object

# File 'lib/biodiversity/parser/scientific_name_dirty.rb', line 234

def _nt_infraspecies
  start_index = index
  if node_cache[:infraspecies].has_key?(index)
    cached = node_cache[:infraspecies][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  i1, s1 = index, []
  r2 = _nt_infraspecies_string
  s1 << r2
  if r2
    r3 = _nt_space
    s1 << r3
    if r3
      r4 = _nt_year
      s1 << r4
    end
  end
  if s1.last
    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
    r1.extend(Infraspecies0)
    r1.extend(Infraspecies1)
  else
    @index = i1
    r1 = nil
  end
  if r1
    r0 = r1
  else
    i5, s5 = index, []
    r6 = _nt_infraspecies_string
    s5 << r6
    if r6
      r7 = _nt_space
      s5 << r7
      if r7
        r8 = _nt_string_authorship_inconsistencies
        s5 << r8
        if r8
          r9 = _nt_space
          s5 << r9
          if r9
            r10 = _nt_authorship
            s5 << r10
          end
        end
      end
    end
    if s5.last
      r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
      r5.extend(Infraspecies2)
      r5.extend(Infraspecies3)
    else
      @index = i5
      r5 = nil
    end
    if r5
      r0 = r5
    else
      r11 = super
      if r11
        r0 = r11
      else
        @index = i0
        r0 = nil
      end
    end
  end

  node_cache[:infraspecies][start_index] = r0

  r0
end

#_nt_latin_word ⇒ Object

# File 'lib/biodiversity/parser/scientific_name_dirty.rb', line 416

def _nt_latin_word
  start_index = index
  if node_cache[:latin_word].has_key?(index)
    cached = node_cache[:latin_word][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?('\G[a-z\\-æœàâåãäáçčëéèíìïňññóòôøõöúùüŕřŗššşž]', true, index)
    r1 = true
    @index += 1
  else
    r1 = nil
  end
  s0 << r1
  if r1
    r2 = _nt_valid_name_letters
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(LatinWord0)
    r0.extend(LatinWord1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:latin_word][start_index] = r0

  r0
end

#_nt_left_paren ⇒ Object

# File 'lib/biodiversity/parser/scientific_name_dirty.rb', line 578

def _nt_left_paren
  start_index = index
  if node_cache[:left_paren].has_key?(index)
    cached = node_cache[:left_paren][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  i1, s1 = index, []
  if has_terminal?("(", false, index)
    r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
    @index += 1
  else
    terminal_parse_failure("(")
    r2 = nil
  end
  s1 << r2
  if r2
    r3 = _nt_space
    s1 << r3
    if r3
      if has_terminal?("(", false, index)
        r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
        @index += 1
      else
        terminal_parse_failure("(")
        r4 = nil
      end
      s1 << r4
    end
  end
  if s1.last
    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
    r1.extend(LeftParen0)
  else
    @index = i1
    r1 = nil
  end
  if r1
    r0 = r1
  else
    r5 = super
    if r5
      r0 = r5
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:left_paren][start_index] = r0

  r0
end

#_nt_page_number ⇒ Object

# File 'lib/biodiversity/parser/scientific_name_dirty.rb', line 1059

def _nt_page_number
  start_index = index
  if node_cache[:page_number].has_key?(index)
    cached = node_cache[:page_number][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if has_terminal?(":", false, index)
    r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
    @index += 1
  else
    terminal_parse_failure(":")
    r1 = nil
  end
  s0 << r1
  if r1
    r2 = _nt_space
    s0 << r2
    if r2
      s3, i3 = [], index
      loop do
        if has_terminal?('\G[\\d]', true, index)
          r4 = true
          @index += 1
        else
          r4 = nil
        end
        if r4
          s3 << r4
        else
          break
        end
      end
      if s3.empty?
        @index = i3
        r3 = nil
      else
        r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
      end
      s0 << r3
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(PageNumber0)
    r0.extend(PageNumber1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:page_number][start_index] = r0

  r0
end

#_nt_right_paren ⇒ Object

# File 'lib/biodiversity/parser/scientific_name_dirty.rb', line 512

def _nt_right_paren
  start_index = index
  if node_cache[:right_paren].has_key?(index)
    cached = node_cache[:right_paren][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  i1, s1 = index, []
  if has_terminal?(")", false, index)
    r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
    @index += 1
  else
    terminal_parse_failure(")")
    r2 = nil
  end
  s1 << r2
  if r2
    r3 = _nt_space
    s1 << r3
    if r3
      if has_terminal?(")", false, index)
        r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
        @index += 1
      else
        terminal_parse_failure(")")
        r4 = nil
      end
      s1 << r4
    end
  end
  if s1.last
    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
    r1.extend(RightParen0)
  else
    @index = i1
    r1 = nil
  end
  if r1
    r0 = r1
  else
    r5 = super
    if r5
      r0 = r5
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:right_paren][start_index] = r0

  r0
end

#_nt_root ⇒ Object

# File 'lib/biodiversity/parser/scientific_name_dirty.rb', line 54

def _nt_root
  start_index = index
  if node_cache[:root].has_key?(index)
    cached = node_cache[:root][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_space
  s0 << r1
  if r1
    r2 = _nt_scientific_name_5
    s0 << r2
    if r2
      r3 = _nt_space
      s0 << r3
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Root0)
    r0.extend(Root1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:root][start_index] = r0

  r0
end

#_nt_scientific_name_5 ⇒ Object

# File 'lib/biodiversity/parser/scientific_name_dirty.rb', line 118

def _nt_scientific_name_5
  start_index = index
  if node_cache[:scientific_name_5].has_key?(index)
    cached = node_cache[:scientific_name_5][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  i1, s1 = index, []
  r2 = _nt_scientific_name_4
  s1 << r2
  if r2
    r3 = _nt_garbage
    s1 << r3
  end
  if s1.last
    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
    r1.extend(ScientificName50)
    r1.extend(ScientificName51)
  else
    @index = i1
    r1 = nil
  end
  if r1
    r0 = r1
  else
    r4 = super
    if r4
      r0 = r4
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:scientific_name_5][start_index] = r0

  r0
end

#_nt_species ⇒ Object

# File 'lib/biodiversity/parser/scientific_name_dirty.rb', line 345

def _nt_species
  start_index = index
  if node_cache[:species].has_key?(index)
    cached = node_cache[:species][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  i1, s1 = index, []
  r2 = _nt_species_string
  s1 << r2
  if r2
    r3 = _nt_space
    s1 << r3
    if r3
      r4 = _nt_year
      s1 << r4
    end
  end
  if s1.last
    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
    r1.extend(Species0)
    r1.extend(Species1)
  else
    @index = i1
    r1 = nil
  end
  if r1
    r0 = r1
  else
    r5 = super
    if r5
      r0 = r5
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:species][start_index] = r0

  r0
end

#_nt_string_authorship_inconsistencies ⇒ Object

# File 'lib/biodiversity/parser/scientific_name_dirty.rb', line 1120

def _nt_string_authorship_inconsistencies
  start_index = index
  if node_cache[:string_authorship_inconsistencies].has_key?(index)
    cached = node_cache[:string_authorship_inconsistencies][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  if has_terminal?("corrig.", false, index)
    r0 = instantiate_node(SyntaxNode,input, index...(index + 7))
    @index += 7
  else
    terminal_parse_failure("corrig.")
    r0 = nil
  end

  node_cache[:string_authorship_inconsistencies][start_index] = r0

  r0
end

#_nt_valid_name_letters ⇒ Object

# File 'lib/biodiversity/parser/scientific_name_dirty.rb', line 467

def _nt_valid_name_letters
  start_index = index
  if node_cache[:valid_name_letters].has_key?(index)
    cached = node_cache[:valid_name_letters][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  s0, i0 = [], index
  loop do
    if has_terminal?('\G[a-z\\-æœàâåãäáçčëéèíìïňññóòôøõöúùüŕřŗššşž]', true, index)
      r1 = true
      @index += 1
    else
      r1 = nil
    end
    if r1
      s0 << r1
    else
      break
    end
  end
  if s0.empty?
    @index = i0
    r0 = nil
  else
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(ValidNameLetters0)
  end

  node_cache[:valid_name_letters][start_index] = r0

  r0
end

#_nt_year ⇒ Object

# File 'lib/biodiversity/parser/scientific_name_dirty.rb', line 693

def _nt_year
  start_index = index
  if node_cache[:year].has_key?(index)
    cached = node_cache[:year][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  i1, s1 = index, []
  r2 = _nt_year_number
  s1 << r2
  if r2
    r3 = _nt_space
    s1 << r3
    if r3
      r4 = _nt_approximate_year
      s1 << r4
    end
  end
  if s1.last
    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
    r1.extend(Year0)
    r1.extend(Year1)
  else
    @index = i1
    r1 = nil
  end
  if r1
    r0 = r1
  else
    i5, s5 = index, []
    r6 = _nt_year_number
    s5 << r6
    if r6
      r7 = _nt_space
      s5 << r7
      if r7
        r8 = _nt_page_number
        s5 << r8
      end
    end
    if s5.last
      r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
      r5.extend(Year2)
      r5.extend(Year3)
    else
      @index = i5
      r5 = nil
    end
    if r5
      r0 = r5
    else
      r9 = _nt_year_number_with_punctuation
      if r9
        r0 = r9
      else
        r10 = _nt_approximate_year
        if r10
          r0 = r10
        else
          r11 = _nt_double_year
          if r11
            r0 = r11
          else
            r12 = super
            if r12
              r0 = r12
            else
              @index = i0
              r0 = nil
            end
          end
        end
      end
    end
  end

  node_cache[:year][start_index] = r0

  r0
end

#_nt_year_number_with_punctuation ⇒ Object

# File 'lib/biodiversity/parser/scientific_name_dirty.rb', line 1009

def _nt_year_number_with_punctuation
  start_index = index
  if node_cache[:year_number_with_punctuation].has_key?(index)
    cached = node_cache[:year_number_with_punctuation][index]
    if cached
      cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_year_number
  s0 << r1
  if r1
    if has_terminal?(".", false, index)
      r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
      @index += 1
    else
      terminal_parse_failure(".")
      r2 = nil
    end
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(YearNumberWithPunctuation0)
    r0.extend(YearNumberWithPunctuation1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:year_number_with_punctuation][start_index] = r0

  r0
end

#root ⇒ Object

# File 'lib/biodiversity/parser/scientific_name_dirty.rb', line 8

def root
  @root ||= :root
end