rio 0.3.3 → 0.3.4

data/lib/rio/if/grande_entry.rb

@@ -0,0 +1,355 @@
+#--
+# =============================================================================== 
+# 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
+  class Rio
+    # Grande Directory Selection Method 
+    #
+    # Sets the rio to return directories. _args_ can be used to select which directories are returned.
+    #  ario.files(*args) do |f|
+    #    f.directory?      #=> true
+    #  end
+    # No aguments selects all directories.
+    # if _args_ are:
+    # Regexp:: selects matching directories
+    # glob::   selects matching directories
+    # Proc::   called for each directory. the directory is processed unless the proc returns false
+    # Symbol:: sent to each directory. Each directory is processed unless the symbol returns false
+    #
+    # If a block is given, behaves like <tt>ario.dirs(*args).each(&block)</tt>
+    #
+    # See also Rio#files, Rio#entries, Rio#skipdirs
+    #
+    #  rio('adir').dirs { |frio| ... } # process all directories in 'adir'    
+    #  rio('adir').all.dirs { |frio| ... } #  same thing recursively
+    #  rio('adir').dirs(/^\./) { |frio| ...} # process dot directories
+    #  rio('adir').dirs[/^\./] # return an array of dot directories
+    #  rio('adir').dirs[:symlink?] # an array of symlinks to directories
+    #
+    def dirs(*args,&block) target.dirs(*args,&block); self end
+    
+    # Grande Directory Exclude Method 
+    #
+    # If no args are provided selects anything but directories.
+    #  ario.skipdirs do |el|
+    #    el.directory?     #=> false
+    #  end
+    # If args are provided, sets the rio to select directories as with Rio#dirs, but the arguments are
+    # used to determine which directories will *not* be processed
+    #
+    # If a block is given behaves like 
+    #  ario.skipdirs(*args).each(&block)
+    #
+    # See Rio#dirs
+    #
+    #  rio('adir').skipdirs { |ent| ... } # iterate through everything except directories
+    #  rio('adir').skipdirs(/^\./) { |drio| ... } # iterate through directories, skipping dot directories
+    # 
+    #
+    def skipdirs(*args,&block) target.skipdirs(*args,&block); self end
+
+
+    # Grande Directory Entry Selection Method 
+    #
+    # No aguments selects all entries.
+    #
+    # if +args+ are:
+    # Regexp:: selects matching entries
+    # glob::   selects matching entries
+    # Proc::   called for each entry. the entry is processed unless the proc returns false
+    # Symbol:: sent to each entry. Each entry is processed unless the symbol returns false
+    #
+    # If a block is given, behaves like <tt>ario.etries(*args).each(&block)</tt>
+    #
+    # See also Rio#files, Rio#dirs, Rio#skipentries
+    #
+    #  rio('adir').entries { |frio| ... } # process all entries in 'adir'    
+    #  rio('adir').all.entries { |frio| ... } #  same thing recursively
+    #  rio('adir').entries(/^\./) { |frio| ...} # process entries starting with a dot
+    #  rio('adir').entries[/^\./] # return an array of all entries starting with a dot
+    #  rio('adir').entries[:symlink?] # an array of symlinks in 'adir'
+    #
+    def entries(*args,&block) target.entries(*args,&block); self end
+
+    # Grande Directory Entry Rejection Method 
+    #
+    # No aguments rejects all entries.
+    #
+    # Behaves like Rio#entries, except that matching entries are excluded.
+    #
+    def skipentries(*args,&block) target.skipentries(*args,&block); self end
+
+    
+    # Grande File Selection Method 
+    #
+    # Configures the rio to process files. +args+ can be used to select which files are returned.
+    #  ario.files(*args) do |f|
+    #    f.file?      #=> true
+    #  end
+    # No aguments selects all files.
+    #
+    # +args+ may be zero or more of the following:
+    #
+    # Regexp:: selects matching files
+    # String:: treated as a glob, and selects matching files
+    # Proc::   called for each file. the file is processed unless the proc returns false
+    # Symbol:: sent to each file. Each file is processed unless the symbol returns false
+    #
+    # +files+ returns the Rio which called it. This might seem counter-intuitive at first. 
+    # One might reasonably assume that
+    #  rio('adir').files('*.rb')
+    # would return files. It does not. It configures the rio to return files and returns
+    # the Rio. This enables chaining for further configuration so constructs like
+    #  rio('adir').all.files('*.rb').norecurse('.svn')
+    # are possible.
+    #
+    # If a block is given, behaves like 
+    #  ario.files(*args).each
+    #
+    # 
+    # See also Rio#dirs, Rio#entries, Rio#skipfiles
+    #
+    #  rio('adir').files { |frio| ... } # process all files in 'adir'    
+    #  rio('adir').all.files { |frio| ... } #  same thing recursively
+    #  rio('adir').files('*.rb') { |frio| ...} # process .rb files
+    #  rio('adir').files['*.rb'] # return an array of .rb files
+    #  rio('adir').files[/\.rb$/] # same thing using a regular expression
+    #  rio('adir').files[:symlink?] # an array of symlinks to files
+    #  rio('adir').files >> rio('other_dir') # copy files to 'other_dir'
+    #  rio('adir').files('*.rb') >> rio('other_dir') # only copy .rb files
+    #
+    # For Rios that refer to files, <tt>files(*args)</tt> causes the file to be processed only if 
+    # it meets the criteria specified by the args.
+    #
+    #  rio('afile.z').files['*.z'] #=> [rio('afile.z')]
+    #  rio('afile.q').files['*.z'] #=> []
+    #
+    # === Example Problem
+    #
+    # Fill the array +ruby_progs+ with all ruby programs in a directory and its subdirectories, 
+    # skipping those in _subversion_ (.svn) directories. 
+    #
+    #  ruby_progs = []
+    # 
+    # For the purposes of this problem, a Ruby program is defined as a file ending with .rb or a file
+    # that is executable and whose shebang line contains 'ruby':
+    #
+    #  is_ruby_exe = proc{ |f| f.executable? and f.gets =~ /^#!.+ruby/ }
+    #
+    # ==== Solution 1. Use the subscript operator.
+    #
+    #  ruby_progs = rio('adir').norecurse('.svn').files['*.rb',is_ruby_exe]
+    #
+    # Explanation:
+    #
+    # 1. Create the Rio
+    #
+    #    Create a Rio for a directory
+    #     rio('adir')
+    #
+    # 2. Configure the Rio
+    #
+    #    Specify recursion and that '.svn' directories should not be included.
+    #     rio('adir').norecurse('.svn')
+    #    Select files
+    #     rio('adir').norecurse('.svn').files
+    #    Limit to files ending with '.rb'
+    #     rio('adir').norecurse('.svn').files('*.rb')
+    #    Also allow files for whom +is_ruby_exe+ returns true
+    #     rio('adir').norecurse('.svn').files('*.rb',is_ruby_exe)
+    #
+    # 3. Do the I/O
+    #
+    #    Return an array rather than iterating thru them
+    #     ruby_progs = rio('adir').norecurse('.svn').files['*.rb',is_ruby_exe]
+    #
+    # ==== Solution  2. Use the copy-to operator
+    #
+    #  rio('adir').files('*.rb',is_ruby_exe).norecurse('.svn') > ruby_progs
+    #
+    # Explanation:
+    #
+    # 1. Create the Rio
+    #
+    #    Create a Rio for a directory
+    #     rio('adir')
+    #
+    # 2. Configure the Rio
+    #
+    #    Select only files
+    #     rio('adir').files
+    #    Limit to files ending with '.rb'
+    #     rio('adir').files('*.rb')
+    #    Also allow files for whom +is_ruby_exe+ returns true
+    #     rio('adir').files('*.rb',is_ruby_exe)
+    #    Specify recursion and that '.svn' directories should not be included.
+    #     rio('adir').files('*.rb',is_ruby_exe).norecurse('.svn')
+    #
+    # 3. Do the I/O
+    #
+    #    Copy the Rio to ruby_progs
+    #     rio('adir').files('*.rb',is_ruby_exe).norecurse('.svn') > ruby_progs
+    #
+    # ==== Example Discussion
+    #
+    # Note that the only difference between Step 2 of Solution 1 and that of Solution 2 is 
+    # the order of the configuration methods. Step 2 of Solution 1 would have worked equally 
+    # well:
+    #
+    #  rio('adir').norecurse('.svn').files('*.rb',is_ruby_exe) > ruby_progs
+    #
+    # Furthermore if our problem were changed slightly and instead of having our results
+    # ending up in an array, we wished to iterate through them, we could use:
+    #
+    #  rio('adir').norecurse('.svn').files('*.rb',is_ruby_exe) { |ruby_prog_rio| ... }
+    #
+    # Note the similarities. In fact, solution 1 could have been written:
+    #  
+    #  rio('adir').norecurse('.svn').files('*.rb',is_ruby_exe).to_a
+    # or
+    #  rio('adir').norecurse('.svn').files('*.rb',is_ruby_exe)[]
+    #
+    # Passing the arguments for +files+ to the subscript operator is syntactic sugar.
+    # The subscript operator does not really take any arguments of its own. It always
+    # passes them to the most recently called of the grande selection methods (or the
+    # default selection method, if none have been called). So,
+    #
+    #  rio('adir').files['*.rb']
+    # is a shortcut for
+    #  rio('adir').files('*.rb').to_a
+    #
+    #  rio('adir')['*.rb']
+    # is a shortcut for
+    #  rio('adir').entries('*.rb').to_a
+    #
+    #  rio('afile').lines[0..10]
+    # is a shortcut for
+    #  rio('afile').lines(0..10).to_a
+    #
+    # And so on.
+    # 
+    #
+    #
+    def files(*args,&block) target.files(*args,&block); self end
+
+    # Grande File Exclude Method 
+    #
+    # If no args are provided selects anything but files.
+    #  ario.skipfiles do |el|
+    #    el.file?     #=> false
+    #  end
+    # If args are provided, sets the rio to select files as with Rio#files, but the arguments are
+    # used to determine which files will *not* be processed
+    #
+    # If a block is given behaves like <tt>ario.skipfiles(*args).each(&block)</tt>
+    #
+    # See Rio#files
+    #
+    #  rio('adir').skipfiles { |ent| ... } # iterate through everything except files
+    #  rio('adir').skipfiles('*~') { |frio| ... } # iterate through files, skipping those ending with a tilde
+    # 
+    #
+    def skipfiles(*args,&block) target.skipfiles(*args,&block); self end
+
+
+    # Returns +true+ if the rio is in +all+ (recursive) mode. See Rio#all
+    #
+    #  adir = rio('adir').all.dirs
+    #  adir.all? # true
+    #  adir.each do |subdir|
+    #    subdir.all?  # true
+    #  end
+    #
+    #  rio('adir').all? # false
+    #  
+    def all?() target.all?() end
+
+
+    # Grande Directory Recursion Method
+    # 
+    # Sets the Rio to all mode (recursive)
+    # 
+    # When called with a block, behaves as if all.each(&block) had been called
+    # 
+    # +all+ causes subsequent calls to +files+ or +dirs+ to be applied recursively
+    # to subdirectories
+    #
+    #  rio('adir').all.files('*.[ch]').each { |file| ... } # process all c language source files in adir 
+    #                                                      # and all subdirectories of adir
+    #  rio('adir').all.files(/\.[ch]$/) { |file| ... }     # same as above
+    #  rio('adir').files("*.[ch]").all { |file| ... }      # once again
+    #  rio('adir').all.files["*.[ch]"]                     # same, but return an array instead of iterating
+    #  
+    def all(arg=true,&block) target.all(arg,&block); self end
+
+
+    # Grande Directory Recursion Selection Method
+    # 
+    # Sets the Rio to recurse into directories like Rio#all. If no args are provided behaves like Rio#all. 
+    # If args are provided, they are processed like Rio#dirs, to select which subdirectories should 
+    # be recursed into. Rio#recurse always implies Rio#all.
+    #
+    # +args+ may be one or more of:
+    # Regexp::  recurse into matching subdirectories
+    # glob::    recurse into matching subdirectories
+    # Proc::    called for each directory. The directory is recursed into unless the proc returns false
+    # Symbol::  sent to each directory. Each directory is recursed into unless the symbol returns false
+    #
+    # If a block is given, behaves like <tt>ario.recurse(*args).each(&block)</tt>
+    #
+    # See also Rio#norecurse, Rio#all, Rio#dirs
+    #
+    #  rio('adir').recurse('test*') { |drio| ... } # process all entries and all entries in subdirectories
+    #                                              # starting with 'test' -- recursively
+    #
+    def recurse(*args,&block) target.recurse(*args,&block); self end
+
+
+    # Grande Directory Recursion Exclude Method
+    # 
+    # Sets the Rio to recurse into directories like Rio#all. If no args are provided, no
+    # directories will be recursed into. If args are provided, behaves like Rio#recurse, except
+    # that matching directories will *not* be recursed into
+    #
+    #  rio('adir').norecurse('.svn') { |drio| ... } # recurse, skipping subversion directories
+    #
+    def norecurse(*args,&block) target.norecurse(*args,&block); self end
+
+
+  end
+end
+

