nexus_parser 1.2.0 → 1.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 93e9b7ced7b53e19e2cd33c72c433736058c4adcf7555dc6b43635c08f5dcea7
-  data.tar.gz: 4b9bce06037be960e29e1e4f02bbeef286f47a35e977384a5d451e1f0c3e3f91
+  metadata.gz: 4229e2b23de12e3ef92bc88a83aa04805d3884ca09019aaab843846f58fef964
+  data.tar.gz: 7973b5f04b84eea945ce632e5b20844a82c02a9a90c3c18a5ae4bbdaa97376c8
 SHA512:
-  metadata.gz: 2297128f4ad470e7de1760996aaa712ed8bc691fee0a3cc8a59de54cf1b40bcc9d1cd6478049ae14f93b90ea208a93b6bc4872b76ecf8fc99221ea1b583f954d
-  data.tar.gz: 19615c9fcdc2469bf32e681ac3b81b1a4ca8f468a0154671573b73c0e54f247d78b075ee3a2a1d63a4ba21c0cd657dfe656f8140b8feed07ca54d93fadf1772a
+  metadata.gz: cd2739e8dcf4b84287f325a6443227b0b669a45f38c23a20f32bf30cfe88ac7eb34b5a6af6b0929c9af7b55c21b9096e683543528858527920dccfadff10d425
+  data.tar.gz: 40780dadb8ddc80554ca199e6ea9f0ffb5672db51c66c1b41390a25cf4f4c39e2b27799f644a293135b848b9feb3af0fc4cab338e5fe7f40ba670dcaad384965

data/.gitignore

@@ -13,6 +13,9 @@ tmtags
 ## VIM
 *.swp
 
+## BYEBUG
+.byebug_history
+
 ## PROJECT::GENERAL
 coverage
 rdoc

data/lib/nexus_parser/lexer.rb

@@ -33,18 +33,8 @@ class NexusParser::Lexer
     if @next_token
       return @next_token
     else
-      # check for a match on the specified class first
       if match(token_class)
         return @next_token
-      else
-        # now check all the tokens for a match
-        NexusParser::Tokens.nexus_file_token_list.each {|t|
-          return @next_token if match(t)
-        }
-      end
-      # no match, either end of string or lex-error
-      if @input != ''
-        raise( NexusParser::ParseError, "Lex Error, unknown token at #{@input[0..10]}...", caller)
       else
         return nil
       end

data/lib/nexus_parser/parser.rb

@@ -1,6 +1,6 @@
 
 class NexusParser::Parser
- 
+
   def initialize(lexer, builder)
     @lexer = lexer
     @builder = builder
@@ -10,41 +10,41 @@ class NexusParser::Parser
     # nf = @builder.new_nexus_file # create new local NexusParser instance, nf
     # blks = []
     @lexer.pop(NexusParser::Tokens::NexusStart)
-     
+
     while @lexer.peek(NexusParser::Tokens::BeginBlk)
-       
+
       @lexer.pop(NexusParser::Tokens::BeginBlk) # pop it
-      
+
       if @lexer.peek(NexusParser::Tokens::AuthorsBlk)
         parse_authors_blk
-        
-      # we parse these below 
+
+      # we parse these below
       elsif @lexer.peek(NexusParser::Tokens::TaxaBlk)
-        
+
         @lexer.pop(NexusParser::Tokens::TaxaBlk )
         parse_taxa_blk
-           
+
       elsif @lexer.peek(NexusParser::Tokens::ChrsBlk)
         @lexer.pop(NexusParser::Tokens::ChrsBlk)
         parse_characters_blk
 
       elsif @lexer.peek(NexusParser::Tokens::NotesBlk)
-        @lexer.pop(NexusParser::Tokens::NotesBlk)  
+        @lexer.pop(NexusParser::Tokens::NotesBlk)
         parse_notes_blk
 
       # we should parse this
       elsif @lexer.peek(NexusParser::Tokens::SetsBlk)
         @lexer.pop(NexusParser::Tokens::SetsBlk)
 
-      # we don't parse these 
+      # we don't parse these
       elsif @lexer.peek(NexusParser::Tokens::TreesBlk)
         @foo =  @lexer.pop(NexusParser::Tokens::TreesBlk).value
