rio 0.3.4 → 0.3.6

data/lib/rio/if/grande_stream.rb

@@ -99,8 +99,9 @@ module RIO
     # 
     # Returns the Rio
     #
-    # If no args are provided, all records are selected. What constitutes a record is affected by Rio#lines,Rio#bytes,
-    # and extensions such as Rio#csv.
+    # If no args are provided, all records are selected. 
+    # What constitutes a record is affected by Rio#lines,Rio#bytes,
+    # and extensions such as Rio#csv and Rio#yaml.
     #
     # If args are provided they may be one or more of the following:
     # Regexp::  any matching record will be iterated over by Rio#each or returned by Rio#getrec
@@ -110,6 +111,13 @@ module RIO
     # Symbol::  a symbol which will _sent_ to each record, records are included unless nil or false is returned
     # Array::   an array of any of above. All must match for a line to be included
     #
+    # Any other argument type is compared with the record using its <tt>===</tt> method.
+    #
+    # If the argument is a ::Proc it may be called with one, two or three paramaters.
+    # 1. the record
+    # 2. the recno (optional)
+    # 3. the rio (optional)
+    #
     # Note in the following examples that since +lines+ is the default <tt>ario.records(*args)</tt>
     # is effectively the same as <tt>ario.lines(*args)</tt>.
     #
@@ -136,7 +144,7 @@ module RIO
     # See also Rio#records, Rio#skiplines, Rio#lines
     #
     # If no args are provided, no records are rejected. What constitutes a record is affected by Rio#lines,Rio#bytes,
-    # and extensions such as Rio#csv.
+    # and extensions such as Rio#csv and Rio#yaml.
     #
     # If args are provided they may be one or more of the following:
     # Regexp::  any matching record will not be processed

data/lib/rio/if/path.rb

@@ -40,13 +40,10 @@ module RIO
 
     # Returns the path for the Rio, which is defined differently for different types of Rios.
     #
-    # For Rios representing paths on the underlying file system this returns 
-    # URI::FILE#path or URI::Generic#path depending on whether the Rio is absolute or not. 
-    # Note that this is not necessarily the same as Rio#fspath, but rather
-    # a URL path as defined in RFC1738.
-    #
-    # For Rios that have a URI representation this returns URI#path 
-    #
+    # For Rios representing paths on the underlying file system this is an alias 
+    # Rio#fspath. For Rios with paths that are not on the file system this is an
+    # alias for Rio#urlpath.
+    # 
     # Otherwise this returns nil.
     # 
     def path(*args) target.path(*args) end
@@ -72,6 +69,10 @@ module RIO
     # Returns nil if the Rio is not on the filesystem (i.e. stdin: or http: Rios)
     def fspath(*args) target.fspath(*args) end
 
+    # Returns the path portion of the URL representation of the rio 
+    # Returns nil if the Rio URL has no path (i.e. stdin: or http: Rios)
+    def urlpath(*args) target.urlpath(*args) end
+
     # Proxy for File#expand_path
     #
     # Converts a pathname to an absolute pathname. 
@@ -98,7 +99,7 @@ module RIO
     #  rio('/tmp/afile').rel('/tmp')   #=> rio('afile')
     #  rio('zippy/afile').rel('zippy') #=> rio('afile')
     #
-    def rel(other) target.rel(other)  end
+    def rel(other=nil) target.rel(other)  end
 
 
     # Returns a new Rio whose path is the base path that is used by 

data/lib/rio/if/yaml.rb

