rio 0.3.3 → 0.3.4

data/lib/rio/if/path.rb

@@ -321,7 +321,7 @@ module RIO
     def /(arg) target / arg end
 
 
-    # Create a Rio referencing Rio#to_s + arg.to_s
+    # Create a Rio referencing Rio#to_str + arg.to_str
     #
     #  rio('afile') + '-0.1'   #=> rio('afile-0.1')
     #
@@ -365,7 +365,9 @@ module RIO
     # Rio#rootpath
     #
     #
-    def rootpath(*args) target.rootpath(*args) end
+    def rootpath(*args) # :nodoc:
+      target.rootpath(*args) 
+    end
 
 
     # Rio#root
@@ -386,7 +388,7 @@ module RIO
     ##def getwd(*args,&block) target.getwd(*args,&block) end
 
 
-    # Returns the scheme for the Rio's URI like URI#scheme where the Rio is represented
+    # Returns the scheme for the Rio's URI-like URI#scheme where the Rio is represented
     # by a standard URI. For Rios that are not represented by standard URIs one of
     # Rio's non-standard schemes is returned. 
     #
@@ -434,6 +436,26 @@ module RIO
     #
     def route_to(other) target.route_to(other)  end
 
+    # Calls Pathname#cleanpath
+    #
+    # Returns a new Rio whose path is the clean pathname of +self+ with 
+    # consecutive slashes and useless dots
+    # removed.  The filesystem is not accessed.
+    #
+    # If +consider_symlink+ is +true+, then a more conservative algorithm is used
+    # to avoid breaking symbolic linkages.  This may retain more <tt>..</tt>
+    # entries than absolutely necessary, but without accessing the filesystem,
+    # this can't be avoided.  See #realpath.
+    #
+    def cleanpath(consider_symlink=false) target.cleanpath(consider_symlink)  end
 
+    # Calls Pathname#realpath
+    #
+    # Returns a new Rio whose path is the real (absolute) pathname 
+    # of +self+ in the actual filesystem.
+    # The real pathname doesn't contain symlinks or useless dots.
+    #
+    def realpath() target.realpath()  end
+    
   end
 end

data/lib/rio/if/stream.rb

@@ -51,22 +51,11 @@ module RIO
 
     # Slurps the contents of the rio into a string. See also Rio#contents
     #
-    #  astring = rio('afile.txt').slurp # slurp the entire contents of afile.txt into astring
+    #  astring = rio('afile.txt').contents # slurp the entire contents of afile.txt into astring
     # 
-    # Alpha Note: Considering removing Rio#contents and Rio#slurp in favor of +to_string+. Is 
-    # this the Ruby way? Is it too confusing with a +to_s+ and +to_str+ already? Is it a good idea?
-    def slurp() target.slurp() end
-
-    # Returns the contents of the rio as a string. See also Rio#slurp 
-    #
-    #  astring = rio('afile.txt').contents # copies the entire contents of afile.txt into astring
-    #
-    # Alpha Note: Considering removing Rio#contents and Rio#slurp in favor of +to_string+. Is 
-    # this the Ruby way? Is it too confusing with a +to_s+ and +to_str+ already? Is it a good idea?
     def contents() target.contents() end
 
 
-
     # Rio#each_record
     # 
     #
@@ -98,8 +87,8 @@ module RIO
     def lineno() target.lineno() end
 
     # Calls IO#lineno=
-    #      ario.lineno = integer    => integer
-    # Manually sets the current line number to the given value. +$.+ is
+    #  ario.lineno = integer    => integer
+    # Manually sets the current line number to the given value. <tt>$.</tt> is
     # updated only on the next read.
     #
     # f = rio("testfile")
@@ -122,35 +111,25 @@ module RIO
     #
     # To illustrate: Given a file containing three lines "L0\n","L1\n","L2\n"
     # and a Range (0..1)
-    # Each of the following would fill ay with ["L0\n", "L1\n"]
-    # 
-    #  ay = []
+    # Each of the following would fill anarray with ["L0\n", "L1\n"]
+    #
+    # Given:
+    #  anarray = []
     #  range = (0..1)
