dimus-biodiversity 0.0.12 → 0.0.13

data/lib/biodiversity/parser/{scientific_name.treetop → scientific_name_clean.treetop}

@@ -1,5 +1,5 @@
 # encoding: UTF-8
-grammar ScientificName
+grammar ScientificNameClean
 
   rule composite_scientific_name
     a:scientific_name space hybrid_separator space b:scientific_name space {
@@ -34,6 +34,34 @@ grammar ScientificName
   rule scientific_name
     name_part_authors_mix
     /
+    space a:name_part space b:authors_part space c:taxon_concept_rank space d:authors_part space {
+      def value
+        a.value + " " + b.value + " " + c.apply(d)
+      end
+    
+      def canonical
+        a.canonical
+      end
+    
+      def details
+        a.details.merge(b.details).merge(c.details(d)).merge({:name_part_verbatim => a.text_value, :auth_part_verbatim => (b.text_value + " " + c.text_value + " " + d.text_value).gsub(/\s{2,}/, ' ').strip})
+      end    
+    }
+    / 
+    space a:name_part space b:taxon_concept_rank space c:authors_part space {
+      def value
+        a.value + " " + b.apply(c)
+      end
+    
+      def canonical
+        a.canonical
+      end
+    
+      def details
+        a.details.merge(b.details(c)).merge({:name_part_verbatim => a.text_value, :auth_part_verbatim => (b.text_value + " " + c.text_value).gsub(/\s{2,}/, ' ').strip})
+      end    
+    }
+    / 
     space a:name_part space b:authors_part space c:status_part space {
       def value
         a.value + " " + b.value + " " + c.value
@@ -42,7 +70,7 @@ grammar ScientificName
         a.canonical
       end
       def details
-        a.details.merge(b.details).merge(c.details)
+        a.details.merge(b.details).merge(c.details).merge({:name_part_verbatim => a.text_value, :auth_part_verbatim => (b.text_value + " " + c.text_value).gsub(/\s{2,}/, ' ').strip})
       end
     }
     /
@@ -54,7 +82,7 @@ grammar ScientificName
         a.canonical
       end
       def details
-        a.details.merge(b.details)
+        a.details.merge(b.details).merge({:name_part_verbatim => a.text_value, :auth_part_verbatim => b.text_value.gsub(/\s{2,}/, ' ')})
       end
     }
     /
@@ -68,7 +96,7 @@ grammar ScientificName
       end
       
       def details
-        a.details.merge(b.details).merge({:is_valid => false})
+        a.details.merge(b.details).merge({:is_valid => false}).merge({:name_part_verbatim => a.text_value, :auth_part_verbatim => b.text_value.gsub(/\s{2,}/, ' ')})
       end
     }
     /
@@ -104,25 +132,25 @@ grammar ScientificName
   rule name_part_authors_mix
     a:species_name space b:authors_part space c:subspecies_name space d:authors_part {
       def value
-        a.value + " " + b.value + " " + c.value + " " + d.value
+        (a.value + " " + b.value + " " + c.value + " " + d.value).gsub(/\s+/,' ')
       end
       def canonical
-        a.canonical + " " + c.canonical
+        (a.canonical + " " + c.canonical).gsub(/\s+/,' ')
       end
       def details
-        a.details.merge(c.details).merge({:species_authors=>b.details, :subspecies_authors => d.details})
+        a.details.merge(c.details).merge({:species_authors=>b.details, :subspecies_authors => d.details}).merge({:name_part_verbatim => a.text_value, :auth_part_verbatim => (b.text_value + " " + c.text_value + " " + d.text_value).gsub(/\s{2,}/, ' ')})
       end
     }
     /
     a:species_name space b:authors_part space c:subspecies_name {
       def value 
-        a.value + " " + b.value + " " + c.value
+        (a.value + " " + b.value + " " + c.value).gsub(/\s+/,' ')
       end
       def canonical
-        a.canonical + " " + c.canonical
+        (a.canonical + " " + c.canonical).gsub(/\s+/,' ')
       end
       def details
-        a.details.merge(c.details).merge({:species_authors=>b.details})
+        a.details.merge(c.details).merge({:species_authors=>b.details}).merge({:name_part_verbatim => a.text_value, :auth_part_verbatim => (b.text_value + " " + c.text_value).gsub(/\s{2,}/, ' ')})
       end
     }
   end
@@ -180,7 +208,7 @@ grammar ScientificName
   end
   
   rule original_authors_names_full