data/lib/rio/if/{methods.rb → grande_stream.rb}

@@ -42,12 +42,21 @@ module RIO
     # 
     # If called with a block behaves as if lines(*args).each(&block) had been called
     # 
+    # +lines+ returns the Rio which called it. This might seem counter-intuitive at first. 
+    # One might reasonably assume that
+    #  rio('adir').lines(0..10)
+    # would return lines. It does not. It configures the rio to return lines and returns
+    # the Rio. This enables chaining for further configuration so constructs like
+    #  rio('afile').lines(0..10).skiplines(/::/)
+    # are possible.
+    #
     # If args are provided they may be one or more of the following:
     # Regexp::  any matching record will be processed
     # Range::   specifies a range of records (zero-based) to be included
     # Integer:: interpreted as a one element range of lines to be processed
     # Proc::    a proc which will be called for each record, records are included unless nil or false is returned
     # Symbol::  a symbol which will _sent_ to each record, records are included unless nil or false is returned
+    # Array::   an array of other selectors. records are selected unless any of the matches fail.
     #
     #  rio('f.txt').lines(/^\s*#/) { |line| ... } # iterate over comment-only lines
     #  rio('f.txt').lines(/^\s*#/).each { |line| ... } # same as above
@@ -94,16 +103,12 @@ module RIO
     # and extensions such as Rio#csv.
     #
     # 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