-    #  ain = rio('afile').readlines
-    #  ain.each_with_index do |line,i|
-    #    ay << line if range === i
+    #
+    #  all_lines = rio('afile').readlines
+    #  all_lines.each_with_index do |line,i|
+    #    anarray << line if range === i
     #  end
-    # 
-    #  ay = rio('afile').lines[0..1]
-    #  
+    #  # anarray == ["L0\n", "L1\n"]
+    #
+    #  anarray = rio('afile').lines[0..1] # anarray == ["L0\n", "L1\n"]
+    #
     # +recno+ counts the number of times Rio#getrec or Rio#each is used to get a record. 
     # so +recno+ will only concern parts of the file read with grande methods 
     # Rio#each, Rio#[], Rio#getrec 
     # 
     # See also Rio#lineno
-    #  f = rio("afile")
-    #  r1 = (0..1)
-    #  r2 = (100..101)
-    #
-    #  aout1 = []
-    #  f.each { |rec|
-    #    aout << rec if r1 === f.recno or r2 === f.recno
-    #  }
-    #
-    #  aout2 = f[r1,r2]
-    #
-    #  aout1 == aout2 # true
-    #
     def recno() target.recno() end
 
 
@@ -281,7 +260,7 @@ module RIO
 
     # Calls IO#puts
     #
-    # Writes the given objects to the rio as with  Rio#print  . 
+    # Writes the given objects to the rio as with Rio#print. 
     # Writes a record separator (typically a newline) after any that do not already end with a newline sequence. 
     # If called with an array argument, writes each element on a new line. 
     # If called without arguments, outputs a single record separator.
@@ -595,5 +574,51 @@ module RIO
     #
     def ungetc(*args) target.ungetc(*args); self end
     
+    # Sets the 'sync-mode' of the underlying IO using IO#sync=
+    #      ario.sync(boolean=true,&block)   => ario
+    # Sets the Rio so that its 'sync mode' will be set to +true+ or +false+ when opened, or set
+    # it immediately if already open. When sync mode is
+    # true, all output is immediately flushed to the underlying operating
+    # system and is not buffered internally. Returns the rio. See
+    # also Rio#fsync, Rio#nosync, Rio#sync?.
+    #
+    # If a block is given behaves like <tt>ario.sync(arg).each(&block)</tt>
+    #
+    #  f = rio("testfile").sync.puts("Hello World")
+    #  f.sync?     # => true
+    #
+    def sync(arg=true,&block) target.sync(arg,&block); self end
+
+    # Similar to IO#sync= false
+    #      ario.nosync(&block)   => ario
+    # Sets the Rio so that its 'sync mode' will be set to +false+ when opened, or set
+    # it immediately if already open. When sync mode is
+    # true, all output is immediately flushed to the underlying operating
+    # system and is not buffered internally. Returns the rio. See
+    # also Rio#fsync, Rio#sync, Rio#sync?.
+    #
+    # If a block is given behaves like <tt>ario.nosync.each(&block)</tt>
+    #
+    #  f = rio("testfile").sync.puts("Hello World")
+    #  f.sync?     # => true
+    #  f.nosync
+    #  f.sync?     # => false
+    #
+    def nosync(arg=false,&block) target.nosync(arg,&block); self end
+
+    # Query the current "sync mode" with IO#sync
+    #      ario.sync?    => true or false
+    # Returns the current "sync mode" of _ario_. When sync mode is true,
+    # all output is immediately flushed to the underlying operating
+    # system and is not buffered by Ruby internally. See also Rio#fsync,
+    # Rio#sync, Rio#nosync
+    #
+    #  f = rio("testfile")
+    #  f.sync?   #=> false
+    #
+    def sync?() target.sync?() end
+
+
+
   end
 end

data/lib/rio/if/temp.rb

@@ -37,8 +37,8 @@
 
 module RIO
   class Rio
-    def file() target.file; self end
-    def dir() target.dir; self end
+    #def file() target.file; self end
+    #def dir() target.dir; self end
       
 
   end

data/lib/rio/if/test.rb

@@ -41,27 +41,35 @@ module RIO
     #  rio('afile').blockdev?     =>  true or false
     # Returns +true+ if the named file is a block device.
     def blockdev?() target.blockdev?() end