@@ -0,0 +1,218 @@
+#--
+# =============================================================================== 
+# 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>
+
+
+module RIO
+  module IF
+    module YAML
+      #def file() target.file end
+      #def dir() target.dir end
+      
+      # Puts a Rio in YAML mode.
+      #
+      #
+      # Rio uses the YAML class from the Ruby standard library to provide
+      # support for reading and writing YAML files. Normally using
+      # <tt>(skip)records</tt> is identical to <tt>(skip)lines</tt> because
+      # while +records+ only selects and does not specify the record-type,
+      # +lines+ is the default.
+      #
+      # The YAML extension distingishes between items selected using
+      # Rio#records, Rio#rows and Rio#lines. Rio returns objects loaded via
+      # YAML#load when +records+ is used; returns the YAML text as a String
+      # when +rows+ is used; and returns lines as Strings as normal when
+      # +lines+ is used.  +records+ is the default. In yaml-mode,
+      # <tt>(skip)records</tt> can be called as <tt>(skip)objects</tt> and
+      # <tt>(skip)rows</tt> can be called as <tt>(skip)documents</tt>
+      #
+      # To read a single YAML document, Rio provides #getobj and #load For
+      # example, consider the following partial 'database.yml' from the rails
+      # distribution:
+      #
+      #  development:
+      #    adapter: mysql
+      #    database: rails_development
+      #
+      #  test:
+      #    adapter: mysql
+      #    database: rails_test
+      #
+      #
+      # To get the object represented in the yaml file:
+      #
+      #  rio('database.yml').yaml.load
+      #     ==>{"development"=>{"adapter"=>"mysql", "database"=>"rails_development"}, 
+      #         "test"=>{"adapter"=>"mysql", "database"=>"rails_test"}}
+      #
+      # Or one could read parts of the file like so:
+      #
+      #  rio('database.yml').yaml.getobj['development']['database']
+      #     ==>"rails_development"
+      #
+      # Single objects can be written using #putobj and #putobj!
+      # which is aliased to #dump
+      #
+      #  anobject = {
+      #    'production' => {
+      #      'adapter' => 'mysql',
+      #      'database' => 'rails_production',
+      #    }
+      #  }
+      #  rio('afile.yaml').yaml.dump(anobject)
+      #
+      # The YAML extension changes the way the grande copy operators interpret
+      # their argument. Rio#< (copy-from) and Rio#<< (append-from) treat an
+      # array as an array of objects which are converted using their #to_yaml
+      # method before writing.
+      #
+      #  rio('afile.yaml').yaml < [obj1, obj2, obj3]
+      #
+      # Because of this, copying an ::Array must be done like this:
+      #
+      #  rio('afile.yaml').yaml < [anarray]
+      #
+      # If their argument is a Rio or ::IO it is iterate through as normal,
+      # with each record converted using its to_yaml method.
+      #
+      # For all other objects, the result of their +to_yaml+ operator is
+      # simply written.
+      #
+      #  rio('afile.yaml').yaml < anobject
+      #
+      # Rio#> (copy-to) and Rio#>> (append-to) will fill an array with with
+      # all selected YAML documents in the Rio. For non-arrays, the yaml text
+      # is copied. (This may change if a useful reasonable alternative can be
+      # found) rio('afile.yaml').yaml > anarray # load all YAML documents from
+      # 'afile.yaml'
+      #
+      # Single objects can be written using Rio#putrec (aliased to Rio#putobj
+      # and Rio#dump)
+      #
+      #  rio('afile.yaml').yaml.putobj(anobject)
+      #
+      # Single objects can be loaded using Rio#getrec (aliase to Rio#getobj
+      # and Rio#load)
+      #
+      #  anobject = rio('afile.yaml').yaml.getobj
+      #
+      # Note that other than this redefinition of what a record is and how the
+      # copy operators interpret their argument, a Rio in yaml-mode is just
+      # like any other Rio. And all the things you can do with any Rio come
+      # for free.  They can be iterated over using #each and read into an
+      # array using #[] just like any other Rio. All the selection criteria
+      # are identical also.
+      #
+      # Get the first three objects into an array:
+      #
+      #  array_of_objects = rio('afile.yaml').yaml[0..2]
+      #
+      # Iterate over only YAML documents that are a kind_of ::Hash use:
+      #
+      #  rio('afile.yaml').yaml(::Hash) {|ahash| ...} 
+      #
+      # This takes advantage of the fact that the default for matching records
+      # is <tt>===</tt>
+      #
+      # Selecting records using a Proc can be used as normal:
+      #
+      #  anarray = rio('afile.yaml').yaml(proc{|anobject| ...}).to_a
+      #
+      # One could even use the copy operator to convert a CSV file to a YAML
+      # representation of the same data:
+      #
+      #  rio('afile.yaml').yaml < rio('afile.csv').csv 
+      #
+      def yaml(&block) 
+        target.yaml(&block); 
+        self 
+      end
+
+
+      # Queries if the Rio is in yaml-mode. See #yaml
+      def yaml?() target.yaml? end
+
+
+      # Select objects from a YAML file. See #yaml and RIO::Doc::INTRO
+      def objects(*selectors,&block) target.objects(*selectors,&block); self end
+
+
+      # Reject objects from a YAML file. See #yaml and RIO::Doc::INTRO
+      def skipobjects(*selectors,&block) target.skipobjects(*selectors,&block); self end
+
+
+      # Select documents from a YAML file. See #yaml and RIO::Doc::INTRO
+      def documents(*selectors,&block) target.documents(*selectors,&block); self end
+
+
+      # Reject documents from a YAML file. Calls #skiprows. See #yaml and RIO::Doc::INTRO
+      def skipdocuments(*selectors,&block) target.skipdocuments(*selectors,&block); self end
+
+      # Calls YAML.load.
+      #
+      # Loads a single YAML object from the stream referenced by the Rio
+      #
+      #   rio('database.yml').yaml.getobj
+      #
+      # See #yaml and RIO::Doc::INTRO
+      #
+      def getobj() target.getobj() end
+
+      # Alias for #getobj
+      def load() target.load() end
+
+      # Alias for #getrec
+      #def getdoc() target.getdoc() end
+
+
+      # Calls YAML.dump, leaving the Rio open.
+      def putobj(obj) target.putobj(obj); self end
+
+      # Dumps an object to a Rio as with Rio#putobj, and closes the Rio.
+      #
+      #  rio('afile.yaml').yaml.putobj!(anobject)
+      #
+      # is identical to 
+      #
+      #  rio('afile.yaml').yaml.putobj(anobject).close
+      #
+      def putobj!(obj) target.putobj!(obj); self end
+
+      # Alias for Rio#putobj!
+      def dump(obj) target.dump(obj); self end
+
+    end
+  end
+end