-    # [Integer]
-    #   specifies a record-number (zero-based) to be iterated over by Rio#each or returned by Rio#getrec
-    # [Range]
-    #   specifies a range of records (zero-based) to included in the iteration
-    # [Proc]
-    #   a proc which will be called for each record, records are included unless nil or false is returned
-    # [Symbol]
-    #   a symbol which will _sent_ to each record, records are included unless nil or false is returned
+    # Regexp::  any matching record will be iterated over by Rio#each or returned by Rio#getrec
+    # Integer:: specifies a record-number (zero-based) to be iterated over by Rio#each or returned by Rio#getrec
+    # Range::   specifies a range of records (zero-based) to included in the iteration
+    # Proc::    a proc which will be called for each record, records are included unless nil or false is returned
+    # 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
     #
     # 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>.
@@ -111,23 +116,24 @@ module RIO
     #  rio('afile').records(0) { |line| ... } # iterate over the first line of 'afile'
     #  rio('afile').records(0,5..7)) { |line| ... } # iterate over lines 0,5,6 and 7
     #  rio('afile').records(/Zippy/) { |line| ... } # iterate over all lines containing 'Zippy'
-    #  rio('afile').lines(0,/^\s*#/) { |line| ... } # iterate over the first line and comment lines
-    #  rio('afile').records(0,/^\s*#/) { |line| ... } # same thing
-    #  rio('afile').lines(proc { |rec,rnum,rio| rnum == 0 || rec =~ /^\s*#/ }) { |line| ... } # same thing
-    #  rio('afile').chomp.lines(proc { |rec,rnum,rio| rec.size > 0 }) { |line| ... } # non-empty lines
-    #  # return array containing line 0, all comment lines and any line containing the filename of the Rio
-    #  rio('afile').lines[0,/^\s*#/,proc { |rec,rnum,ario| rec =~ /#{ario.filename}/ }]
     #