- 
+
       elsif @lexer.peek(NexusParser::Tokens::LabelsBlk)
         @lexer.pop(NexusParser::Tokens::LabelsBlk)
-   
+
       elsif @lexer.peek(NexusParser::Tokens::MqCharModelsBlk)
-        @lexer.pop(NexusParser::Tokens::MqCharModelsBlk) 
+        @lexer.pop(NexusParser::Tokens::MqCharModelsBlk)
 
       elsif @lexer.peek(NexusParser::Tokens::AssumptionsBlk)
         @lexer.pop(NexusParser::Tokens::AssumptionsBlk)
@@ -52,7 +52,7 @@ class NexusParser::Parser
       elsif @lexer.peek(NexusParser::Tokens::CodonsBlk)
         @lexer.pop(NexusParser::Tokens::CodonsBlk)
       end
-      
+
     end
   end
 
@@ -70,15 +70,15 @@ class NexusParser::Parser
 
      #   while @lexer.peek(NexusParser::Tokens::ValuePair)
      #     # IMPORTANT, these are going to a general hash, there may ultimately be overlap of keys used in different blocks, this is ignored at present
-     #     @builder.add_var(@lexer.pop(NexusParser::Tokens::ValuePair).value) 
+     #     @builder.add_var(@lexer.pop(NexusParser::Tokens::ValuePair).value)
      #   end
-        
+
         #@lexer.pop(NexusParser::Tokens::ID) if @lexer.peek(NexusParser::Tokens::ID)
      # end
     #end
   end
 
-  def parse_taxa_blk 
+  def parse_taxa_blk
     @lexer.pop(NexusParser::Tokens::Title) if @lexer.peek(NexusParser::Tokens::Title)
 
     # need to not ignore to test against
@@ -88,7 +88,7 @@ class NexusParser::Parser
     while true
       inf += 1
       raise(NexusParser::ParseError,"Either you have a gazillion taxa or more likely the parser is caught in an infinite loop trying to parser taxon labels. Check for double single quotes in this block.") if inf > 100000
-    
+
       if @lexer.peek(NexusParser::Tokens::EndBlk)
         @lexer.pop(NexusParser::Tokens::EndBlk)
         break
@@ -98,51 +98,53 @@ class NexusParser::Parser
           @lexer.pop(NexusParser::Tokens::Taxlabels) if @lexer.peek(NexusParser::Tokens::Taxlabels)
           i = 0
           while @lexer.peek(NexusParser::Tokens::Label)
-            @builder.update_taxon(:index => i, :name => @lexer.pop(NexusParser::Tokens::Label).value) 
+            @builder.update_taxon(:index => i, :name => @lexer.pop(NexusParser::Tokens::Label).value)
             i += 1
-          end 
+          end
           @lexer.pop(NexusParser::Tokens::SemiColon) if @lexer.peek(NexusParser::Tokens::SemiColon) # close of tax labels, placement of this seems dubious... but tests are working
-        
+
         elsif  @lexer.peek(NexusParser::Tokens::MesquiteIDs)
 
           @lexer.pop(NexusParser::Tokens::MesquiteIDs) # trashing these for now
         elsif  @lexer.peek(NexusParser::Tokens::MesquiteBlockID)
-          @lexer.pop(NexusParser::Tokens::MesquiteBlockID) 
+          @lexer.pop(NexusParser::Tokens::MesquiteBlockID)
         end
-        
+
       end
     end
 
 
   end
 
-  def parse_characters_blk 
-    
-    inf = 0 
+  def parse_characters_blk
+
+    inf = 0
     while true
       inf += 1
       raise(NexusParser::ParseError,"Either you have a gazillion characters or more likely the parser is caught in an infinite loop trying to parser character data. Check for double single quotes in this block.") if inf > 100000
 
       if @lexer.peek(NexusParser::Tokens::EndBlk) # we're at the end of the block, exit after geting rid of the semi-colon
-        break 
+        break
       else
         @lexer.pop(NexusParser::Tokens::Title) if @lexer.peek(NexusParser::Tokens::Title) # not used at present
         @lexer.pop(NexusParser::Tokens::LinkLine) if @lexer.peek(NexusParser::Tokens::LinkLine) # trashing these for now