data/lib/rio/ioh.rb

@@ -44,10 +44,11 @@ module RIO
       def initialize(ios,*args)
         @ios = ios
       end
-      def initialize_copy(*args)
-        #p callstr('ioh:initialize_copy',*args)
+      def initialize_copy(other)
+        #p callstr('ioh:initialize_copy',other)
         super
-        @ios = @ios.clone unless @ios.nil?
+        #p @ios
+        @ios = other.ios.clone unless other.ios.nil?
       end
       def callstr(func,*args)
         self.class.to_s+'['+self.to_s+']'+'.'+func.to_s+'('+args.join(',')+')'
@@ -96,6 +97,7 @@ module RIO
                               :fileno,
                               :close_read,:close_write,
                               :fsync,:sync,:sync=,:fcntl,:ioctl)
+
       def method_missing(sym,*args,&block)
         #p callstr('method_missing',sym,*args)
         handle.__send__(sym,*args,&block)

data/lib/rio/matchrecord.rb

@@ -84,7 +84,8 @@ module RIO
         end
         def match?(val,recno)
           #p "match?(#{val},#{recno}) select_arg=#{@select_arg}"
-          @select_arg.call(val,recno,@therio)
+          args = [val,recno,@therio]
+          @select_arg.call(*args[0,@select_arg.arity])
         end
       end
       class Symbol < Base
@@ -107,6 +108,12 @@ module RIO
           @select_arg.all? { |sel| sel.match?(val,recno) }
         end
       end
+      class Case < Base
+        def match?(val,recno)
+          #p "match?(#{val},#{recno}) select_arg=#{@select_arg}"
+          @select_arg === val
+        end
+      end
       def create(therio,arg)
         case arg
         when ::Regexp
@@ -122,7 +129,7 @@ module RIO
         when ::Array
           Match::Record::And.new(arg,therio)
         else
-          raise ArgumentError,"Argument must be a Regexp,Range,Fixnum,Proc, or Symbol"
+          Match::Record::Case.new(arg)
         end
       end
       module_function :create

data/lib/rio/ops/dir.rb

@@ -38,6 +38,8 @@
 require 'extensions/object'
 require 'rio/grande'
 require 'rio/cp'
+require 'rio/ops/either'
+
 module RIO
   module Impl
     module U
@@ -73,7 +75,6 @@ module RIO
   module Ops
     module Dir
       module ExistOrNot
-        require 'rio/ops/either'
         include ::RIO::Ops::FileOrDir::ExistOrNot
       end
     end

data/lib/rio/ops/either.rb

@@ -53,7 +53,15 @@ module RIO
   end
   module Ops
     module FileOrDir
+      module ExistOrNot
+      end
+      module NonExisting
+        include ExistOrNot
+      end
+
       module Existing