+    # 
+    #  rio('f.csv').puts!(["h0,h1","f0,f1"]) # Create f.csv                
+    #
+    #  rio('f.csv').csv.records[]    #==>[["h0", "h1"], ["f0", "f1"]]
+    #  rio('f.csv').csv.lines[]      #==>["h0,h1\n", "f0,f1\n"]
+    #  rio('f.csv').csv.records[0]   #==>[["h0", "h1"]]
     #
     def records(*args,&block) target.records(*args,&block); self end
 
     # Specifies records which should *not* be iterated through by Rio#each or returned by Rio#getrec
     # 
-    # If called with a block behaves as if norecords(*args).each(&block) had been called
+    # If called with a block behaves as if <tt>skiprecords(*args).each(&block)</tt>
+    # had been called
     # 
     # Returns the Rio
     #
-    # See also Rio#records, Rio#nolines, Rio#lines
+    # 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.
@@ -138,22 +144,23 @@ module RIO
     # Range::   specifies a range of records (zero-based) to be excluded
     # Proc::    a proc which will be called for each record, records are excluded unless nil or false is returned
     # Symbol::  a symbol which will _sent_ to each record, records are excluded unless nil or false is returned
+    # Array::   an array of any of the above, all of which must match for the array to match.
     #
     # Note in the following examples that since +lines+ is the default record 