+
     # Calls FileTest#chardev?
     #  rio('afile').chardev?     =>  true or false
     # Returns +true+ if the named file is a character device.
     def chardev?() target.chardev? end
+
     # Calls FileTest#directory?
     #  rio('afile').directory?     =>  true or false
     # Returns +true+ if the named file is a directory, +false+ otherwise.
     def directory?() target.directory? end
+
+    # Alias for #directory?
     def dir?() target.dir? end
+
     # Calls FileTest#exist?
     #  rio('afile').exist?()    =>  true or false
     # Returns +true+ if the named file exists.
     def exist?() target.exist? end
+
     # Calls FileTest#file?
     #  rio('afile').file?     => true or false
     # Returns +true+ if the named file exists and is a regular file.
     def file?() target.file? end
+
     # Calls FileTest#socket?
     #  rio('afile').socket?     =>  true or false
     # Returns +true+ if the named file is a socket.
     def socket?() target.socket? end 
+
     # Calls FileTest#symlink?
     #  rio('afile').symlink?     =>  true or false
     # Returns +true+ if the named file is a symbolic link.
@@ -214,6 +222,21 @@ module RIO
     # 
     def absolute?() target.absolute?()  end
 
+    # Calls Pathname#mountpoint?
+    #
+    # Returns +true+ if <tt>self</tt> points to a mountpoint.
+    def mountpoint?() target.mountpoint?()  end
+    
+    # Calls Pathname#root?
+    #
+    # #root? is a predicate for root directories.  I.e. it returns +true+ if the
+    # pathname consists of consecutive slashes.
+    #
+    # It doesn't access the actual filesystem.  So it may return +false+ for some
+    # pathnames which points to roots such as <tt>/usr/..</tt>.
+    #
+    def root?() target.root?()  end
 
+    
   end
 end

data/lib/rio/impl/path.rb

@@ -77,6 +77,11 @@ module RIO
       def self.writable?(s,*args) ::FileTest.writable?(s,*args) end
       def self.writable_real?(s,*args) ::FileTest.writable_real?(s,*args) end
       def self.zero?(s,*args) ::FileTest.zero?(s,*args) end
+      require 'pathname'
+      def self.root?(s) ::Pathname.new(s).root? end
+      def self.mountpoint?(s) ::Pathname.new(s).mountpoint? end
+      def self.realpath(s) ::Pathname.new(s).realpath end
+      def self.cleanpath(s,*args) ::Pathname.new(s).cleanpath(*args) end
     end
   end
 end

data/lib/rio/match.rb

@@ -40,9 +40,12 @@ module RIO
     module Common
 
       def ss_type?(keys)
-        case
-        when cx['ss_type'].nil? then keys[0]
-        when cx['ss_type'].in?(keys) then cx['ss_type']
+        #p cx,keys
+        case cx['ss_type']
+        when nil
+          keys[0]
+       else
+          cx['ss_type']
         end
       end
       

data/lib/rio/matchrecord.rb

@@ -41,7 +41,7 @@ module RIO
       
       class Base
         def initialize(arg)
-        @select_arg = arg
+          @select_arg = arg
         end
         def inspect
           @select_arg.inspect
@@ -55,40 +55,27 @@ module RIO
       class All < Base
         def match?(val,recno) true end
         def match_all?() true end
-        def =~(record) true end
       end
       class None < Base
         def match?(val,recno) false end
         def match_none?() true end
-        def =~(record) false end
       end
       class RegExp < Base
         def match?(val,recno) 
           @select_arg.match(val)
         end
-        def =~(record) 
-          @select_arg =~ record 
-        end
       end
       class Range < Base
         def match?(val,recno)
           #p "match?(#{val},#{recno}) select_arg=#{@select_arg}"
           @select_arg === recno
         end
-        def =~(record) 
-          #p "=~(#{record},#{record.recno}) select_arg=#{@select_arg}"
-          @select_arg === record.recno 
-        end
       end
       class Fixnum < Base
         def match?(val,recno)
           #p "match?(#{val},#{recno}) select_arg=#{@select_arg}"
           @select_arg === recno
         end