-        
+
         parse_dimensions if @lexer.peek(NexusParser::Tokens::Dimensions)
-        parse_format if @lexer.peek(NexusParser::Tokens::Format) 
-        
+        parse_format if @lexer.peek(NexusParser::Tokens::Format)
+
         parse_chr_state_labels if @lexer.peek(NexusParser::Tokens::CharStateLabels)
 
-        parse_matrix if @lexer.peek(NexusParser::Tokens::Matrix) 
-    
+        parse_chr_labels if @lexer.peek(NexusParser::Tokens::CharLabels)
+
+        parse_state_labels if @lexer.peek(NexusParser::Tokens::StateLabels)
+
+        parse_matrix if @lexer.peek(NexusParser::Tokens::Matrix)
+
         # handle "\s*OPTIONS MSTAXA = UNCERTAIN;\s\n" within a characters block (sticks in an infinite loop right now)
 
 
         @lexer.pop(NexusParser::Tokens::MesquiteIDs) if @lexer.peek(NexusParser::Tokens::MesquiteIDs) # trashing these for now
         @lexer.pop(NexusParser::Tokens::MesquiteBlockID) if @lexer.peek(NexusParser::Tokens::MesquiteBlockID) # trashing these for now
-    
-        false
       end
     end
     @lexer.pop(NexusParser::Tokens::EndBlk)
@@ -150,21 +152,23 @@ class NexusParser::Parser
 
   # prolly pop header then fuse with parse_dimensions
   def parse_format
-    @lexer.pop(NexusParser::Tokens::Format) 
-    while @lexer.peek(NexusParser::Tokens::ValuePair)
-      @builder.add_var(@lexer.pop(NexusParser::Tokens::ValuePair).value)
+    @lexer.pop(NexusParser::Tokens::Format)
+
+    while @lexer.peek(NexusParser::Tokens::ValuePair) || @lexer.peek(NexusParser::Tokens::RespectCase)
+      @lexer.pop(NexusParser::Tokens::RespectCase) if @lexer.peek(NexusParser::Tokens::RespectCase) # !! TODO: nothing is set, respect case is ignored
+      @builder.add_var(@lexer.pop(NexusParser::Tokens::ValuePair).value) if @lexer.peek(NexusParser::Tokens::ValuePair)
     end
 
     check_initialization_of_ntax_nchar
   end
 
-  def parse_dimensions  
+  def parse_dimensions
     @lexer.pop(NexusParser::Tokens::Dimensions)
     while @lexer.peek(NexusParser::Tokens::ValuePair)
       @builder.add_var(@lexer.pop(NexusParser::Tokens::ValuePair).value)
     end
     # the last value pair with a ; is automagically handled, don't try popping it again
-    
+
     check_initialization_of_ntax_nchar
   end
 
@@ -173,7 +177,7 @@ class NexusParser::Parser
     if @builder.nexus_file.vars[:nchar] && @builder.nexus_file.characters == []
       (0..(@builder.nexus_file.vars[:nchar].to_i - 1)).each {|i| @builder.stub_chr }
     end
-    
+
     # check for taxa dimensions, if otherwise not set generate them
     if @builder.nexus_file.vars[:ntax] && @builder.nexus_file.taxa == []
       (0..(@builder.nexus_file.vars[:ntax].to_i - 1)).each {|i| @builder.stub_taxon }
@@ -182,45 +186,108 @@ class NexusParser::Parser
 
   def parse_chr_state_labels
     @lexer.pop(NexusParser::Tokens::CharStateLabels)
- 
-    inf = 0 
+
+    inf = 0
     while true
       inf += 1
       raise(NexusParser::ParseError,"Either you have a gazillion character state labels or more likely the parser is caught in an infinite loop while trying to parser character state labels. Check for double single quotes in this block.") if inf > 100000
 
-      if @lexer.peek(NexusParser::Tokens::SemiColon)    
-        break 
+      if @lexer.peek(NexusParser::Tokens::SemiColon)
+        break
       else
         opts = {}
-        
         name = ""