-    "(" space a:authors_names space ")" space [,]? space b:year {
+    left_bracket space a:authors_names space right_bracket space [,]? space b:year {
       def value
         "(" + a.value + " " + b.value + ")"
       end
@@ -189,7 +217,25 @@ grammar ScientificName
       end
     }
     /
-    "(" space a:authors_names_full space ")" {
+    left_bracket space a:authors_names_full space right_bracket {
+      def value
+        "(" + a.value + ")"
+      end
+      def details
+        {:orig_authors => a.details[:authors]}
+      end
+    }
+    /
+    "[" space a:authors_names_full space "]" {
+       def value
+         "(" + a.value + ")"
+       end
+       def details
+         {:orig_authors => a.details[:authors]}
+       end
+     }
+     /
+    left_bracket space a:unknown_auth space right_bracket {
       def value
         "(" + a.value + ")"
       end
@@ -197,10 +243,19 @@ grammar ScientificName
         {:orig_authors => a.details[:authors]}
       end
     }
+    /
+    left_bracket space "?" space right_bracket {
+      def value
+        "(?)"
+      end
+      def details
+        {:orig_authors => "unknown"}
+      end
+    }
   end
     
   rule original_authors_revised_name
-    "(" space a:authors_revised_name space ")" {
+    left_bracket space a:authors_revised_name space right_bracket {
       def value
         "(" + a.value + ")"
       end
@@ -233,6 +288,19 @@ grammar ScientificName
     }
     /
     authors_names
+    /
+    unknown_auth
+  end
+  
+  rule unknown_auth
+    ("auct."/"hort."/"anon."/"ht.") {
+      def value
+        text_value
+      end
+      def details
+        {:authors => "unknown"}
+      end
+    }
   end
   
   rule ex_sep
@@ -282,7 +350,14 @@ grammar ScientificName
   end
   
   rule author_word
-    "A S. Xu"
+    "A S. Xu" {
+      def value
+        text_value.strip
+      end
+      def details
+        {:authors => {:names => [value]}}
+      end
+    }
     /
     ("anon."/"f."/"bis"/"arg."/"da"/"der"/"den"/"de"/"du"/"la"/"ter"/"van"/"et al.\{\?\}"/"et al.") {
       def value
@@ -409,7 +484,7 @@ grammar ScientificName
   end
   
   rule rank
-    ("f.sp."/"f."/"B"/"ssp."/"mut."/"pseudovar."/"sect."/"ser."/"var."/"subvar."/ "[var.]" /"subsp."/"subf."/"race"/"α" 
+    ("morph."/"f.sp."/"B"/"ssp."/"mut."/"pseudovar."/"sect."/"ser."/"var."/"subvar."/ "[var.]" /"subsp."/"subf."/"race"/"α" 
     /"ββ"/"β"/"γ"/"δ"/"ε"/"φ"/"θ"/"μ"/"a."/"b."/"c."/"d."/"e."/"g."/"k."/"****"/"**"/"*")
     {
       def value
@@ -425,6 +500,26 @@ grammar ScientificName
         {:subspecies => [{:rank => text_value, :value => (a.value rescue nil)}]}
       end
     }
+    /
+    rank_forma
+  end
+  
+  rule rank_forma
+    ("forma"/"form."/"fo."/"f.")
+    {
+      def value
+        "f."
+      end
+      def apply(a)
+        " " + value + " " + a.value
+      end
+      def canonical(a)
+        " " + a.value
+      end
+      def details(a = nil)
+        {:subspecies => [{:rank => value, :value => (a.value rescue nil)}]}
+      end
+    }
   end
   
   rule species_name
@@ -501,8 +596,42 @@ grammar ScientificName
     }
   end
   
+  rule taxon_concept_rank
+    "sec." {
+      def value
+        "sec."
+      end
+      def apply(a)
+        " " + value + " " + a.value
+      end
+      def details(a = nil)
+        {:taxon_concept => a.details}
+      end    
+    }
+  end
+
+  #  "subsect."/"subtrib."/"subgen."/"trib."/
+  rule genus_rank
+    ("subsect."/"subtrib."/"subgen."/"trib.")
+    {
+      def value
+        text_value.strip
+      end
+      def apply(a)
+        " " + text_value + " " + a.value
+      end
+      def canonical(a)
+        " " + a.value
+      end
+      def details(a = nil)
+        {:subgenus => [{:rank => text_value, :value => (a.value rescue nil)}]}
+      end
+    }
+  end
+  
+  
   rule cap_latin_word
-    a:[A-Z] b:latin_word {
+    a:[A-Zή] b:latin_word "?" {
       def value
         a.text_value + b.value
       end
@@ -515,10 +644,38 @@ grammar ScientificName
         {:uninomial => value}
       end
     }
+    /
+    a:[A-Zή] b:latin_word {
+      def value
+        a.text_value + b.value
+      end
+      
+      def canonical 
+        value
+      end
+      
+      def details 
+        {:uninomial => value}
+      end
+    }
+    /
+    ("Ca"/"Ea"/"Ge"/"Ia"/"Io"/"Io"/"Ix"/"Lo"/"Oa"/"Ra"/"Ty"/"Ua"/"Aa"/"Ja"/"Zu"/"La"/"Qu"/"As"/"Ba") {
+      def value
+        text_value
+      end
+      
+      def canonical
+        value
+      end
+      
+      def details
+        {:uninomial => value}
+      end
+    }
   end
 
   rule latin_word
-    a:[a-zë] b:full_name_letters {
+    a:[a-zëüäöïé] b:full_name_letters {
       def value
         a.text_value + b.value
       end
@@ -560,7 +717,7 @@ grammar ScientificName
   end
   
   rule valid_name_letters
-    [a-z\-ëüäöï]+ {
+    [a-z\-ëüäöïé]+ {
       def value
         text_value
       end
@@ -618,6 +775,28 @@ grammar ScientificName
       end
     }
   end
+
+#    Next two rles only for ( (author) )
+#    doesn't touch parenthesis inside another one like (bla-bla-bla1 (bla-bla-bla2))
+
+    rule left_bracket
+      "( ("/"("
+      {
+        def value
+          "("
+        end
+      }
+    end
+
+    rule right_bracket
+      ") )"/")"
+      {
+        def value
+          ")"
+        end
+      }
+    end
+  
   
   rule space
     [\s]* {

data/lib/biodiversity/parser/scientific_name_dirty.rb

@@ -0,0 +1,473 @@
+module ScientificNameDirty
+  include Treetop::Runtime
+
+  def root
+    @root || :composite_scientific_name
+  end
+
+  include ScientificNameClean
+
+  def _nt_composite_scientific_name
+    start_index = index
+    if node_cache[:composite_scientific_name].has_key?(index)
+      cached = node_cache[:composite_scientific_name][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    r0 = super
+
+    node_cache[:composite_scientific_name][start_index] = r0
+
+    return r0
+  end
+
+  module Year0
+    def a
+      elements[0]
+    end
+
+    def space
+      elements[1]
+    end
+
+    def b
+      elements[2]
+    end
+  end
+
+  module Year1
+
+    def value
+      a.text_value + " " + b.text_value
+    end
+    def details
+      {:ambiguous_year => value}
+    end
+  end
+
+  module Year2
+    def a
+      elements[0]
+    end
+
+    def page_number
+      elements[1]
+    end
+  end
+
+  module Year3
+
+    def value
+      a.text_value
+    end
+    def details
+      {:year => value}
+    end
+  end
+
+  def _nt_year
+    start_index = index
+    if node_cache[:year].has_key?(index)
+      cached = node_cache[:year][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0 = index
+    i1, s1 = index, []
+    s2, i2 = [], index
+    loop do
+      if input.index(Regexp.new('[\\d]'), index) == index
+        r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
+        @index += 1
+      else
+        r3 = nil
+      end
+      if r3
+        s2 << r3
+      else
+        break
+      end
+    end
+    if s2.empty?
+      self.index = i2
+      r2 = nil
+    else
+      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+    end
+    s1 << r2
+    if r2
+      r4 = _nt_space
+      s1 << r4
+      if r4
+        r5 = _nt_approximate_year
+        s1 << r5
+      end
+    end
+    if s1.last
+      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+      r1.extend(Year0)
+      r1.extend(Year1)
+    else
+      self.index = i1
+      r1 = nil
+    end
+    if r1
+      r0 = r1
+    else
+      i6, s6 = index, []
+      s7, i7 = [], index
+      loop do
+        if input.index(Regexp.new('[\\d]'), index) == index
+          r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          r8 = nil
+        end
+        if r8
+          s7 << r8
+        else
+          break
+        end
+      end
+      if s7.empty?
+        self.index = i7
+        r7 = nil
+      else
+        r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
+      end
+      s6 << r7
+      if r7
+        r9 = _nt_page_number
+        s6 << r9
+      end
+      if s6.last
+        r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
+        r6.extend(Year2)
+        r6.extend(Year3)
+      else
+        self.index = i6
+        r6 = nil
+      end
+      if r6
+        r0 = r6
+      else
+        r10 = _nt_double_year
+        if r10
+          r0 = r10
+        else
+          r11 = _nt_approximate_year
+          if r11
+            r0 = r11
+          else
+            r12 = super
+            if r12
+              r0 = r12
+            else
+              self.index = i0
+              r0 = nil
+            end
+          end
+        end
+      end
+    end
+
+    node_cache[:year][start_index] = r0
+
+    return r0
+  end
+
+  module ApproximateYear0
+  end
+
+  module ApproximateYear1
+    def space
+      elements[1]
+    end
+
+    def a
+      elements[2]
+    end
+
+    def space
+      elements[3]
+    end
+
+  end
+
+  module ApproximateYear2
+
+    def value
+     "(" + a.text_value + ")"
+    end
+    def details
+      {:approximate_year => value}
+    end
+  end
+
+  def _nt_approximate_year
+    start_index = index
+    if node_cache[:approximate_year].has_key?(index)
+      cached = node_cache[:approximate_year][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0, s0 = index, []
+    if input.index("[", index) == 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
+        i3, s3 = index, []
+        if input.index(Regexp.new('[\\d]'), index) == index
+          r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          r4 = nil
+        end
+        s3 << r4
+        if r4
+          if input.index(Regexp.new('[\\d]'), index) == index
+            r5 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            @index += 1
+          else
+            r5 = nil
+          end
+          s3 << r5
+          if r5
+            if input.index(Regexp.new('[\\d]'), index) == index
+              r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
+              @index += 1
+            else
+              r6 = nil
+            end
+            s3 << r6
+            if r6
+              s7, i7 = [], index
+              loop do
+                if input.index(Regexp.new('[\\d\\?]'), index) == index
+                  r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                  @index += 1
+                else
+                  r8 = nil
+                end
+                if r8
+                  s7 << r8
+                else
+                  break
+                end
+              end
+              if s7.empty?
+                self.index = i7
+                r7 = nil
+              else
+                r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
+              end
+              s3 << r7
+            end
+          end
+        end
+        if s3.last
+          r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+          r3.extend(ApproximateYear0)
+        else
+          self.index = i3
+          r3 = nil
+        end
+        s0 << r3
+        if r3
+          r9 = _nt_space
+          s0 << r9
+          if r9
+            s10, i10 = [], index
+            loop do
+              if input.index("]", index) == index
+                r11 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                @index += 1
+              else
+                terminal_parse_failure("]")
+                r11 = nil
+              end
+              if r11
+                s10 << r11
+              else
+                break
+              end
+            end
+            if s10.empty?
+              self.index = i10
+              r10 = nil
+            else
+              r10 = instantiate_node(SyntaxNode,input, i10...index, s10)
+            end
+            s0 << r10
+          end
+        end
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(ApproximateYear1)
+      r0.extend(ApproximateYear2)
+    else
+      self.index = i0
+      r0 = nil
+    end
+
+    node_cache[:approximate_year][start_index] = r0
+
+    return r0
+  end
+
+  module DoubleYear0
+  end
+
+  module DoubleYear1
+
+    def value
+      text_value
+    end
+    def details
+      {:year => value}
+    end
+  end
+
+  def _nt_double_year
+    start_index = index
+    if node_cache[:double_year].has_key?(index)
+      cached = node_cache[:double_year][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0, s0 = index, []
+    if input.index(Regexp.new('[0-9]'), index) == index
+      r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
+      @index += 1
+    else
+      r1 = nil
+    end
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        if input.index(Regexp.new('[0-9A-Za-z\\?\\-]'), index) == index
+          r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          r3 = nil
+        end
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      if s2.empty?
+        self.index = i2
+        r2 = nil
+      else
+        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      end
+      s0 << r2
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(DoubleYear0)
+      r0.extend(DoubleYear1)
+    else
+      self.index = i0
+      r0 = nil
+    end
+
+    node_cache[:double_year][start_index] = r0
+
+    return r0
+  end
+
+  module PageNumber0
+    def space
+      elements[1]
+    end
+
+  end
+
+  module PageNumber1
+
+    def value
+    end
+  end
+
+  def _nt_page_number
+    start_index = index
+    if node_cache[:page_number].has_key?(index)
+      cached = node_cache[:page_number][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0, s0 = index, []
+    if input.index(":", index) == 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 input.index(Regexp.new('[\\d]'), index) == index
+            r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            @index += 1
+          else
+            r4 = nil
+          end
+          if r4
+            s3 << r4
+          else
+            break
+          end
+        end
+        if s3.empty?
+          self.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
+      self.index = i0
+      r0 = nil
+    end
+
+    node_cache[:page_number][start_index] = r0
+
+    return r0
+  end
+
+end
+
+class ScientificNameDirtyParser < Treetop::Runtime::CompiledParser
+  include ScientificNameDirty
+end
+