swissparser 0.11.1 → 1.0.0

data/features/step_definitions/sugar_steps.rb

@@ -0,0 +1,71 @@
+require 'rspec'
+require 'rspec/mocks'
+
+Given /^I define a simple rule to return option "([^\"]*)" with "([^\"]*)"$/ do |opt_key, key|
+  @rules = @rules.refine do
+    with( key ) do |content|
+      @text = option( opt_key )
+    end
+  end
+end
+
+Given /^I set option "([^\"]*)" = "([^\"]*)"$/ do |key, val|
+  if @opt.nil?
+    @opt = {}
+  end
+  @opt[key] = val
+end
+
+Given /^I define a simple rule to return "bar" via helper with "([^\"]*)"$/ do |key|
+    @rules = @rules.refine do
+    helpers do
+      def foo( )
+        "bar"
+      end
+    end
+    with( key ) do |content|
+      @text = foo
+    end
+
+  end
+end
+
+Given /^I define and helper "foo" which returns "([^\"]*)"$/ do |value|
+  @rules = @rules.refine do
+    helpers do
+      def foob( )
+        value
+      end
+    end
+  end
+end
+
+When /^I run the parser on file "([^\"]*)"$/ do |filename|
+  RSpec::Mocks::setup(File)
+  File.stub(:open){ @data }
+  if @opt
+    @result = @parser.parse_file( filename, @opt )
+  else
+    @result = @parser.parse_file( filename )
+  end
+end
+
+
+When /^I run it on remote file "([^\"]*)"$/ do |uri|
+  RSpec::Mocks::setup(OpenURI)
+  OpenURI.stub(:open_uri) { @data }
+  if @opt
+    @result = @parser.parse_uri( uri, @opt )
+  else
+    @result = @parser.parse_uri( uri )
+  end
+end
+
+Then /^File\.open should be called with "([^\"]*)"$/ do |filename|
+  File.should_receive(:open).with(filename,'w')
+end
+
+Then /^OpenUri\.open should be called with "([^\"]*)"$/ do |uri|
+  OpenURI.should_receive(:open).with(uri)  
+end
+

data/lib/swissparser.rb

@@ -1,5 +1,5 @@
 =begin
-Copyright (C) 2009 Paradigmatic
+Copyright (C) 2009,2010 Paradigmatic
 
 This file is part of SwissParser.
 
@@ -18,216 +18,61 @@ along with SwissParser.  If not, see <http://www.gnu.org/licenses/>.
 =end
 
 require 'open-uri'
-require 'swissparser/parsing_context'
-require 'swissparser/parsing_rules'
+require 'swissparser/entries'
+require 'swissparser/rules'
 
 module Swiss
 
-  VERSION = "0.11.1"
+  VERSION = "1.0.0"
 
-
-  # Parser for a typical bioinformatic flat file.
+  # Parser for a typical bioinformatic flat file, like
+  # SwissProt/Uniprot, KEGG, etc.
   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 = {}
-      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
-
-    # Define an helper method accessible to rules and actions.
-    # This method tales two argument:
-    # * A symbol which will be the method name
-    # * A block which is the method implementation. The block can take parameters.
-    # The helper method can then be called as a regular method.
-    def helper(name, &proc)
-      @helpers[name] = 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|
-        @actions[k] = v
-      end
-      if r.separator
-        @separator = r.separator
-      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 )
+    #Create a new parser from a set of rules.
+    # The method needs a block taking a single parameter which
+    # holds the parsed entries.
+    def initialize( rules, &body )
+      @rules = rules
+      @body = body
     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={} )
+    # Parses any input that accepts the +each_line+ method. Works for
+    # string, open files, etc. An optional hash of arbitrary arguments
+    # (+opt+) can be specified. It is passed to the workflow methods
+    # blocks (+before+, +new_entry+, ...) It executes the block
+    # defined when creating the parser and returns its last expression
+    # result.
+    def parse( input, opt={} )
+      entries = Entries.new( @rules, input, opt )
+      @body.call( entries )
+    end
+
+    # Parses a file specified by +filename+. An optional hash of
+    # arbitrary arguments (+opt+) can be specified. It is passed to
+    # the workflow methods blocks (+before+, +new_entry+, ...) It
+    # executes the block defined when creating the parser and returns
+    # its last expression result.
+    def parse_file( filename, opt={} )
       File.open( filename, 'r' ) do |file|
-        parse( file, params )
+        parse( file, opt )
       end
     end
 
     # Parses a file specified by an +URI+. Both http and ftp are
-    # supported. 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_URI( uri, params={} )
+    # supported. An optional hash of arbitrary arguments (+opt+) can
+    # be specified. It is passed to the workflow methods blocks
+    # (+before+, +new_entry+, ...) It executes the block defined when
+    # creating the parser and returns its last expression result.
+    def parse_uri( uri, opt={} )
       open( uri ) do |file|
