swissparser 0.5.1 → 0.6.0

data/History.txt

@@ -1,3 +1,11 @@
+== 0.6.0 / 2009-11-13
+
+* 2 new features
+  - Parsing parameters are now accessed thru the +params+ method
+    and are accessible to parsing rules too.
+  - Helpers methods are now defined in an helper block and are
+    accessible to actions too.
+
 == 0.5.1 / 2009-11-13
 
 * Added basic RDOC documentation.

data/examples/kegg_demo.rb

@@ -30,12 +30,13 @@ end
 enzyme_parser = Swiss::Parser.define do
   
   
-  new_entry do |params|
+  new_entry do
     { :genes => [] }
   end
-  
-  rules do
 
+
+  helpers do
+    
     def parse_gene_ids( string, entry )
       string.split(" ").each do |item|
         if item =~ /(\d+)\(\w+\)/
@@ -43,7 +44,11 @@ enzyme_parser = Swiss::Parser.define do
         end
       end
     end
+  end
     
+  
+  rules do
+
     human = "HSA"
   
     set_separator( "///" )
@@ -76,7 +81,7 @@ enzyme_parser = Swiss::Parser.define do
 
   end
   
-  finish_entry do |entry,container,params|
+  finish_entry do |entry,container|
     if entry[:genes].size > 0
       e = Enzyme.new
       e.id = entry[:id]

data/examples/signal_demo.rb

@@ -53,11 +53,11 @@ end
 
 stat_parser = parser.extend do
 
-  before do |params|
+  before do
     { :min => 1_000, :max => 0, :sum => 0, :n => 0 }
   end 
 
-  finish_entry do |entry,h,params|
+  finish_entry do |entry,h|
     if entry.size < h[:min]
       h[:min] = entry.size
     end
@@ -68,7 +68,7 @@ stat_parser = parser.extend do
     h[:n] += 1
   end
 
-  after do |h,params|
+  after do |h|
     h[:average] = h[:sum].to_f / h[:n]
     h
   end

data/examples/uniprot_param_demo.rb

@@ -0,0 +1,85 @@
+=begin
+Copyright (C) 2009 Paradigmatic
+
+This file is part of SwissParser.
+
+SwissParser is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+SwissParser is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with SwissParser.  If not, see <http://www.gnu.org/licenses/>.
+=end
+
+#!/usr/bin/ruby -w
+
+require 'yaml'
+require 'swiss_parser.rb'
+
+class Protein
+
+  attr_accessor :id, :size, :species, :taxonomy, :sequence
+
+  def initialize
+    @taxonomy = []
+    @sequence = ""
+  end
+
+end
+
+
+uniprot_parser = Swiss::Parser.define do
+
+  new_entry do
+    puts param(:msg)
+    Protein.new
+  end
+
+  rules do 
+
+    with("ID") do |content,protein|
+      content =~ /([A-Z]\w+)\D+(\d+)/
+      protein.id = $1
+      protein.size = $2.to_i
+    end
+    
+    with("OS") do |content,protein|
+      content =~ /(\w+ \w+)/
+      protein.species = $1
+    end
+    
+    with("OC") do |content,protein|
+      ary = content.gsub(".","").split("; ")
+      protein.taxonomy += ary
+    end
+    
+    with_text_after("SQ") do |content,protein|
+      puts param(:found_seq)
+      seq = content.strip.gsub(" ","")
+      protein.sequence += seq
+    end
+
+  end
+
+end
+
+
+if $0 == __FILE__
+
+  filename = ARGV.shift
+
+  entries = uniprot_parser.parse_file( filename, :msg => "Hello", :found_seq => "Youpie" )
+
+  puts entries.size
+
+  entries.each do |e|
+    puts e.to_yaml
+  end
+
+end

data/lib/swiss_parser.rb

@@ -17,11 +17,9 @@ You should have received a copy of the GNU General Public License
 along with SwissParser.  If not, see <http://www.gnu.org/licenses/>.
 =end
 
-
-
 module Swiss
 
-  VERSION = "0.5.1"
+  VERSION = "0.6.0"
 
   # This class defines parsing rules. Its methods
   # are accessible within the +rules+ section of
@@ -59,6 +57,47 @@ module Swiss
     
   end
 
+  # Methods of this class are accessible to rules and actions.
+  # Methods defined in +helpers+ block are added to this class.
+  class ParsingContext
+
+    def initialize(parameters)
+      @params = parameters
+    end   
+
+    # Retrieves a parsing parameter by key. Returns nil if 
+    # there is no parameter with the provided key.
+    def param( key ) 
+      @params[key]
+    end
+
+
+    module InstanceExecHelper     #:nodoc:
+    end 
+    
+    include InstanceExecHelper
+
+    #Used to execute rules and action using the ParsingContext as context
+    #Stolen from http://eigenclass.org/hiki/bounded+space+instance_exec
+    def instance_exec(*args, &block)
+      begin
+        old_critical, Thread.critical = Thread.critical, true
+        n = 0
+        n += 1 while respond_to?(mname="__instance_exec#{n}")
+        InstanceExecHelper.module_eval{ define_method(mname, &block) }
+      ensure
+        Thread.critical = old_critical
+      end
+      begin
+        ret = send(mname, *args)
+      ensure
+        InstanceExecHelper.module_eval{ remove_method(mname) } rescue nil
+      end
+      ret
+    end 
+    
+  end
+
 
   # Parser for a typical bioinformatic flat file.
   class Parser
