swissparser 0.6.0 → 0.7.0

data/History.txt

@@ -1,3 +1,10 @@
+== 0.7.0 / 2009-11-14
+
+* *Important* *change*: SwissParser is now required with:
+  require 'swissparser' 
+
+* Examples: added the example for tutorial 1.
+
 == 0.6.0 / 2009-11-13
 
 * 2 new features

data/Rakefile

@@ -5,7 +5,7 @@ rescue LoadError
 end
 
 ensure_in_path 'lib'
-require 'swiss_parser'
+require 'swissparser'
 
 #task :default => 'test:run'
 #task 'gem:release' => 'test:run'

data/examples/kegg_demo.rb

@@ -17,7 +17,7 @@ You should have received a copy of the GNU General Public License
 along with SwissParser.  If not, see <http://www.gnu.org/licenses/>.
 =end
 
-require 'swiss_parser.rb'
+require 'swissparser.rb'
 require 'yaml'
 
 class Enzyme

data/examples/signal_demo.rb

@@ -17,7 +17,7 @@ You should have received a copy of the GNU General Public License
 along with SwissParser.  If not, see <http://www.gnu.org/licenses/>.
 =end
 
-require 'swiss_parser.rb'
+require 'swissparser.rb'
 require 'yaml'
 
 class Protein

data/examples/{uniprot_demo.rb → tutorial_1.rb}

@@ -20,7 +20,7 @@ along with SwissParser.  If not, see <http://www.gnu.org/licenses/>.
 #!/usr/bin/ruby -w
 
 require 'yaml'
-require 'swiss_parser.rb'
+require 'swissparser.rb'
 
 class Protein
 
@@ -33,48 +33,53 @@ class Protein
 
 end
 
+module Uniprot
 
-uniprot_parser = Swiss::Parser.define do
+  Parser = Swiss::Parser.define do
 
-  new_entry do
-    Protein.new
-  end
-
-  rules do 
-
-    with("ID") do |content,protein|
-      content =~ /([A-Z]\w+)\D+(\d+)/
-      protein.id = $1
-      protein.size = $2.to_i
+    # Each entry must be stored in a Protein instance
+    new_entry do
+      Protein.new
     end
     
-    with("OS") do |content,protein|
-      content =~ /(\w+ \w+)/
-      protein.species = $1
+    rules do 
+      
+      # Parse the uniprot id
+      with("ID") do |content,protein|
+        content =~ /([A-Z]\w+)\D+(\d+)/
+        protein.id = $1
+        protein.size = $2.to_i
+      end
+      
+      # Parse the organism
+      with("OS") do |content,protein|
+        content =~ /(\w+ \w+)/
+        protein.species = $1
+      end
+      
+      # Parse the complete taxonomy
+      with("OC") do |content,protein|
+        ary = content.gsub(".","").split("; ")
+        protein.taxonomy += ary
+      end
+      
+      # Parse the Sequence
+      with_text_after("SQ") do |content,protein|
+        seq = content.strip.gsub(" ","")
+        protein.sequence += seq
+      end
+      
     end
     
-    with("OC") do |content,protein|
-      ary = content.gsub(".","").split("; ")
-      protein.taxonomy += ary
-    end
-    
-    with_text_after("SQ") do |content,protein|
-      seq = content.strip.gsub(" ","")
-      protein.sequence += seq
-    end
-
   end
-
+  
 end
-
-
+  
 if $0 == __FILE__
-
+    
   filename = ARGV.shift
 
-  entries = uniprot_parser.parse_file( filename )
-
-  puts entries.size
+  entries = Uniprot::Parser.parse_file( filename )
 
   entries.each do |e|
     puts e.to_yaml

data/examples/uniprot_param_demo.rb

@@ -20,7 +20,7 @@ along with SwissParser.  If not, see <http://www.gnu.org/licenses/>.
 #!/usr/bin/ruby -w
 
 require 'yaml'
-require 'swiss_parser.rb'
+require 'swissparser.rb'
 
 class Protein
 

data/lib/swiss_parser.rb

@@ -1,261 +1,13 @@
-=begin
-Copyright (C) 2009 Paradigmatic
+Msg = <<HERE
 
-This file is part of SwissParser.
+=====================================================
+Since version 0.7, SwissParser is now required with:
 
-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.
+  require 'swissparser'
 
-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.
+Please update your code.
+=====================================================
+HERE
 