-        index = @lexer.pop(NexusParser::Tokens::Number).value.to_i
-        (name = @lexer.pop(NexusParser::Tokens::Label).value) if @lexer.peek(NexusParser::Tokens::Label) # not always given a letter
+
+        index = @lexer.pop(NexusParser::Tokens::PositiveInteger).value.to_i
+
+        (name = @lexer.pop(NexusParser::Tokens::CharacterLabel).value) if @lexer.peek(NexusParser::Tokens::CharacterLabel) # not always given a letter
 
         @lexer.pop(NexusParser::Tokens::BckSlash) if @lexer.peek(NexusParser::Tokens::BckSlash)
 
         if !@lexer.peek(NexusParser::Tokens::Comma) || !@lexer.peek(NexusParser::Tokens::SemiColon)
           i = 0
 
-          # three kludge lines, need to figure out the label/number priority, could be issue in list order w/in tokens
-          while @lexer.peek(NexusParser::Tokens::Label) || @lexer.peek(NexusParser::Tokens::Number)
-            opts.update({i.to_s => @lexer.pop(NexusParser::Tokens::Label).value}) if @lexer.peek(NexusParser::Tokens::Label)
-            opts.update({i.to_s => @lexer.pop(NexusParser::Tokens::Number).value.to_s}) if @lexer.peek(NexusParser::Tokens::Number)
+          while @lexer.peek(NexusParser::Tokens::CharacterLabel)
+            opts.update({
+              i.to_s => @lexer.pop(NexusParser::Tokens::CharacterLabel).value
+            })
 
             i += 1
-          end  
+          end
         end
 
         @lexer.pop(NexusParser::Tokens::Comma) if @lexer.peek(NexusParser::Tokens::Comma) # we may also have hit semicolon
-        
+
         opts.update({:index => (index - 1), :name => name})
-       
+
         raise(NexusParser::ParseError, "Error parsing character state labels for (or around) character #{index - 1}.") if !opts[:name]
         @builder.update_chr(opts)
-      end     
+      end
+
+    end
+    @lexer.pop(NexusParser::Tokens::SemiColon)
+  end
+
+  def parse_chr_labels
+    @lexer.pop(NexusParser::Tokens::CharLabels)
+
+    inf = 0
+    while true
+      inf += 1
+      raise(NexusParser::ParseError,"Either you have a gazillion character labels or more likely the parser is caught in an infinite loop while trying to parse character labels. Check for double single quotes in this block.") if inf > 100000
+
+      if @lexer.peek(NexusParser::Tokens::SemiColon)
+        break
+      else
+        i = 0
+        while @lexer.peek(NexusParser::Tokens::CharacterLabel)
+          @builder.update_chr_name(
+            i, @lexer.pop(NexusParser::Tokens::CharacterLabel).value
+          )
+
+          i += 1
+        end
+      end
+    end
+    @lexer.pop(NexusParser::Tokens::SemiColon)
+  end
+
+  def parse_state_labels
+    @lexer.pop(NexusParser::Tokens::StateLabels)
+
+    inf = 0
+    while true
+      inf += 1
+      raise(NexusParser::ParseError,"Either you have a gazillion state labels or more likely the parser is caught in an infinite loop while trying to parse state labels. Check for double single quotes in this block.") if inf > 100000
+
+      if @lexer.peek(NexusParser::Tokens::SemiColon)
+        break
+      else
+        opts = {}
+
+        index = @lexer.pop(NexusParser::Tokens::PositiveInteger).value.to_i
+
+        if !@lexer.peek(NexusParser::Tokens::Comma) && !@lexer.peek(NexusParser::Tokens::SemiColon)
+          i = 0
+
+          while @lexer.peek(NexusParser::Tokens::CharacterLabel)
+            opts.update({
+              i.to_s => @lexer.pop(NexusParser::Tokens::CharacterLabel).value
+            })
+
+            i += 1
+          end
+        end
+
+        @lexer.pop(NexusParser::Tokens::Comma) if @lexer.peek(NexusParser::Tokens::Comma) # we may also have hit semicolon
+
+        opts.update({:index => (index - 1)})
+
+        @builder.update_chr_states(opts)
+      end
 
     end
