[BioRuby-cvs] bioruby/lib/bio/io flatfile.rb,1.34,1.35

Katayama Toshiaki k at pub.open-bio.org
Wed Aug 10 13:15:26 EDT 2005


Update of /home/repository/bioruby/bioruby/lib/bio/io
In directory pub.open-bio.org:/tmp/cvs-serv8755/lib/bio/io

Modified Files:
	flatfile.rb 
Log Message:
* reverted to the previous version. proposed changes will be considered in
  the 0.7 series.


Index: flatfile.rb
===================================================================
RCS file: /home/repository/bioruby/bioruby/lib/bio/io/flatfile.rb,v
retrieving revision 1.34
retrieving revision 1.35
diff -C2 -d -r1.34 -r1.35
*** flatfile.rb	10 Aug 2005 12:51:15 -0000	1.34
--- flatfile.rb	10 Aug 2005 17:15:23 -0000	1.35
***************
*** 2,6 ****
  # bio/io/flatfile.rb - flatfile access wrapper class
  #
! #   Copyright (C) 2001-2005 GOTO Naohisa <ngoto at gen-info.osaka-u.ac.jp>
  #
  #  This library is free software; you can redistribute it and/or
--- 2,6 ----
  # bio/io/flatfile.rb - flatfile access wrapper class
  #
! #   Copyright (C) 2001, 2002 GOTO Naohisa <ngoto at gen-info.osaka-u.ac.jp>
  #
  #  This library is free software; you can redistribute it and/or
***************
*** 27,107 ****
      include Enumerable
  
!     def self.to_a(*args)
!       self.auto(*args) do |ff|
!         raise 'cannot determine file format' unless ff.dbclass
!         ff.to_a
        end
      end
  
!     # Bio::FlatFile.auto(filename/io[, [mode, parm,] opts]) [{block}]
!     def self.auto(*args, &block)
!       self.open(nil, *args, &block)
      end
  
!     # Bio::FlatFile.open(filename/io, dbclass[, [mode, parm,] opts]) [{block}]
!     #  or
!     # Bio::FlatFile.open(dbclass, filename/io[, [mode, parm,] opts]) [{block}]
!     def self.open(*args)
!       ff = self.new(*args)
!       if block_given?
!         yield ff
!         ff.close
!       else
!         ff
        end
      end
  
!     # Bio::FlatFile.new(filename/io, dbclass[, [mode, parm,] opts])
!     #  or
!     # Bio::FlatFile.new(dbclass, filename/io[, [mode, parm,] opts])
!     def initialize(file, dbclass, *args)
!       if file.nil? or file.kind_of?(Module)
!         # swap first two arguments if needed for the backward compatibility
!         dbclass, file = file, dbclass
!       end
!       openmode = parse_opts(args)	# args is always an Array
! 
!       if file.respond_to?(:gets)	# 'file' is already an IO object
!         @io = file
!       else				# 'file' is a filename
!         @io = File.open(file, *openmode)
        end
! 
!       @prefetch = ''			# initialize prefetch buffer
!       if dbclass
  	self.dbclass = dbclass
        else
! 	autodetect			# file format autodetection
        end
      end
      attr_reader :io
  
-     # 1. if the 1st element is not a Hash or true, assume it as a "mode"
-     #    for File.open
-     # 2. if the 2nd element is not a Hash or true, assume it as a "parm"
-     #    for File.open
-     # 3. if the 3rd element is a Hash and have a key ':raw', use its value
-     #    to specify the raw mode (other keys are not in the FlatFile spec yet).
-     # 4. elsif the 3rd element is true, treat it as 'raw = true' is specified
-     #    for the backward compatibility
-     def parse_opts(args)
-       # openmode = args.reject {|x| x.is_a?(Hash) or x.is_a?(TrueClass)}
-       mode = args.shift unless args[0].is_a?(Hash) or args[0].is_a?(TrueClass)
-       perm = args.shift unless args[0].is_a?(Hash) or args[0].is_a?(TrueClass)
-       opts = args.shift
-       openmode = [mode, perm].compact
- 
-       self.raw = false
-       if opts.is_a?(Hash) and opts.has_key?(:raw)
-         self.raw = opts[:raw]
-       else
-         self.raw = opts			# true or nil 
-       end
- 
-       return openmode
-     end
-     private :parse_opts
- 
- 
      def next_entry
        @entry_raw = gets(@rs)
--- 27,88 ----
      include Enumerable
  
