rio 0.3.4 → 0.3.6

data/lib/rio/ext/yaml.rb

@@ -0,0 +1,182 @@
+#--
+# =============================================================================== 
+# Copyright (c) 2005, Christopher Kleckner
+# All rights reserved
+#
+# This file is part of the Rio library for ruby.
+#
+# Rio 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 2 of the License, or
+# (at your option) any later version.
+#
+# Rio 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 Rio; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+# =============================================================================== 
+#++
+#
+# To create the documentation for Rio run the command
+#  rake rdoc
+# from the distribution directory. Then point your browser at the 'doc/rdoc' directory.
+#
+# Suggested Reading
+# * RIO::Doc::SYNOPSIS
+# * RIO::Doc::INTRO
+# * RIO::Doc::HOWTO
+# * RIO::Rio
+#
+# <b>Rio is pre-alpha software. 
+# The documented interface and behavior is subject to change without notice.</b>
+
+
+require 'yaml'
+
+module RIO
+  module Ext
+    module YAML
+      module Cx
+        def yaml(&block) 
+          cxx('yaml',true,&block) 
+        end
+        def yaml?() cxx?('yaml') end 
+        def yaml_(fs=',',rs=nil) 
+          cxx_('yaml',true) 
+        end
+        protected :yaml_
+        def objects(*args) records(*args) end
+        def documents(*args) rows(*args) end
+        def skipobjects(*args) skiprecords(*args) end
+        def skipdocuments(*args) skiprows(*args) end
+      end
+    end
+    module YAML
+      module Input
+        def cpto_(arg)
+          #p callstr('cpto_',arg.inspect)
+          
+          case arg
+          when ::Array,::String then super
+          when ::IO,::StringIO then cpto_io_(arg)
+          else super
+          end
+        end
+        def apto_(arg)
+          case arg
+          when ::Array,::String then super
+          when ::IO,::StringIO then cpto_io_(arg)
+          else super
+          end
+        end
+        def cpto_io_(arg)
+          self.each { |obj|
+            arg << obj.to_yaml + $/
+          }
+        end
+        def cpto_obj_(arg)
+          self.each { |obj|
+            
+          }
+        end
+        def cpto_array_(array)
+          self.each { |el|
+            array << el
+          }
+        end
+        def cpto_string_(string)
+          self.each { |el|
+            string << el.to_yaml + $/
+          }
+        end
+        def get_(arg=nil)
+          case cx['stream_itertype']
+          when 'lines' then super
+          when 'records' then ::YAML.load(self.ioh)
+          when 'rows' then ::YAML.dump(::YAML.load(self.ioh))
+          else ::YAML.load(self.ioh)
+          end
+        end
+        def each_rec_(&block)
+          case cx['stream_itertype']
+          when 'lines' then super
+          when 'records' then ::YAML.load_documents(self.ioh,&block)
+          when 'rows' then ::YAML.load_documents(self.ioh) { |obj| yield obj.to_yaml }
+          else ::YAML.load_documents(self.ioh,&block)
+          end
+          self
+        end
+        def load()
+          getrec()
+        end
+        def getobj()
+          getrec()
+        end
+
+        def add_filters
+          cx['yaml_close_eof'],cx['closeoneof'] = cx['closeoneof'],false
+          super
+        end
+        def each_(&block)
+          #old_close_eof,cx['closeoneof'] = cx['closeoneof'],false
+          super
+          cx['closeoneof'] = cx.delete('yaml_close_eof') 
+          
+          if closeoneof?
+            add_filter(Filter::CloseOnEOF)
+            ioh.oncloseproc = proc { self.on_closeoneof }
+          end
+          closeoneof? ? ioh.close_on_eof_(self) : self
+        end
+      end
+    end
+
+    module YAML
+      module Output
+        protected
+
+        def cpfrom_(arg)
+            case arg
+            when ::Array then cpfrom_array_(arg)
+            when Rio,::IO,::StringIO then super
+            else self.put_(arg)
+            end
+            self
+        end
+        def cpfrom_array_(array)
+          array.each { |el|
+            self.put_(el)
+          }
+          self
+        end
+        def cpfrom_rio_(ario)
+          ario.each { |el|
+            self.put_(el)
+          }
+          self
+        end
+        def put_(obj)
+          #p callstr('put_',obj)
+          ioh.puts(obj.to_yaml)
+        end
+
+        public
+
+        def dump(obj)
+          putrec!(obj)
+        end
+        def putobj(obj)
+          putrec(obj)
+        end
+        def putobj!(obj)
+          putrec!(obj)
+        end
+      end
+    end
+  end
+end
+__END__

