dimus-biodiversity 0.0.18 → 0.5.1

data/lib/biodiversity/parser.rb

@@ -13,54 +13,37 @@ class ScientificNameParser
     @clean = ScientificNameCleanParser.new
     @dirty = ScientificNameDirtyParser.new
     @canonical = ScientificNameCanonicalParser.new
-    @node = nil
+    @parser = nil
   end
   
   def parse(a_string)
     @verbatim = a_string
-    @node = @clean.parse(a_string) || @dirty.parse(a_string) || @canonical.parse(a_string) rescue nil
-    self
-  end
-  
-  def value
-    @node.value if @node
-  end
-
-  def pos
-    @node.pos if @node
-  end
-  
-  def details
-    @node.details if @node
-  end
-  
-  def canonical
-    @node.canonical if @node
-  end
-
-  def to_json 
-    parsed = !!@node
-    if parsed
+    @parser = @clean.parse(a_string) || @dirty.parse(a_string) || @canonical.parse(a_string)
+    def @parser.to_json
+      parsed = !!self
       res = {
         :parsed => parsed,
-        :verbatim => @node.text_value }
+        :verbatim => self.text_value }
       if parsed
         res.merge!({
-          :normalized => @node.value,
-          :canonical => @node.canonical
+          :normalized => self.value,
+          :canonical => self.canonical
           })
-        res.merge!(@node.details)
+        data = self.details
+        if data[:species] && data[:species][:namedHybrid]
+          data[:species].delete(:namedHybrid)
+          data = {:namedHybrid => data}
+        end
+        res.merge!(data)
       end
       res = {:scientificName => res}
       JSON.generate res
-    else
-      JSON.generate({:parsed => parsed, :verbatim => @verbatim})
     end
+    
+    def @parser.pos_json
+      JSON.generate self.pos rescue ''
+    end
+    @parser
   end
-
-  def pos_to_json
-    JSON.generate @node.pos rescue ''
-  end
-
 end
 

data/lib/biodiversity/parser/scientific_name_canonical.rb

@@ -3,29 +3,41 @@ module ScientificNameCanonical
   include Treetop::Runtime
 
   def root
-    @root || :composite_scientific_name
+    @root || :root
   end
 
   include ScientificNameClean
 
   include ScientificNameDirty
 
-  def _nt_composite_scientific_name
+  def _nt_root
     start_index = index
-    if node_cache[:composite_scientific_name].has_key?(index)
-      cached = node_cache[:composite_scientific_name][index]
+    if node_cache[:root].has_key?(index)
+      cached = node_cache[:root][index]
       @index = cached.interval.end if cached
       return cached
     end
 
-    r0 = _nt_name_part_with_garbage
+    i0 = index
+    r1 = _nt_multinomial_with_garbage
+    if r1
+      r0 = r1
+    else
+      r2 = _nt_uninomial_with_garbage
+      if r2
+        r0 = r2
+      else
+        self.index = i0
+        r0 = nil
+      end
+    end
 
-    node_cache[:composite_scientific_name][start_index] = r0
+    node_cache[:root][start_index] = r0
 
     return r0
   end
 
-  module NamePartWithGarbage0
+  module MultinomialWithGarbage0
     def a
       elements[0]
     end
@@ -37,26 +49,43 @@ module ScientificNameCanonical
     def b
       elements[2]
     end
+
+    def space
+      elements[3]
+    end
+
+    def c
+      elements[4]
+    end
+
+    def space_hard
+      elements[5]
+    end
+
+    def garbage
+      elements[6]
+    end
   end
 
-  module NamePartWithGarbage1
-    def value 
-      a.value
+  module MultinomialWithGarbage1
+    def value
+      a.value + " " + b.value + " " + c.value
     end
+    
     def canonical
-      a.canonical
+      a.canonical + " " + b.canonical + " " + c.canonical
     end
     
     def pos