-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.6.0"
-
-  # This class defines parsing rules. Its methods
-  # are accessible within the +rules+ section of
-  # a parser definition.
-  class ParsingRules
-    
-    attr_reader :separator, :actions
-    
-    # *Do* *not* create directly this class but access it
-    # through a +rules+ section in a parser definition.
-    def initialize
-      @actions = { :text => {} }
-    end
-    
-    # Sets the entry separator line. Default: "//"
-    def set_separator(string)
-      @separator = string
-    end
-
-    # Defines how to parse a line starting with +key+. The +proc+
-    # takes two arguments:
-    # * the rest of the line
-    # * the entry object
-    def with( key, &proc )
-      @actions[key] = proc
-    end
-
-    # Defines how to parse a line without key coming *after*
-    # a specified key. The +proc+ takes two arguments:
-    # * the rest of the line
-    # * the entry object
-    def with_text_after( key, &proc )
-      @actions[:text][key] = proc
-    end
-    
-  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
-    
-    #Default entry separator
-    DEFAULT_SEPARATOR = "//"
-
-    #*Do* *not* *use* this method to instatiate a parser. Use rather
-    #the +define+ class method.
-    def initialize(*args)
-      if args.size == 0
-        @separator = DEFAULT_SEPARATOR
-        @actions = {}
-        @actions[:text] = {}
-        @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
-        @before = before
-        @end = the_end
-        @begin = the_begin
-        @after = after
-        @helpers = helpers
-      else
-        raise "Wrong arg number, either 0 or 7."
-      end
-      @ctx = nil
-    end
-
-    # Defines how to create the _entry_ _object_. The +proc+
-    # 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 two arguments:
-    # * The entry object ready to be finalized
-    # * The context object
-    # 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+ 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 a single argument:
-    # * The context object
-    # 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)
-      r = ParsingRules.new
-      r.instance_eval(&proc)
-      r.actions.each do |k,v|
-        if k == :text
-          next
-        end
-        @actions[k] = v
-        r.actions[:text].each do |k,v|
-          @actions[:text][k] = v
-        end
-        if r.separator
-          @separator = r.separator
-        end
-      end
-    end
-
-
-
-    # Extends an existing parser by allowing to redefine rules. The
-    # changes in the new parser simply replace the original defintions.
-    # 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, @helpers )
-      clone.instance_eval( &proc )
-      clone
-    end
-                    
-    # Defines a new parser. 
-    def self.define( &proc )
-      PROTOTYPE.extend( &proc )
-    end
-
-    # Parses a file specified by +filename+. An optional hash
-    # of arbitrary arguments (+params+) can be specified. It is
-    # passed to the workflow methods blocks (+before+, +new_entry+, ...)
-    # It returns the value specified in the +after+ block. By default, 
-    # it returns an array containing _entry_ objects.
-    def parse_file( filename, params={} )
-      @ctx = ParsingContext.new( params )
-      @ctx.instance_exec( &@helpers )
-      container = @ctx.instance_exec( &@before )
-      File.open( filename, 'r' ) do |file|
-        entry = @ctx.instance_exec( &@begin )
-        file.each_line do |line|
-          state = parse_line( line, entry )
-          if state == :end
-            @ctx.instance_exec( entry, container, &@end )
-            entry = @ctx.instance_exec( &@begin )
-          end
-        end
-      end
-      @ctx.instance_exec( container, &@after )
-    end
-
-    private
-
-    PROTOTYPE = Parser.new
-    PROTOTYPE.instance_eval do
-      before { || [] }
-      new_entry { || {} }
-      finish_entry {|e,c| c << e }
-      after {|c| c }
-    end
-
-    
-    def parse_line( line, holder )
-      line.chomp!
-      if line == @separator
-        :end
-      elsif line =~ /^(\S+)\s+(.*)$/
-        key,value = $1,$2
-        @last_key = key
-        if @actions[key]
-          @ctx.instance_exec( value, holder, &@actions[key] )
-        end
-        :parsing
-      else
-        if @actions[:text][@last_key]
-          @ctx.instance_exec( line, holder, &@actions[:text][@last_key] )
-        end
-        :parsing
-      end
-    end
-    
-  end
-
-end
+fail(Msg)

data/lib/swissparser.rb