+        include ExistOrNot
+
         def chmod(mod) rtn_self { Impl::U.chmod(mod,fspath) } end
         def chown(owner,group) rtn_self { Impl::U.chown(owner,group,fspath) } end
         def must_exist() self end
@@ -107,7 +115,7 @@ module RIO
           end
         end
 
-        require 'Pathname'
+        require 'pathname'
         def realpath
           new_rio(Impl::U.realpath(fspath))
         end
@@ -117,14 +125,6 @@ module RIO
 
       end
 
-      module ExistOrNot
-      end
-      module Existing
-        include ExistOrNot
-      end
-      module NonExisting
-        include ExistOrNot
-      end
     end
   end
 end

data/lib/rio/ops/file.rb

@@ -36,6 +36,9 @@
 
 
 require 'rio/cp'
+require 'rio/piper/cp'
+require 'rio/ops/either'
+
 module RIO
   module Impl
     module U
@@ -58,7 +61,6 @@ module RIO
   module Ops
     module File
       module ExistOrNot
-        require 'rio/ops/either'
         include FileOrDir::ExistOrNot
        end
       module Existing
@@ -66,6 +68,7 @@ module RIO
         include FileOrDir::Existing
         include Cp::File::Output
         include Cp::File::Input
+        include Piper::Cp::Input
 
         def selective?
           %w[stream_sel stream_nosel].any? { |k| cx.has_key?(k) }

data/lib/rio/ops/path.rb

@@ -81,7 +81,8 @@ module RIO
       module URI
         def abs(base=nil)
           if base.nil?
-            new_rio(rl.abs)
+            nrio = new_rio(rl.abs)
+            nrio
           else
             new_rio(rl,ensure_rio(base).abs.to_uri).abs
           end
@@ -93,8 +94,15 @@ module RIO
         def route_from(other)
           new_rio(rl.abs.route_from(ensure_rio(other).rl.abs))
         end
-        def rel(other)
-          route_from(other)
+        def rel(other=nil)
+          if other.nil?
+            base = self.abs.dirname
+          else
+            new_rio(self.rl.abs.route_from(ensure_rio(other).rl.abs))
+          end
+          base = other.nil? ? self.abs : ensure_rio(other).dup
+          base += '/' if base.directory? and base.to_s[-1] != '/'
+          route_from(base)
         end
 #        def rel(other=nil)
 #          if other.nil?
@@ -131,15 +139,9 @@ module RIO
         end
         def split()
           require 'rio/to_rio'
-          pth = rl.path_no_slash
-          parts = pth.split(RIO::Local::SEPARATOR)
-          if abs?
-            rooturi = rl.uri.clone
-            rooturi.path = '/'
-            parts[0] = rooturi
-          end
-          # give each rio the correct base
-          parts.inject([rio(parts.shift)]) { |ary,d| ary << rio(d,{ 'base' => ary[-1].abs.to_url+'/'} ) }.extend(ToRio::Array)
+          parts = self.rl.split
+          # map to rios and extend the array with to_array
+          parts.map { |arl| rio(arl) }.extend(ToRio::Array)
         end
         def basename(*args)
           unless args.empty?
@@ -148,22 +150,26 @@ module RIO
           end
           #p self.ext?.inspect
           fn = Impl::U.basename(rl.path_no_slash,self.ext?)
-          new_rio(fn,{'base' => _calc_base()})
+          new_rio(fn,{:base => _calc_base()})
         end
         def filename()
           fn = Impl::U.basename(rl.path_no_slash)
-          new_rio(fn,{'base' => _calc_base()})
+          new_rio(fn,{:base => _calc_base()})
         end
         def _calc_base()
           dn = Impl::U.dirname(rl.path_no_slash)
-          if dn[0] == ?/
-            dn 
-          else
-            self.base.to_url + dn + '/'
-          end
+          dn[0] == ?/ ? dn : self.base.to_url + dn + '/' #'
+#          if dn[0] == ?/
+#            dn 
+#          else
+#            self.base.to_url + dn + '/'
+#          end
         end
+        private :_calc_base
+
         def dirname(*args)
-          new_rio(Impl::U.dirname(rl.path_no_slash,*args))
+          #new_rio(Impl::U.dirname(rl.path_no_slash,*args))
+          new_rio(rl.dirname)
         end
 
         def sub(re,arg)