!     def self.open(dbclass, file, *arg)
!       # 3rd and 4th arg: mode, perm (passed to File.open)
!       openmode = []
!       while x = arg[0] and !x.is_a?(Hash)
! 	openmode << arg.shift
!       end
!       # rest of arg: passed to FlatFile.new
!       # create a flatfile object
!       unless file.respond_to?(:gets)
!         # 'file' is a filename
!         if block_given? then
!           File.open(file, *openmode) do |fobj|
!             ff = self.new(dbclass, fobj, *arg)
!             yield ff
!           end
!         else
!           fobj = File.open(file, *openmode)
!           self.new(dbclass, fobj, *arg)
!         end
!       else
!         # 'file' is a IO object
!         ff = self.new(dbclass, file, *arg)
!         block_given? ? (yield ff) : ff
        end
      end
  
!     def self.auto(*arg, &block)
!       self.open(nil, *arg, &block)
      end
  
!     def self.to_a(*arg)
!       self.auto(*arg) do |ff|
!         raise 'cannot determine file format' unless ff.dbclass
!         ff.to_a
        end
      end
  
!     def initialize(dbclass, stream, options = nil)
!       # 2nd arg: IO object
!       @io = stream
!       # 3rd arg: options (nil or a Hash)
!       self.raw = false
!       if options.is_a?(Hash) then
!         self.raw = options[:raw] if options.has_key?(:raw)
!       else
!         self.raw = options
        end
!       # initialize prefetch buffer
!       @prefetch = ''
!       # 1st arg: database class (or file format autodetection)
!       if dbclass then
  	self.dbclass = dbclass
        else
! 	autodetect
        end
      end
      attr_reader :io
  
      def next_entry
        @entry_raw = gets(@rs)
***************
*** 380,473 ****
  = Bio::FlatFile
  
! --- Bio::FlatFile.new(filename_or_stream, dbclass[, [mode, parm,] options])
! --- Bio::FlatFile.new(dbclass, filename_or_stream[, [mode, parm,] options])
! 
!       Prepare to read a file or a IO stream specified in 'filename_or_stream'.
!       If the 'filename_or_stream' is a filename, this method opens the local
!       file as File.open(filename, mode, perm).  See the documentations on
!       Ruby's Kernel#open method for the 'mode' and 'parm' options.
! 
!       The 'dbclass' must be a one of the BioRuby's database class name
!       (e.g. Bio::GenBank, Bio::FastaFormat).
!       If nil is given to the 'dbclass', try to determine database class
!       (file format) automatically.  It is recommended to set 'dbclass'
!       using FlatFile#dbclass= method if the automatic determination failed.
!       Otherwise, 'dbclass' is set to nil and FlatFile#next_entry can act same
!       as the IO#gets method only when the raw mode is on (raw = true).
! 
!       The last argument 'options' is a Hash (or nil to omit) containing
!       flags to determine the behavior of the Bio::FlatFile instance.
!       Currently, only the ':raw' flag is recognized as the key.
!       If the value of options[:raw] is true, "raw mode" is on (defalut is off).
!       You can also change this flag by Bio::FlatFile#raw = true afterwards.
  
!       Backward compatibility:
!       The order of the first two arguments is automatically recognized.
  
        * Example 1
!           Bio::FlatFile.new(ARGF, Bio::GenBank)
!           Bio::FlatFile.new(Bio::GenBank, ARGF)
        * Example 2
!           Bio::FlatFile.new(IO.popen("gzip -dc nc1101.flat.gz"), Bio::GenBank)
        * Example 3
!           Bio::FlatFile.new($stdin, nil, :raw => true)
!           # following notation was also used in the old BioRuby to specify
!           # the raw mode (deprecated).
!           Bio::FlatFile.new($stdin, nil, true)
  
! --- Bio::FlatFile.open(filename_or_stream, dbclass[, [mode, perm,] options])
! --- Bio::FlatFile.open(dbclass, filename_or_stream[, [mode, perm,] options])
  
!       Open a file as a flat file database in the specified 'dbclass' format.
!       Similar to Bio::FlatFile.new but also accepts block.
  
!       Refer to the document of Bio::FlatFile.new for the other options.
  
!       Backward compatibilities:
!       It is not recommended because the name of this method is resemble to
!       the Ruby's File.open, but the 'filename_or_stream' can be an already
!       opened IO stream.  It is also not recommended but if nil is specified
!       to the 'dbclass', this method acts as the Bio::FlatFile.auto method.
  
        * Example 1
!           ff = Bio::FlatFile.open("genbank/gbest40.seq", Bio::GenBank)
        * Example 2