-      a.pos
+      a.pos.merge(b.pos).merge(c.pos)
     end
     
     def details
-      a.details.merge(:name_part_verbatim => a.text_value, :auth_part_verbatim => b.text_value)
+      a.details.merge(b.details).merge(c.details)
     end
   end
 
-  module NamePartWithGarbage2
+  module MultinomialWithGarbage2
     def a
       elements[0]
     end
@@ -68,68 +97,114 @@ module ScientificNameCanonical
     def b
       elements[2]
     end
+
+    def space_hard
+      elements[3]
+    end
+
+    def garbage
+      elements[4]
+    end
   end
 
-  module NamePartWithGarbage3
-    def value 
-      a.value
+  module MultinomialWithGarbage3
+    def value
+      a.value + " " + b.value
     end
+    
     def canonical
-      a.canonical
+      a.canonical + " " + b.canonical
     end
     
     def pos
-      a.pos
+      a.pos.merge(b.pos)
     end
     
     def details
-      a.details.merge(:name_part_verbatim => a.text_value, :auth_part_verbatim => b.text_value)
+      a.details.merge(b.details)
     end
   end
 
-  def _nt_name_part_with_garbage
+  module MultinomialWithGarbage4
+    def a
+      elements[0]
+    end
+
+    def space
+      elements[1]
+    end
+
+    def b
+      elements[2]
+    end
+
+    def space_hard
+      elements[3]
+    end
+
+    def garbage
+      elements[4]
+    end
+  end
+
+  module MultinomialWithGarbage5
+    def value
+      a.value + " " + b.value
+    end
+    
+    def canonical
+      a.canonical + " " + b.canonical
+    end
+    
+    def pos
+      a.pos.merge(b.pos)
+    end
+    
+    def details
+      a.details.merge(b.details)
+    end
+  end
+
+  def _nt_multinomial_with_garbage
     start_index = index
-    if node_cache[:name_part_with_garbage].has_key?(index)
-      cached = node_cache[:name_part_with_garbage][index]
+    if node_cache[:multinomial_with_garbage].has_key?(index)
+      cached = node_cache[:multinomial_with_garbage][index]
       @index = cached.interval.end if cached
       return cached
     end
 
     i0 = index
     i1, s1 = index, []
-    r2 = _nt_species_name
+    r2 = _nt_genus
     s1 << r2
     if r2
       r3 = _nt_space
       s1 << r3
       if r3
-        s4, i4 = [], index
-        loop do
-          if input.index(Regexp.new('[^ш]'), index) == index
-            r5 = instantiate_node(SyntaxNode,input, index...(index + 1))
-            @index += 1
-          else
-            r5 = nil
-          end
+        r4 = _nt_subgenus
+        s1 << r4
+        if r4
+          r5 = _nt_space
+          s1 << r5
           if r5
-            s4 << r5
-          else
-            break
+            r6 = _nt_species
+            s1 << r6
+            if r6
+              r7 = _nt_space_hard
+              s1 << r7
+              if r7
+                r8 = _nt_garbage
+                s1 << r8
+              end
+            end
           end
         end
-        if s4.empty?
-          self.index = i4
-          r4 = nil
-        else
-          r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
-        end
-        s1 << r4
       end
     end
     if s1.last
       r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
-      r1.extend(NamePartWithGarbage0)
-      r1.extend(NamePartWithGarbage1)
+      r1.extend(MultinomialWithGarbage0)
+      r1.extend(MultinomialWithGarbage1)
     else
       self.index = i1
       r1 = nil
@@ -137,53 +212,138 @@ module ScientificNameCanonical
     if r1
       r0 = r1
     else