-    # type <tt>ario.norecords(*args)</tt> is effectively 
-    # the same as <tt>ario.nolines(*args)</tt>.
+    # type <tt>ario.skiprecords(*args)</tt> is effectively 
+    # the same as <tt>ario.skiplines(*args)</tt>.
     #
-    #  rio('afile').norecords(0) { |line| ... } # iterate over all but the first line of 'afile'
-    #  rio('afile').norecords(0,5..7)) { |line| ... } # don't iterate over lines 0,5,6 and 7
-    #  rio('afile').norecords(/Zippy/) { |line| ... } # skip all lines containing 'Zippy'
-    #  rio('afile').chomp.nolines(:empty?) { |line| ... } # skip empty lines
+    #  rio('afile').skiprecords(0) { |line| ... } # iterate over all but the first line of 'afile'
+    #  rio('afile').skiprecords(0,5..7)) { |line| ... } # don't iterate over lines 0,5,6 and 7
+    #  rio('afile').skiprecords(/Zippy/) { |line| ... } # skip all lines containing 'Zippy'
+    #  rio('afile').chomp.skiplines(:empty?) { |line| ... } # skip empty lines
     #
-    def norecords(*args,&block) target.norecords(*args,&block); self end
+    def skiprecords(*args,&block) target.skiprecords(*args,&block); self end
 
     # Sets the Rio to read lines and specifies lines which should *not* be iterated through by Rio#each or 
     # returned by Rio#getrec
     # 
-    # If called with a block behaves as if <tt>nolines(*args).each(&block)</tt> had been called
+    # If called with a block behaves as if <tt>skiplines(*args).each(&block)</tt> had been called
     # 
     # Returns the Rio
     #
@@ -162,32 +169,33 @@ module RIO
     # If no args are provided, no lines are rejected.
     #
     # If args are provided they may be one or more of the following:
-    # [Regexp]  any matching line will not be processed
-    # [Integer] specifies a line-number (zero-based) to be skipped
-    # [Range]   specifies a range of lines (zero-based) to be excluded
-    # [Proc]    a proc which will be called for each line, lines are excluded unless nil or false is returned
-    # [Symbol]  a symbol which will _sent_ to each line, lines are excluded unless nil or false is returned
+    # Regexp::  any matching line will not be processed
+    # Integer:: specifies a line-number (zero-based) to be skipped
+    # Range::   specifies a range of lines (zero-based) to be excluded
+    # Proc::    a proc which will be called for each line, lines are excluded unless nil or false is returned
+    # Symbol::  a symbol which will _sent_ to each line, lines are excluded unless nil or false is returned
+    # Array::   an array of any of above. All must match for a line to be included
     #
-    #  rio('afile').nolines(0) { |line| ... } # iterate over all but the first line of 'afile'
-    #  rio('afile').nolines(0,5..7)) { |line| ... } # don't iterate over lines 0,5,6 and 7
-    #  rio('afile').nolines(/Zippy/) { |line| ... } # skip all lines containing 'Zippy'
-    #  rio('afile').chomp.nolines(:empty?) { |line| ... } # skip empty lines
+    #  rio('afile').skiplines(0) { |line| ... } # iterate over all but the first line of 'afile'
+    #  rio('afile').skiplines(0,5..7)) { |line| ... } # don't iterate over lines 0,5,6 and 7
+    #  rio('afile').skiplines(/Zippy/) { |line| ... } # skip all lines containing 'Zippy'
+    #  rio('afile').chomp.skiplines(:empty?) { |line| ... } # skip empty lines
     #
-    def nolines(*args,&block) target.nolines(*args,&block); self end
+    def skiplines(*args,&block) target.skiplines(*args,&block); self end
 
 
     
     # Sets the Rio to read rows and specifies rows which should be iterated through 
-    # by Rio#each or returned by Rio#getrec
+    # by Rio#each or returned by Rio#getrec.
     # Rio#rows is intended for use by extensions, where the concept of a row is reasonable. 
-    # In the absensence of an extension behaves like Rio#records
+    # In the absensence of an extension behaves like Rio#records.
     def rows(*args,&block) target.rows(*args,&block); self end
 
     # Sets the Rio to read rows and specifies lines which should *not* be iterated 
     # through by Rio#each or returned by Rio#getrec
-    # Rio#norows is intended for use by extensions, where the concept of a row is 
-    # reasonable. In the absensence of an extension behaves like Rio#norecords
-    def norows(*args,&block) target.norows(*args,&block); self end
+    # Rio#skiprows is intended for use by extensions, where the concept of a row is 
+    # reasonable. In the absence of an extension behaves like Rio#skiprecords
+    def skiprows(*args,&block) target.skiprows(*args,&block); self end
 
     # Sets the implicit output mode to 'a'.
     # 
@@ -383,7 +391,7 @@ module RIO
     #  dest.close     # must be explicitly closed
     # 
     #  dest = rio('destfile')
-    #  dest.print(rio('srcfile').slurp)
+    #  dest.print(rio('srcfile').contents)
     #  dest.closed?   #=> false (Rio#print is not a copy operator)
     #  dest.close
     #
@@ -520,6 +528,25 @@ module RIO
     def chomp(arg=true,&block) target.chomp(arg,&block); self end
 
 
+    # Queries the Rio's strip-mode.
+    # See #strip.
+    #
+    def strip?() target.strip?() end
+
+
+    # Sets the Rio to strip lines and returns the Rio
+    # 
+    # When called with a block, behaves as if strip.each(&block) had been called
+    #
+    # +strip+ causes lines returned by each, to_a, readlines, readline, gets, each_line etc.
+    # to be stripped with String#strip before iterated over or assigned
+    #
+    #  ans = rio(?-).print("A Prompt> ").strip.gets # prompt the user
+    #
+    # See also #chomp
+    def strip(arg=true,&block) target.strip(arg,&block); self end
+
+
     # Sets the Rio to gzip mode. 
     #     ario.gzip    #=> ario
     # If applied to a Rio that is being read from Reads
@@ -562,52 +589,6 @@ module RIO
     #def outputmode?() target.outputmode?() 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 immediatly 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 immediatly 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