-        parse( file, params )
+        parse( file, opt )
       end
     end
-    
-    # Parses any input that accepts the +each_line+ method.  Works for
-    # string, open files, etc. 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( data, params={} )
-      @ctx = init_context( params )
-      state = :begin
-      container = @ctx.instance_exec( &@before )
-      entry = @ctx.instance_exec( &@begin )
-      data.each_line do |line|
-        if @ctx.should_skip?
-          if line.include? @separator
-            state = :end
-            entry = init_entry
-          end
-        else
-          state = parse_line( line, entry )
-          if state == :end
-            @ctx.instance_exec( entry, container, &@end )
-            entry = init_entry
-          end
-        end
-      end
-      if state == :parsing 
-        raise("No separator at end of file")
-      end
-      @ctx.instance_exec( container, &@after )
-    end
-
-    PROTOTYPE = Parser.new
-    PROTOTYPE.instance_eval do
-      before { || [] }
-      new_entry { || {} }
-      finish_entry {|e,c| c << e }
-      after {|c| c }
-    end
-    PROTOTYPE.freeze
 
-    private
-
-    def init_entry()
-      @ctx.reset_skip
-      @ctx.instance_exec( &@begin )
-    end
-    
-    def init_context(params)
-      ctx = ParsingContext.new( params )
-      helperModule = Module.new
-      @helpers.each do |name, proc|
-        helperModule.send( :define_method, name, proc )
-      end
-      ctx.extend( helperModule )
-      ctx
-    end
-
-    
-    def parse_line( line, holder )
-      line.chomp!
-      if line.include? @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
 
+  DefaultRules = Rules.new
+  DefaultRules.freeze
+
 end

data/lib/swissparser.rbc