-      i6, s6 = index, []
-      r7 = _nt_name_part
-      s6 << r7
-      if r7
-        r8 = _nt_space
-        s6 << r8
-        if r8
-          s9, i9 = [], index
-          loop do
-            if input.index(Regexp.new('[^ш]'), index) == index
-              r10 = instantiate_node(SyntaxNode,input, index...(index + 1))
-              @index += 1
-            else
-              r10 = nil
-            end
-            if r10
-              s9 << r10
-            else
-              break
+      i9, s9 = index, []
+      r10 = _nt_genus
+      s9 << r10
+      if r10
+        r11 = _nt_space
+        s9 << r11
+        if r11
+          r12 = _nt_subgenus
+          s9 << r12
+          if r12
+            r13 = _nt_space_hard
+            s9 << r13
+            if r13
+              r14 = _nt_garbage
+              s9 << r14
             end
           end
-          if s9.empty?
-            self.index = i9
-            r9 = nil
-          else
-            r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
-          end
-          s6 << r9
         end
       end
-      if s6.last
-        r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
-        r6.extend(NamePartWithGarbage2)
-        r6.extend(NamePartWithGarbage3)
+      if s9.last
+        r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
+        r9.extend(MultinomialWithGarbage2)
+        r9.extend(MultinomialWithGarbage3)
       else
-        self.index = i6
-        r6 = nil
+        self.index = i9
+        r9 = nil
       end
-      if r6
-        r0 = r6
+      if r9
+        r0 = r9
       else
-        self.index = i0
-        r0 = nil
+        i15, s15 = index, []
+        r16 = _nt_genus
+        s15 << r16
+        if r16
+          r17 = _nt_space
+          s15 << r17
+          if r17
+            r18 = _nt_species
+            s15 << r18
+            if r18
+              r19 = _nt_space_hard
+              s15 << r19
+              if r19
+                r20 = _nt_garbage
+                s15 << r20
+              end
+            end
+          end
+        end
+        if s15.last
+          r15 = instantiate_node(SyntaxNode,input, i15...index, s15)
+          r15.extend(MultinomialWithGarbage4)
+          r15.extend(MultinomialWithGarbage5)
+        else
+          self.index = i15
+          r15 = nil
+        end
+        if r15
+          r0 = r15
+        else
+          self.index = i0
+          r0 = nil
+        end
+      end
+    end
+
+    node_cache[:multinomial_with_garbage][start_index] = r0
+
+    return r0
+  end
+
+  module UninomialWithGarbage0
+    def a
+      elements[0]
+    end
+
+    def space_hard
+      elements[1]
+    end
+
+    def b
+      elements[2]
+    end
+  end
+
+  module UninomialWithGarbage1
+    def value
+      a.value
+    end
+    
+    def canonical
+      a.canonical
+    end
+    
+    def pos
+      a.pos
+    end
+    
+    def details
+      {:uninomial => a.details[:uninomial]}
+    end
+  end
+
+  def _nt_uninomial_with_garbage
+    start_index = index
+    if node_cache[:uninomial_with_garbage].has_key?(index)
+      cached = node_cache[:uninomial_with_garbage][index]
+      @index = cached.interval.end if cached
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_uninomial_epitheton
+    s0 << r1
+    if r1
+      r2 = _nt_space_hard
+      s0 << r2
+      if r2
+        r3 = _nt_garbage
+        s0 << r3
       end
     end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(UninomialWithGarbage0)
+      r0.extend(UninomialWithGarbage1)
+    else
+      self.index = i0
+      r0 = nil
+    end
 
-    node_cache[:name_part_with_garbage][start_index] = r0
+    node_cache[:uninomial_with_garbage][start_index] = r0
 
     return r0
   end
@@ -198,7 +358,7 @@ module ScientificNameCanonical
 
     s0, i0 = [], index
     loop do
-      if input.index(Regexp.new('[.]'), index) == index
+      if input.index(Regexp.new('[^ш]'), index) == index
         r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
         @index += 1
       else
@@ -210,7 +370,12 @@ module ScientificNameCanonical
         break
       end
     end
-    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+    if s0.empty?
+      self.index = i0
+      r0 = nil
+    else
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+    end
 
     node_cache[:garbage][start_index] = r0