-        def =~(record) 
-          #p "=~(#{record},#{record.recno}) select_arg=#{@select_arg}"
-          @select_arg === record.recno 
-        end
       end
       class Proc < Base
         def initialize(arg,therio)
@@ -99,19 +86,46 @@ module RIO
           #p "match?(#{val},#{recno}) select_arg=#{@select_arg}"
           @select_arg.call(val,recno,@therio)
         end
-        def =~(record)
-          @select_arg.call(record,record.recno,@therio)
-        end
       end
       class Symbol < Base
         def match?(val,recno)
           #p "match?(#{val},#{recno}) select_arg=#{@select_arg}"
           val.__send__(@select_arg)
         end
-        def =~(record)
-          record.__send__(@select_arg)
+      end
+      class And < Base
+        def initialize(matches,therio)
+          list = []
+          matches.each do |arg|
+            list << Match::Record.create(therio,arg)
+          end
+          super(list)
+          @therio = therio
+        end
+        def match?(val,recno)
+          #p "match?(#{val},#{recno}) select_arg=#{@select_arg}"
+          @select_arg.all? { |sel| sel.match?(val,recno) }
+        end
+      end
+      def create(therio,arg)
+        case arg
+        when ::Regexp
+          Match::Record::RegExp.new(arg)
+        when ::Range
+          Match::Record::Range.new(arg)
+        when ::Proc
+          Match::Record::Proc.new(arg,therio)
+        when ::Symbol
+          Match::Record::Symbol.new(arg)
+        when ::Fixnum
+          Match::Record::Fixnum.new(arg)
+        when ::Array
+          Match::Record::And.new(arg,therio)
+        else
+          raise ArgumentError,"Argument must be a Regexp,Range,Fixnum,Proc, or Symbol"
         end
       end
+      module_function :create
     end
   end
 
@@ -162,20 +176,23 @@ module RIO
           @list.nil? ? nil : self
         end
         def create_sel(therio,arg)
-          case arg
-          when ::Regexp
-            Match::Record::RegExp.new(arg)
-          when ::Range
-            Match::Record::Range.new(arg)
-          when ::Proc
-            Match::Record::Proc.new(arg,therio)
-          when ::Symbol
-            Match::Record::Symbol.new(arg)
-          when ::Fixnum
-            Match::Record::Fixnum.new(arg)
-          else
-            raise ArgumentError,"Argument must be a Regexp,Range,Fixnum,Proc, or Symbol"
-          end
+          Match::Record.create(therio,arg)
+#           case arg
+#           when ::Regexp
+#             Match::Record::RegExp.new(arg)
+#           when ::Range
+#             Match::Record::Range.new(arg)
+#           when ::Proc
+#             Match::Record::Proc.new(arg,therio)
+#           when ::Symbol
+#             Match::Record::Symbol.new(arg)
+#           when ::Fixnum
+#             Match::Record::Fixnum.new(arg)
+#           when ::Array
+#             Match::Record::And.new(arg)
+#           else
+#             raise ArgumentError,"Argument must be a Regexp,Range,Fixnum,Proc, or Symbol"
+#           end
         end
         def match?(val,recno)
           # !@list.nil? && (@list.empty? || @list.detect { |sel| sel.match?(val,recno) } || false) && true
@@ -190,9 +207,6 @@ module RIO
           return as if al
           return false
         end
-        def =~(el)
-          !@list.nil? && (@list.empty? || @list.detect { |sel| sel =~ el } || false) && true
-        end
         def always?() !@list.nil? && @list.empty? end
         def never?() @list.nil? end
       end
@@ -253,16 +267,6 @@ module RIO
           ok = ((!@sel.nil? && (as = @sel.match?(val,recno))) && !(!@rej.nil? && @rej.match?(val,recno)))
           return (ok ? as : ok)
         end
-        def =~(el)
-          return @always unless @always.nil?
-          (!@sel.nil? && (@sel =~ el)) && !(!@rej.nil? && (@rej =~ el))
-
-          #yes = (!@sel.nil? && (@sel =~ el))
-          #no = (!@rej.nil? && (@rej =~ el))
-          #p "yes=#{yes} no=#{no} el=#{el}"
-          #return yes && !no
-          #(@sel =~ el) && !(@rej =~ el)
-        end
       end
     end
   end