@@ -0,0 +1,261 @@
+=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
+
+module Swiss
+
+  VERSION = "0.7.0"
+
+  # This class defines parsing rules. Its methods
+  # are accessible within the +rules+ section of
+  # a parser definition.
+  class ParsingRules
+    
+    attr_reader :separator, :actions
+    
+    # *Do* *not* create directly this class but access it
+    # through a +rules+ section in a parser definition.
+    def initialize
+      @actions = { :text => {} }
+    end
+    
+    # Sets the entry separator line. Default: "//"
+    def set_separator(string)
+      @separator = string
+    end
+
+    # Defines how to parse a line starting with +key+. The +proc+
+    # takes two arguments:
+    # * the rest of the line
+    # * the entry object
+    def with( key, &proc )
+      @actions[key] = proc
+    end
+
+    # Defines how to parse a line without key coming *after*
+    # a specified key. The +proc+ takes two arguments:
+    # * the rest of the line
+    # * the entry object
+    def with_text_after( key, &proc )
+      @actions[:text][key] = proc
+    end
+    
+  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
+    
+    #Default entry separator
+    DEFAULT_SEPARATOR = "//"
+
+    #*Do* *not* *use* this method to instatiate a parser. Use rather
+    #the +define+ class method.
+    def initialize(*args)
+      if args.size == 0
+        @separator = DEFAULT_SEPARATOR
+        @actions = {}
+        @actions[:text] = {}
+        @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
+        @before = before
+        @end = the_end
+        @begin = the_begin
+        @after = after
+        @helpers = helpers
+      else
+        raise "Wrong arg number, either 0 or 7."
+      end
+      @ctx = nil
+    end
+
+    # Defines how to create the _entry_ _object_. The +proc+
+    # 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 two arguments:
+    # * The entry object ready to be finalized
+    # * The context object
+    # 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+ 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 a single argument:
+    # * The context object
+    # 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)
+      r = ParsingRules.new
+      r.instance_eval(&proc)
+      r.actions.each do |k,v|
+        if k == :text
+          next
+        end
+        @actions[k] = v
+        r.actions[:text].each do |k,v|
+          @actions[:text][k] = v
+        end
+        if r.separator
+          @separator = r.separator
+        end
+      end
+    end
+
+
+
+    # Extends an existing parser by allowing to redefine rules. The
+    # changes in the new parser simply replace the original defintions.
+    # 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, @helpers )
+      clone.instance_eval( &proc )
+      clone
+    end
+                    
+    # Defines a new parser. 
+    def self.define( &proc )
+      PROTOTYPE.extend( &proc )
+    end
+
+    # Parses a file specified by +filename+. An optional hash
+    # of arbitrary arguments (+params+) can be specified. It is
+    # passed to the workflow methods blocks (+before+, +new_entry+, ...)
+    # It returns the value specified in the +after+ block. By default, 
+    # it returns an array containing _entry_ objects.
+    def parse_file( filename, params={} )
+      @ctx = ParsingContext.new( params )
+      @ctx.instance_exec( &@helpers )
+      container = @ctx.instance_exec( &@before )
+      File.open( filename, 'r' ) do |file|
+        entry = @ctx.instance_exec( &@begin )
+        file.each_line do |line|
+          state = parse_line( line, entry )
+          if state == :end
+            @ctx.instance_exec( entry, container, &@end )
+            entry = @ctx.instance_exec( &@begin )
+          end
+        end
+      end
+      @ctx.instance_exec( container, &@after )
+    end
+
+    private
+
+    PROTOTYPE = Parser.new
+    PROTOTYPE.instance_eval do
+      before { || [] }
+      new_entry { || {} }
+      finish_entry {|e,c| c << e }
+      after {|c| c }
+    end
+
+    
+    def parse_line( line, holder )
+      line.chomp!
+      if line == @separator
+        :end
+      elsif line =~ /^(\S+)\s+(.*)$/
+        key,value = $1,$2
+        @last_key = key
+        if @actions[key]
+          @ctx.instance_exec( value, holder, &@actions[key] )
+        end
+        :parsing
+      else
+        if @actions[:text][@last_key]
+          @ctx.instance_exec( line, holder, &@actions[:text][@last_key] )
+        end
+        :parsing
+      end
+    end
+    
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: swissparser
 version: !ruby/object:Gem::Version 
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors: 
 - paradigmatic
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-13 00:00:00 +01:00
+date: 2009-11-14 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -41,9 +41,10 @@ files:
 - examples/data/uniprot.txt
 - examples/kegg_demo.rb
 - examples/signal_demo.rb
-- examples/uniprot_demo.rb
+- examples/tutorial_1.rb
 - examples/uniprot_param_demo.rb
 - lib/swiss_parser.rb
+- lib/swissparser.rb
 has_rdoc: true
 homepage: http://github.com/paradigmatic/SwissParser
 licenses: []