data/lib/rio/factory.rb

@@ -82,6 +82,9 @@ module RIO
                           when 'strio'
                             require 'rio/scheme/strio'
                             StrIO
+                          when 'cmdpipe'
+                            require 'rio/scheme/cmdpipe'
+                            CmdPipe
                           when 'aryio'
                             require 'rio/scheme/aryio'
                             AryIO
@@ -116,20 +119,8 @@ module RIO
     def reset_state(rl)
       mod = subscheme_module(rl.scheme)
       mod.const_get(:RESET_STATE) unless mod.nil?
-      #p st
-#       @reset_class[st] ||= case st
-#                            when 'Path::Reset'
-#                              require 'rio/path/reset'
-#                              Path::Reset
-#                            when 'Stream::Open'
-#                              require 'rio/stream/open'
-#                              Stream::Open
-#                            else
-#                              raise ArgumentError,"Unknown RESET_STATE (#{st})"
-#                            end
-      
-
     end
+
     STATE2FILE = {
       'Path::Reset' => 'rio/path/reset',
       'Path::Empty' => 'rio/path',
@@ -168,6 +159,12 @@ module RIO
       'StrIO::Stream::InOut' => 'rio/scheme/strio',
       'StrIO::Stream::Open' => 'rio/scheme/strio',
 
+      'CmdPipe::Stream::Reset' => 'rio/scheme/cmdpipe',
+#      'CmdPipe::Stream::Open' => 'rio/scheme/cmdpipe',
+#      'CmdPipe::Stream::Input' => 'rio/scheme/cmdpipe',
+#      'CmdPipe::Stream::Output' => 'rio/scheme/cmdpipe',
+#      'CmdPipe::Stream::InOut' => 'rio/scheme/cmdpipe',
+
       'HTTP::Stream::Input' => 'rio/scheme/http',
       'HTTP::Stream::Open' => 'rio/scheme/http',
 
@@ -225,7 +222,7 @@ module RIO
       create_handle(state2class(reset_state(riorl)).new_r(riorl))
     end
     def clone_state(state)
-      create_handle(state.clone)
+      create_handle(state.target.clone)
     end
     def create_handle(new_state)
       hndl = Handle.new(new_state)

data/lib/rio/filter/closeoneof.rb

@@ -57,6 +57,7 @@ module RIO
         rtn
       end
       def close_on_eof_(rtn)
+        #p callstr('close_on_eof_',rtn)
 #        p @ios
         unless @autoclosed or closed?
           handle.close()
@@ -66,37 +67,17 @@ module RIO
         rtn
       end
         
-      def copy_stream(dst) 
-        #p callstr('copy_stream',dst)
-        close_on_eof(super)
-      end
-      def contents() 
-        close_on_eof(super)
-      end
-      def readlines(*args)
-        close_on_eof(super)
-      end
-      def each_line(*args,&block)
-        close_on_eof(super)
-      end
-      def each_byte(*args,&block)
-        close_on_eof(super)
-      end
-      def each_bytes(nb,*args,&block)
-        close_on_eof(super)
-      end
-      def readline(*args)
-        close_on_eof(super)
-      end
-      def read(*args)
-        close_on_eof(super)
-      end
-      def readchar(*args)
-        close_on_eof(super)
-      end
-      def gets(*args)
-        close_on_eof(super)
-      end
+      def readlines(*args)            close_on_eof(super) end
+      def each_line(*args,&block)     close_on_eof(super) end
+      def each_byte(*args,&block)     close_on_eof(super) end
+      def each_bytes(nb,*args,&block) close_on_eof(super) end
+      def readline(*args)             close_on_eof(super) end
+      def read(*args)                 close_on_eof(super) end
+      def readchar(*args)             close_on_eof(super) end
+      def gets(*args)                 close_on_eof(super) end
+
+      def copy_stream(dst)            close_on_eof(super) end
+      def contents()                  close_on_eof(super) end
     end
   end
 end

data/lib/rio/filter/gzip.rb

@@ -39,10 +39,16 @@ require 'zlib'
 
 module RIO
   module Filter
+    module GZipMissing
+      def binmode()
+        self
+      end
+    end
     module GZipRead
       def self.extend_object(ioh_stream)
         super
         gz = Zlib::GzipReader.new(ioh_stream.ios)
+        gz.extend Filter::GZipMissing
         ioh_stream.iostack.push(gz)
       end
     end
@@ -50,6 +56,7 @@ module RIO
       def self.extend_object(ioh_stream)
         super
         gz = Zlib::GzipWriter.new(ioh_stream.ios)
+        gz.extend Filter::GZipMissing
         ioh_stream.iostack.push(gz)
       end
     end

data/lib/rio/if.rb

@@ -37,6 +37,10 @@
 
 module RIO
   class Rio
+    require 'rio/if/csv'
+    include RIO::IF::CSV
+    require 'rio/if/yaml'
+    include RIO::IF::YAML
   end
 end
 
@@ -53,5 +57,4 @@ require 'rio/if/file'
 require 'rio/if/dir'
 require 'rio/if/stream'
 require 'rio/if/temp'
-require 'rio/if/csv'
 require 'rio/if/string'

data/lib/rio/if/csv.rb

@@ -36,41 +36,42 @@
 
 
 module RIO
-  class Rio
-    #def file() target.file end
-    #def dir() target.dir end
-    
-    # Puts a Rio in CSV mode and sets the field and record separators.
-    # In csv mode selecting with Rio#records will cause each line
-    # read to be parsed into a line with the CSV standard library.
-    # Specifying using Rio#lines to select will return unparsed strings
-    # as normal.
-    #
-    #  # copy a csv file, changing the field separator
-    #  rio('afile.csv').csv > rio('afile_semicolons.csv').csv(';')
-    #
-    # CSV mode also adds two methods Rio#columns and Rio#nocolumns which 
-    # allows selecting columns by column index using Fixnums or Ranges
-    # in a way similar to how lines are selected.
-    #
-    #  # iterate through every line but only get the first three columns
-    #  rio("afile.csv").csv.columns(0..2) { |array_of_fields| ... }
-    #
-    #  # iterate through every line but skip the columns 2 and 3 through 5
-    #  rio("afile.csv").csv.nocolumns(2,3..5) { |array_of_fields| ... }
-    #
-    #  # an array containg all but the first line returning columns 5,6 and 7
-    #  rio("afile.csv").csv.columns(5..7).skiplines[0]
-    #
-    # See RIO::Doc::INTRO for complete documentation on csv mode.
-    def csv(field_separator=',',record_separator=nil,&block) 
-      target.csv(field_separator,record_separator,&block); 
-      self 
+  module IF
+    module CSV
+      #def file() target.file end
+      #def dir() target.dir end
+      
+      # Puts a Rio in CSV mode and sets the field and record separators.
+      # In csv mode selecting with Rio#records will cause each line
+      # read to be parsed into a line with the CSV standard library.
+      # Specifying using Rio#lines to select will return unparsed strings
+      # as normal.
+      #
+      #  # copy a csv file, changing the field separator
+      #  rio('afile.csv').csv > rio('afile_semicolons.csv').csv(';')
+      #
+      # CSV mode also adds two methods #columns and #skipcolumns which 
+      # allows selecting columns by column index using Fixnums or Ranges
+      # in a way similar to how lines are selected.
+      #
+      #  # iterate through every line but only get the first three columns
+      #  rio("afile.csv").csv.columns(0..2) { |array_of_fields| ... }
+      #
+      #  # iterate through every line but skip the columns 2 and 3 through 5
+      #  rio("afile.csv").csv.skipcolumns(2,3..5) { |array_of_fields| ... }
+      #
+      #  # an array containg all but the first line returning columns 5,6 and 7
+      #  rio("afile.csv").csv.columns(5..7).skiplines[0]
+      #
+      # See RIO::Doc::INTRO for complete documentation on csv mode.
+      def csv(field_separator=',',record_separator=nil,&block) 
+        target.csv(field_separator,record_separator,&block); 
+        self 
+      end
+      # Select columns from a CSV file. See #csv and RIO::Doc::INTRO.
+      def columns(*ranges,&block) target.columns(*ranges,&block); self end
+      # Reject columns from a CSV file. See #csv and RIO::Doc::INTRO.
+      def skipcolumns(*ranges,&block) target.skipcolumns(*ranges,&block); self end
     end
-    # Select columns from a CSV file. See Rio#csv and RIO::Doc::INTRO.
-    def columns(*ranges,&block) target.columns(*ranges,&block); self end
-    # Reject columns from a CSV file. See Rio#csv and RIO::Doc::INTRO.
-    def nocolumns(*ranges,&block) target.nocolumns(*ranges,&block); self end
   end
 end
-

data/lib/rio/if/grande.rb

@@ -37,6 +37,8 @@
 
 module RIO
   class Rio
+#  module IF
+#  module Grande
     # Returns the contents of the rio as an array.
     # Rio#to_a is implemented in terms of Rio#each so the the following are roughly equivelent
     #
@@ -404,6 +406,51 @@ module RIO
     # Alias for Rio#> (copy-to grande operator)
     def copy_to(destination) target.copy_to(destination); self end
 
+
+    # Grande Pipe Operator
+    # 
+    # The Rio pipe operator is actually an alternative syntax for calling the copy-to operator, designed to 
+    # allow several copy operation to be performed in one line of code, with behaviour that mimics
+    # the pipe operator commonly available in shells.
+    #
+    # If +destination+ is a +cmdio+, a <tt>cmdpipe</tt> Rio is returned, and none of the commands are run.
+    #
+    # Otherwise the +cmdpipe+ Rio is run with the output of the pipe being copied to the destination.
+    # In this case a Rio representing the +destination+ is returned.
+    # 
+    # If destination is not a Rio it is passed to the Rio constructor as is done with the copy-to operator
+    # except that if +destination+ is a String it is assumed to be a command instead of a path.
+    #
+    #  rio('afile') | rio(?-,'grep i') | rio(?-) # returns rio(?-)
+    #                                            # equivelent to rio(?-, 'grep i') < rio('afile') > rio(?-)
+    #
+    #  rio('infile') | rio(?-, 'acmd') | rio(?-, 'acmd2') | rio('outfile')
+    #  # same as
+    #  # acmd = rio(?-,'acmd')
+    #  # acmd2 = rio(?-,'acmd2')
+    #  # out = rio('outfile')
+    #  # acmd < rio('infile')
+    #  # acmd2 < acmd
+    #  # out < acmd2
+    # 
+    #  rio('afile') | 'acmd' | 'acmd2' | rio('outfile') # same thing
+    #
+    #  acmdpipe = rio(?-,'acmd') | 'acmd2'
+    #  rio('afile') | acmdpipe | rio('outfile') # same thing
+    #
+    #  acmdpipe1 = rio(?|,'acmd','acmd2')
+    #  rio('afile') | acmdpipe1 | rio('outfile') # same thing
+    #
+    #  acmdpipe2 = rio('afile') | 'acmd' | 'acmd2'
+    #  acmdpipe2 | rio('outfile') # same thing
+    #
+    # The grande pipe operator can not be used to create a +cmdpipe+ Rio that includes a destination.
+    # This must be done using a Rio constructor
+    #  cmd_with_output = rio(?|,'acmd',rio('outfile'))
+    #  rio('afile') | cmd_with_output # same as above
+    #
+    def |(destination) target | destination end
+
     # Grande Append-To Operator
     # 
     # The append-to grande-operator is the same as Rio#> (copy-to) except that it opens the destination
@@ -536,6 +583,24 @@ module RIO
     def copy_from(source) target.copy_from(source); self end
 
 
+    # Temporarily set the Rio to read records, and call #get
+    #
+    # See also Rio#records, Rio#lines, Rio#each, Rio#[]
+    #
+    def getrec() target.getrec() end
+
+    # Temporarily set the Rio to read rows, and call #get
+    #
+    # See also Rio#rows, Rio#lines, Rio#each, Rio#[]
+    #
+    def getrow() target.getrow() end
+
+    # Temporarily set the Rio to read lines, and call #get
+    #
+    # See also Rio#records, Rio#lines, Rio#each, Rio#[]
+    #
+    def getline() target.getline() end
+
     # Reads and returns the next record from a Rio, honoring the grande selection methods. 
     #
     # Returns nil on end of file.
@@ -543,11 +608,15 @@ module RIO
     # See also Rio#records, Rio#lines, Rio#each, Rio#[]
     #
     #  ario = rio('afile').lines(10..12)
-    #  line10 = ario.getrec 
-    #  line11 = ario.getrec 
-    #  line12 = ario.getrec 
-    #  a_nil  = ario.getrec 
-    def getrec() target.getrec() end
+    #  line10 = ario.get 
+    #  line11 = ario.get 
+    #  line12 = ario.get 
+    #  a_nil  = ario.get 
+    def get() target.get() end
+
+    # Writes a single record to a Rio
+    def putrec(el) target.putrec(el) end
+
 
     # Grande Exclude method
     #