@@ -0,0 +1,928 @@
+!RBIX
+0
+x
+M
+1
+n
+n
+x
+10
+__script__
+i
+58
+5
+7
+0
+64
+47
+49
+1
+1
+15
+5
+7
+2
+64
+47
+49
+1
+1
+15
+5
+7
+3
+64
+47
+49
+1
+1
+15
+45
+4
+5
+7
+6
+65
+49
+7
+2
+13
+45
+4
+8
+12
+7
+9
+12
+7
+10
+12
+65
+12
+49
+11
+4
+15
+48
+9
+15
+2
+11
+I
+6
+I
+0
+I
+0
+I
+0
+n
+p
+12
+s
+8
+open-uri
+x
+7
+require
+s
+19
+swissparser/entries
+s
+17
+swissparser/rules
+x
+8
+Rubinius
+n
+x
+5
+Swiss
+x
+11
+open_module
+n
+x
+15
+__module_init__
+M
+1
+n
+n
+x
+5
+Swiss
+i
+76
+5
+66
+65
+7
+0
+7
+1
+64
+49
+2
+2
+15
+45
+3
+4
+7
+5
+1
+65
+49
+6
+3
+13
+45
+3
+7
+12
+7
+8
+12
+7
+9
+12
+65
+12
+49
+10
+4
+15
+48
+8
+15
+65
+7
+11
+45
+12
+13
+13
+71
+14
+47
+9
+64
+47
+48
+15
+13
+47
+48
+16
+15
+8
+66
+48
+14
+49
+2
+2
+15
+45
+11
+17
+48
+18
+11
+I
+6
+I
+0
+I
+0
+I
+0
+n
+p
+19
+x
+7
+VERSION
+s
+5
+1.0.0
+x
+9
+const_set
+x
+8
+Rubinius
+n
+x
+6
+Parser
+x
+10
+open_class
+n
+x
+14
+__class_init__
+M
+1
+n
+n
+x
+6
+Parser
+i
+62
+5
+66
+45
+0
+1
+7
+2
+7
+3
+65
+67
+48
+4
+49
+5
+4
+15
+45
+0
+6
+7
+7
+7
+8
+65
+67
+48
+4
+49
+5
+4
+15
+45
+0
+9
+7
+10
+7
+11
+65
+67
+48
+4
+49
+5
+4
+15
+45
+0
+12
+7
+13
+7
+14
+65
+67
+48
+4
+49
+5
+4
+11
+I
+5
+I
+0
+I
+0
+I
+0
+n
+p
+15
+x
+8
+Rubinius
+n
+x
+10
+initialize
+M
+1
+n
+n
+x
+10
+initialize
+i
+14
+95
+19
+1
+15
+20
+0
+38
+0
+15
+20
+1
+38
+1
+11
+I
+3
+I
+2
+I
+1
+I
+1
+n
+p
+2
+x
+6
+@rules
+x
+5
+@body
+p
+7
+I
+0
+I
+23
+I
+4
+I
+24
+I
+9
+I
+25
+I
+e
+x
+48
+/home/falcone/prg/SwissParser/lib/swissparser.rb
+p
+2
+x
+5
+rules
+x
+4
+body
+x
+17
+method_visibility
+x
+15
+add_defn_method
+n
+x
+5
+parse
+M
+1
+n
+n
+x
+5
+parse
+i
+60
+23
+1
+10
+14
+44
+43
+0
+78
+49
+1
+1
+19
+1
+15
+45
+2
+3
+13
+71
+4
+47
+9
+40
+47
+48
+5
+13
+39
+6
+20
+0
+20
+1
+47
+49
+7
+3
+15
+8
+49
+39
+6
+20
+0
+20
+1
+49
+4
+3
+19
+2
+15
+39
+8
+20
+2
+49
+9
+1
+11
+I
+8
+I
+3
+I
+1
+I
+2
+n
+p
+10
+x
+4
+Hash
+x
+16
+new_from_literal
+x
+7
+Entries
+n
+x
+3
+new
+x
+8
+allocate
+x
+6
+@rules
+x
+10
+initialize
+x
+5
+@body
+x
+4
+call
+p
+7
+I
+0
+I
+2e
+I
+e
+I
+2f
+I
+34
+I
+30
+I
+3c
+x
+48
+/home/falcone/prg/SwissParser/lib/swissparser.rb
+p
+3
+x
+5
+input
+x
+3
+opt
+x
+7
+entries
+n
+x
+10
+parse_file
+M
+1
+n
+n
+x
+10
+parse_file
+i
+28
+23
+1
+10
+14
+44
+43
+0
+78
+49
+1
+1
+19
+1
+15
+45
+2
+3
+20
+0
+7
+4
+64
+56
+5
+50
+6
+2
+11
+I
+6
+I
+2
+I
+1
+I
+2
+n
+p
+7
+x
+4
+Hash
+x
+16
+new_from_literal
+x
+4
+File
+n
+s
+1
+r
+M
+1
+p
+2
+x
+9
+for_block
+t
+n
+x
+10
+parse_file
+i
+15
+57
+19
+0
+15
+5
+20
+0
+21
+1
+1
+47
+49
+0
+2
+11
+I
+5
+I
+1
+I
+1
+I
+1
+n
+p
+1
+x
+5
+parse
+p
+5
+I
+0
+I
+39
+I
+4
+I
+3a
+I
+f
+x
+48
+/home/falcone/prg/SwissParser/lib/swissparser.rb
+p
+1
+x
+4
+file
+x
+4
+open
+p
+5
+I
+0
+I
+38
+I
+e
+I
+39
+I
+1c
+x
+48
+/home/falcone/prg/SwissParser/lib/swissparser.rb
+p
+2
+x
+8
+filename
+x
+3
+opt
+n
+x
+9
+parse_uri
+M
+1
+n
+n
+x
+9
+parse_uri
+i
+24
+23
+1
+10
+14
+44
+43
+0
+78
+49
+1
+1
+19
+1
+15
+5
+20
+0
+56
+2
+47
+50
+3
+1
+11
+I
+5
+I
+2
+I
+1
+I
+2
+n
+p
+4
+x
+4
+Hash
+x
+16
+new_from_literal
+M
+1
+p
+2
+x
+9
+for_block
+t
+n
+x
+9
+parse_uri
+i
+15
+57
+19
+0
+15
+5
+20
+0
+21
+1
+1
+47
+49
+0
+2
+11
+I
+5
+I
+1
+I
+1
+I
+1
+n
+p
+1
+x
+5
+parse
+p
+5
+I
+0
+I
+44
+I
+4
+I
+45
+I
+f
+x
+48
+/home/falcone/prg/SwissParser/lib/swissparser.rb
+p
+1
+x
+4
+file
+x
+4
+open
+p
+5
+I
+0
+I
+43
+I
+e
+I
+44
+I
+18
+x
+48
+/home/falcone/prg/SwissParser/lib/swissparser.rb
+p
+2
+x
+3
+uri
+x
+3
+opt
+p
+9
+I
+2
+I
+23
+I
+11
+I
+2e
+I
+20
+I
+38
+I
+2f
+I
+43
+I
+3e
+x
+48
+/home/falcone/prg/SwissParser/lib/swissparser.rb
+p
+0
+x
+13
+attach_method
+x
+12
+DefaultRules
+x
+5
+Rules
+n
+x
+3
+new
+x
+8
+allocate
+x
+10
+initialize
+n
+x
+6
+freeze
+p
+9
+I
+2
+I
+1a
+I
+c
+I
+1e
+I
+2a
+I
+4b
+I
+46
+I
+4c
+I
+4c
+x
+48
+/home/falcone/prg/SwissParser/lib/swissparser.rb
+p
+0
+x
+13
+attach_method
+p
+9
+I
+0
+I
+14
+I
+9
+I
+15
+I
+12
+I
+16
+I
+1b
+I
+18
+I
+3a
+x
+48
+/home/falcone/prg/SwissParser/lib/swissparser.rb
+p
+0