@@ -73,8 +112,9 @@ module Swiss
         @separator = DEFAULT_SEPARATOR
         @actions = {}
         @actions[:text] = {}
-      elsif args.size == 6
-        actions,separator,before,the_begin,the_end,after = *args
+        @helpers = lambda {}
+      elsif args.size == 7
+        actions,separator,before,the_begin,the_end,after,helpers = *args
         @actions = actions.clone
         @actions[:text] = actions[:text].clone
         @separator = separator
@@ -82,47 +122,52 @@ module Swiss
         @end = the_end
         @begin = the_begin
         @after = after
+        @helpers = helpers
       else
-        raise "Wrong arg number, either 0 or 6."
+        raise "Wrong arg number, either 0 or 7."
       end
+      @ctx = nil
     end
 
     # Defines how to create the _entry_ _object_. The +proc+
-    # takes a single argument which is a hash containing
-    # parsing options. It must return a new _entry_ _object_.
+    # does not take arguments, but it must return a new 
+    # _entry_ _object_.
     # Default:: creates an empty hash.
     def new_entry(&proc)
        @begin = proc
     end
 
     # Defines how to finalize an _entry_ _object_. The +proc+
-    # takes three arguments:
+    # takes two arguments:
     # * The entry object ready to be finalized
     # * The context object
-    # * An hash containing parsing options. 
     # Default:: Adds the entry object to the context object using +<<+ method.
     def finish_entry(&proc)
       @end = proc
     end
     
     # Defines how to set the context before using the parser.
-    # The +proc+ takes a single argument which is a hash containing
-    # parsing options. It must return a _context_ object.
+    # The +proc+ does not take arguments. It must return a _context_ object.
     # Default:: creates an empty array
     def before (&proc)
       @before = proc
     end
 
     # Defines how to finalize the whole parsing.
-    # The +proc+ takes two arguments:
+    # The +proc+ takes a single argument:
     # * The context object
-    # * An hash containing parsing options. 
     # The value returned by the +proc+ is then returned by the parsing method.
     # Default:: just returns the context object.
     def after(&proc)
       @after = proc
     end
 
+    # Helpers methods accessible to rules and actions can be
+    # defined using this method.
+    def helpers(&proc)
+      @helpers = proc
+    end
+
     # Defines parsing rules inside a parser definition. The ParsingRules
     # methods can then be called inside the proc.
     def rules(&proc)
@@ -149,7 +194,7 @@ module Swiss
     # After extension, the new parser is independent of the original one,
     # i.e. a change to the original parser will not affect the derived one.
     def extend(&proc)
-      clone = Parser.new( @actions, @separator, @before, @begin, @end, @after )
+      clone = Parser.new( @actions, @separator, @before, @begin, @end, @after, @helpers )
       clone.instance_eval( &proc )
       clone
     end
@@ -165,28 +210,30 @@ module Swiss
     # It returns the value specified in the +after+ block. By default, 
     # it returns an array containing _entry_ objects.
     def parse_file( filename, params={} )
-      context = @before.call( params )
+      @ctx = ParsingContext.new( params )
+      @ctx.instance_exec( &@helpers )
+      container = @ctx.instance_exec( &@before )
       File.open( filename, 'r' ) do |file|
-        entry = @begin.call( params )
+        entry = @ctx.instance_exec( &@begin )
         file.each_line do |line|
           state = parse_line( line, entry )
           if state == :end
-            @end.call( entry, context, params )
-            entry = @begin.call( params )
+            @ctx.instance_exec( entry, container, &@end )
+            entry = @ctx.instance_exec( &@begin )
           end
         end
       end
-      @after.call( context, params )
+      @ctx.instance_exec( container, &@after )
     end
 
     private
 
     PROTOTYPE = Parser.new
     PROTOTYPE.instance_eval do
-      before { |p| [] }
-      new_entry { |p| {} }
-      finish_entry {|e,c,p| c << e }
-      after {|c,p| c }
+      before { || [] }
+      new_entry { || {} }
+      finish_entry {|e,c| c << e }
+      after {|c| c }
     end
 
     
@@ -198,12 +245,12 @@ module Swiss
         key,value = $1,$2
         @last_key = key
         if @actions[key]
-          @actions[key].call( value, holder )
+          @ctx.instance_exec( value, holder, &@actions[key] )
         end
         :parsing
       else
         if @actions[:text][@last_key]
-          @actions[:text][@last_key].call( line, holder )
+          @ctx.instance_exec( line, holder, &@actions[:text][@last_key] )
         end
         :parsing
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: swissparser
 version: !ruby/object:Gem::Version 
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors: 
 - paradigmatic
@@ -42,6 +42,7 @@ files:
 - examples/kegg_demo.rb
 - examples/signal_demo.rb
 - examples/uniprot_demo.rb
+- examples/uniprot_param_demo.rb
 - lib/swiss_parser.rb
 has_rdoc: true
 homepage: http://github.com/paradigmatic/SwissParser