!           ff = Bio::FlatFile.open("embl/est_hum17.dat", nil)
        * Example 3
!           ff = Bio::FlatFile.open($stdin, Bio::GenBank)
  
!       If it is called with block, the block is passed to the newly opened
!       Bio::FlatFile instance and the file will be automatically closed
!       when leaving the block.
  
        * Example 4
!           Bio::FlatFile.open('test4.fst', Bio::FastaFormat) do |ff|
!             ff.each { |e| puts e.definition }
            end
  
! --- Bio::FlatFile.auto(filename_or_stream[, [mode, perm,] options])
  
!       Open a file or an IO stream by auto detection of the database format.
!       Similar to Bio::FlatFile.open but no need to specify the 'dbclass'. 
!       This method would be most useful one among the 'new', 'open' and 'auto'.
!       Refer to the document of Bio::FlatFile.new for other options.
  
        * Example 1
!           flatfile = Bio::FlatFile.auto(ARGF)
!           flatfile.each do |entry|
!             # do something on entry
!             puts entry.entry_id
!           end
        * Example 2
!           Bio::FlatFile.auto("embl/est_hum17.dat")
        * Example 3
!           Bio::FlatFile.auto(IO.popen("gzip -dc nc1101.flat.gz"))
!       * Example 4
!           Bio::FlatFile.auto(ARGF) do |flatfile|
!             flatfile.each do |entry|
!               # do something on entry
!               puts entry.entry_id
!             end
!           end
  
  --- Bio::FlatFile.to_a(filename_or_stream, *arg)
--- 361,428 ----
  = Bio::FlatFile
  
! --- Bio::FlatFile.auto(filename_or_stream[, mode, perm, options])
  
!       Same as Bio::FlatFile.open(nil, filename_or_stream, mode, perm, options).
  
        * Example 1
!           Bio::FlatFile.auto(ARGF)
        * Example 2
!           Bio::FlatFile.auto("embl/est_hum17.dat")
        * Example 3
!           Bio::FlatFile.auto(IO.popen("gzip -dc nc1101.flat.gz"))
  
! --- Bio::FlatFile.open(dbclass, filename_or_stream[, mode, perm, options])
  
!       Prepare to read a file or a stream 'filename_or_stream'
!       which contains 'dbclass'-style formatted data.
  
!       'dbclass' shoud be a class (or module) or nil.
!       e.g. Bio::GenBank, Bio::FastaFormat.
  
!       If 'filename_or_stream' is a filename (which doesn't have gets method),
!       the method opens a local file named 'filename_or_stream'
!       with 'File.open(filename, mode, perm)'.
! 
!       When nil is given to dbclass, trying to determine database class
!       (file format) automatically. If fails to determine, dbclass is
!       set to nil and FlatFile#next_entry works same as IO#gets when
!       raw = true. It is recommended to set dbclass using
!       FlatFile#dbclass= method if fails to determine automatically.
  
        * Example 1
!           Bio::FlatFile.open(Bio::GenBank, "genbank/gbest40.seq")
        * Example 2
!           Bio::FlatFile.open(nil, "embl/est_hum17.dat")
        * Example 3
!           Bio::FlatFile.open(Bio::GenBank, $stdin)
  
!       If it is called with block, the block will be executed with
!       a newly opened Bio::FlatFile instance object. If filename
!       is given, the file is automatically closed when leaving the block.
  
        * Example 4
!           Bio::FlatFile.open(nil, 'test4.fst') do |ff|
!               ff.each { |e| print e.definition, "\n" }
            end
  
! --- Bio::FlatFile.new(dbclass, stream, options = nil)
  
!       Same as FlatFile.open, except that 'stream' should be a opened
!       stream object (IO, File, ..., who have the 'gets' method).
  
        * Example 1
!           Bio::FlatFile.new(Bio::GenBank, ARGF)
        * Example 2
!           Bio::FlatFile.new(Bio::GenBank, IO.popen("gzip -dc nc1101.flat.gz"))
! 
!       'options' needs to be a hash (or nil).
!       Current options are below:
!          :raw --> if true, "raw mode" (same as #raw=true).
!                   default: false (not "raw mode").
! 
        * Example 3
!           Bio::FlatFile.new(nil, $stdin, :raw=>true)
!       * Example 3 in old style (deprecated)
!           Bio::FlatFile.new(nil, $stdin, true)
  
  --- Bio::FlatFile.to_a(filename_or_stream, *arg)



More information about the bioruby-cvs mailing list