-    @lexer.pop(NexusParser::Tokens::SemiColon) 
+    @lexer.pop(NexusParser::Tokens::SemiColon)
   end
 
   def parse_matrix
@@ -228,25 +295,25 @@ class NexusParser::Parser
     i = 0
       while true
         if @lexer.peek(NexusParser::Tokens::SemiColon)
-         break 
+         break
         else
           t = @lexer.pop(NexusParser::Tokens::Label).value
 
           @builder.update_taxon(:index => i, :name => t) # if it exists its not re-added
 
           @builder.code_row(i, @lexer.pop(NexusParser::Tokens::RowVec).value)
-      
+
           i += 1
         end
       end
-    @lexer.pop(NexusParser::Tokens::SemiColon) # pop the semicolon 
+    @lexer.pop(NexusParser::Tokens::SemiColon) # pop the semicolon
   end
 
   # this suck(s/ed), it needs work when a better API for Mesquite comes out
   def parse_notes_blk
     # IMPORTANT - we don't parse the (CM <note>), we just strip the "(CM" ... ")" bit for now in NexusParser::Note
 
-    @vars = {} 
+    @vars = {}
     inf = 0 # a crude iteration checker
     while true
       inf += 1
@@ -259,18 +326,20 @@ class NexusParser::Parser
 
         if @lexer.peek(NexusParser::Tokens::ValuePair)
           @vars.update(@lexer.pop(NexusParser::Tokens::ValuePair).value)
-      
-        elsif @lexer.peek(NexusParser::Tokens::Label)
-          if @vars[:type] # we have the data for this row write it, and start a new one    
-            
+
+        elsif @lexer.peek(NexusParser::Tokens::FileLbl)
+          @lexer.pop(NexusParser::Tokens::FileLbl)
+          @vars.update(:file => 'file') # we check for whether :file key is present and handle conditionally
+
+        else @lexer.peek(NexusParser::Tokens::Label)
+          # If we already have a :type set then the Label we just peeked starts a
+          # new row, so write the current one and then start a new one.
+          if @vars[:type]
             @builder.add_note(@vars)
             @vars = {}
-          else
-            @vars.update(:type => @lexer.pop(NexusParser::Tokens::Label).value)
           end
-        elsif @lexer.peek(NexusParser::Tokens::FileLbl)  
-          @lexer.pop(NexusParser::Tokens::FileLbl)
-          @vars.update(:file => 'file') # we check for whether :file key is present and handle conditionally
+
+          @vars.update(:type => @lexer.pop(NexusParser::Tokens::Label).value)
         end
       end
     end
@@ -278,9 +347,9 @@ class NexusParser::Parser
 
     #@vars = {}
     #while true
-      
-    #  break if  @lexer.peek(NexusParser::Tokens::EndBlk)   
-      
+
+    #  break if  @lexer.peek(NexusParser::Tokens::EndBlk)
+
     #  @vars.update(:type => @lexer.pop(NexusParser::Tokens::Label).value)
 
       # kludge to get around the funny construct that references file
@@ -291,11 +360,11 @@ class NexusParser::Parser
 
      #   while true
 
-     #     meh = @lexer.pop(NexusParser::Tokens::ValuePair)          
+     #     meh = @lexer.pop(NexusParser::Tokens::ValuePair)
      #     @vars.update(meh.value)
      #     break if !@lexer.peek(NexusParser::Tokens::ValuePair)
      #   end
-     #   
+     #
      #   @builder.add_note(@vars)
      #   @vars = {}
     #end
@@ -324,7 +393,7 @@ class NexusParser::Parser
     # nor this
   end
 
-  
+
   def parse_mesquite_blk
 
   end
@@ -333,7 +402,7 @@ class NexusParser::Parser
 
   # def parse_children(parent)
   # parse a comma-separated list of nodes
-  #  while true 
+  #  while true
   #    parse_node(parent)
   #    if @lexer.peek(NexusParser::Tokens::Comma)
   #      @lexer.pop(NexusParser::Tokens::Comma)
@@ -342,7 +411,7 @@ class NexusParser::Parser
   #    end
   #  end
   # end
-  
+
 end