rio 0.3.2 → 0.3.3

data/lib/rio/if/dir.rb

@@ -127,7 +127,15 @@ module RIO
     #
     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 noentries(*args,&block) target.noentries(*args,&block); self end
 
+    
     # Grande File Selection Method 
     #
     # Sets the rio to return files. +args+ can be used to select which files are returned.
@@ -136,9 +144,9 @@ module RIO
     #  end
     # No aguments selects all files.
     #
-    # If +args+ are:
+    # +args+ may be one or more of the following:
     # Regexp:: selects matching files
-    # glob::   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
     #
@@ -153,7 +161,7 @@ module RIO
     #  rio('adir').files[/\.rb$/] # same thing using a regular expression
     #  rio('adir').files[:symlink?] # an array of symlinks to files
     #
-    # For Rios that refer to files, +files(*args)+ causes the file to be processed only if 
+    # 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')]
@@ -167,7 +175,7 @@ module RIO
     # directories. 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'
     #
-    #  rio(path).norecurse('.svn').files['*.rb',proc{ |f| f.executable? and f[0] =~ /^#!.+ruby/ }]
+    #  rio(path).norecurse('.svn').files['*.rb',proc{ |f| f.executable? and f.gets =~ /^#!.+ruby/ }]
     #
     # Explanation:
     #
@@ -180,9 +188,9 @@ module RIO
     # Limit to files ending with '.rb'
     #  rio(path).norecurse('.svn').files('*.rb')
     # Also allow files that are both executable and whose first line is a shebang-ruby line
-    #  rio(path).norecurse('.svn').files('*.rb',proc{ |f| f.executable? and f[0] =~ /^#!.+ruby/ })
+    #  rio(path).norecurse('.svn').files('*.rb',proc{ |f| f.executable? and f.gets =~ /^#!.+ruby/ })
     # Return an array rather than iterating thru them
-    #  rio(path).norecurse('.svn').files['*.rb',proc{ |f| f.executable? and f[0] =~ /^#!.+ruby/ }]
+    #  rio(path).norecurse('.svn').files['*.rb',proc{ |f| f.executable? and f.gets =~ /^#!.+ruby/ }]
     #
     def files(*args,&block) target.files(*args,&block); self end
 

data/lib/rio/if/fileordir.rb

@@ -103,6 +103,12 @@ module RIO
     #
     def rename(*args,&block) target.rename(*args,&block); self end
     
+
+    # Behaves like Rio#rename, but also changes the calling Rio to 
+    # refer to the renamed path
+    def rename!(*args,&block) target.rename!(*args,&block); self end
+    
+
     # For directories proxies Dir#read, otherwise proxies IO#read
     #
     # Proxy for IO#read

data/lib/rio/if/grande.rb

@@ -207,6 +207,31 @@ module RIO
     # So the existance of a block after many methods is taken as an implied
     # Rio#each
     #
+    # For Rios that refer to files, the item passed to the block is a String containing
+    # the line or block as selected by Rio#lines, or Rio#bytes. +lines+ is the default.
+    #  rio('afile').lines.each { |line| ...}
+    # 
+    # The block passed to +each+ will also accept an optional second parameter which will contain
+    # the result of the matching function. What this variable contains depends on the argument
+    # to +lines+ that resulted in the match as follows:
+    # 
+    # Regexp::   The MatchData that resulted from the match.
+    # Range::    The record number of the matching record.
+    # Fixnum::   The record number of the matching record.
+    # Proc::     The value returned by the proc.
+    # Symbol::   The value resulting from sending the symbol to the String.
+    #
+    # If no selection arguments were used, this variable will simply contain +true+.
+    #
+    #  rio(??).puts(%w[0:zero 1:one]).rewind.lines(/(\d+):([a-z]+)/) do |line,match| 
+    #    puts("#{match[1]} is spelled '#{match[2]}'")
+    #  end
+    # 
+    # Produces:
+    #  0 is spelled 'zero'
+    #  1 is spelled 'one'
+    #
+    # 
     # For Rios that refer to directories, the item passed to the block is a Rio refering to
     # the directory entry. 
     #
@@ -374,6 +399,9 @@ module RIO
     #
     def >(destination) target > destination; self end
 
+    # Alias for Rio#> (copy-to grande operator)
+    def copy(destination) target.copy(destination); self end
+
     # Grande Append-To Operator
     # 
     # The append-to grande-operator is the same as Rio#> (copy-to) except that it opens the destination

data/lib/rio/if/internal.rb

@@ -43,11 +43,84 @@ module RIO
     
     # This is an internal function and should not normally be needed in client code.
     # It closes a Rio and returns it to its 'reset' state.
-    def reset() target.reset() end
+    def reset() # :nodoc:
+      target.reset() 
+    end
     
     # This is an internal function and is not needed in client code.
     # It returns the internal 'Rio Resource Locator' object.
-    def rl() target.rl() end
+    def rl() # :nodoc:
+      target.rl() 
+    end
+
+    # This is an internal function and is not needed in client code.
+    # It returns the internal 'Rio Resource Locator' object.
+    def to_rl() # :nodoc:
+      target.to_rl() 
+    end
+
+    # This is an internal function and is not needed in client code.
+    # It returns the internal 'Rio Context' object.
+    def cx() # :nodoc:
+      target.cx() 
+    end
+
+    # This is an internal function and is not needed in client code.
+    def cx=(arg) # :nodoc:
+      target.cx = arg 
+    end
+
+    # This is an internal function and is not needed in client code.
+    def copyclose() # :nodoc:
+      target.copyclose 
+    end
+
+    # This is an internal function and is not needed in client code.
+    def nostreamenum() # :nodoc:
+      target.nostreamenum 
+    end
+
+    # This is an internal function and is not needed in client code.
+    def cpclose(*args,&block) # :nodoc:
+      target.cpclose(*args,&block) 
+    end
+
+    # This is an internal function and is not needed in client code.
+    def each_record(*args,&block) # :nodoc:
+      target.each_record(*args,&block) 
+    end
+
+    # This is an internal function and is not needed in client code.
+    def each_row(*args,&block) # :nodoc:
+      target.each_row(*args,&block) 
+    end
+
+    # This is an internal function and is not needed in client code.
+    def outputmode?() # :nodoc:
+      target.outputmode? 
+    end
+
+    # This is an internal function and is not needed in client code.
+    def inputmode?() # :nodoc:
+      target.inputmode? 
+    end
+
+    # This is an internal function and is not needed in client code.
+    def iostate(sym) # :nodoc:
+      target.iostate(sym) 
+    end
+
+    # This is an internal function and is not needed in client code.
+    def getwd(*args) # :nodoc:
+      target.getwd(*args) 
+    end
+
+    # This is an internal function and is not needed in client code.
+    def stream_iter?() # :nodoc:
+      target.stream_iter? 
+    end
+
+    
 
   end
 end

data/lib/rio/if/methods.rb

@@ -465,10 +465,11 @@ module RIO
     #def autorewind?() target.autorewind?() end
 
 
-    # Rio#autorewind
+    # Sets a Rio to 'autorewind'.
+    # autorewind is not a well thought out concept and probably will be
+    # removed. Do not use it.
     #
-    #
-    #def autorewind(arg=true,&block) target.autorewind(arg,&block); self end
+    def autorewind(*args,&block) target.autorewind(*args,&block); self end
 
 
     # Rio#noautorewind

data/lib/rio/if/string.rb

@@ -0,0 +1,46 @@
+#--
+# =============================================================================== 
+# 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
+    # Returns the String associated with a Rio which references a StringIO object.
+    # For any other type of Rio, is undefined.
+    def string() target.string end
+
+  end
+end
+

data/lib/rio/if/temp.rb

@@ -0,0 +1,46 @@
+#--
+# =============================================================================== 
+# 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
+    def file() target.file; self end
+    def dir() target.dir; self end
+      
+
+  end
+end
+

data/lib/rio/matchcolumns.rb

@@ -0,0 +1,266 @@
+#--
+# =============================================================================== 
+# 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 Match #:nodoc: all
+    module Column
+      
+      class Base
+        def initialize(arg)
+          @select_arg = arg
+        end
+        def inspect
+          @select_arg.inspect
+        end
+        def val()
+          @select_arg
+        end
+        def match_all?() false end
+        def match_none?() false end
+      end
+      class All < Base
+        def match?(colno) true end
+        def match_all?() true end
+        def =~(colno) true end
+      end
+      class None < Base
+        def match?(colno) false end
+        def match_none?() true end
+        def =~(colno) false end
+      end
+
+      class Range < Base
+        def match?(colno)
+          #p "match?(#{val},#{recno}) select_arg=#{@select_arg}"
+          @select_arg === colno
+        end
+        def =~(colno) 
+          #p "=~(#{record},#{record.recno}) select_arg=#{@select_arg}"
+          @select_arg === colno 
+        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)
+          super(arg)
+          @therio = therio
+        end
+        def match?(val,recno)
+          #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
+      end
+    end
+  end
+
+  module Match
+    module Record
+      # for a sellist
+      # nil indicates no call was made, so nothing selected
+      # empty indicates a call was made, so all selected
+      # contents should be checked for matches
+      # if contents are removed the list should become nil, not empty
+      class SelList
+        def initialize(therio,args)
+          if args.nil?
+            @list = nil
+          else
+            @list = []
+            args.each do |arg|
+              @list << create_sel(therio,arg)
+            end
+          end
+          #p "SelList(#{args.inspect},#{@list.inspect})"
+        end
+        def inspect
+          @list.inspect
+        end
+        def size() @list.size unless @list.nil? end
+        def only_one_fixnum?()
+          @list && @list.size == 1 && @list[0].kind_of?(Match::Record::Fixnum)
+        end
+        def delete_at(index)
+          @list.delete_at(index)
+          @list = nil if @list.empty?
+        end
+        def self.create(therio,args)
+          new(therio,args) unless args.nil?
+        end
+        def ranges()
+          @list.nil? ? [] : @list.select { |sel| sel.kind_of?(Record::Range) }
+        end
+        def remove_passed_ranges(n)
+          return nil if @list.nil?
+          return self if @list.empty?
+          newlist = []
+          @list.each do |sel| 
+            newlist << sel unless sel.kind_of?(Match::Record::Range) and sel.val.max < n 
+          end
+          @list = (newlist.empty? ? nil : newlist) if newlist.length != @list.length
+          @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
+        end
+        def match?(val,recno)
+          # !@list.nil? && (@list.empty? || @list.detect { |sel| sel.match?(val,recno) } || false) && true
+          return false if @list.nil?
+          return true if @list.empty?
+          as = nil
+          al = @list.detect { |sel| as = sel.match?(val,recno)
+            #p "1: #{$1} as[match?]: #{as.inspect}"
+            as
+          }
+          #p "[SelList.match?] as:#{as.inspect} al:#{al.inspect}"
+          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
+
+
+      class SelRej
+        def initialize(therio,sel_args,rej_args)
+          @sel = SelList.create(therio,sel_args)
+          @rej = SelList.create(therio,rej_args)
+          @always = init_always()
+        end
+        def only_one_fixnum?()
+          @rej.nil? && @sel && @sel.only_one_fixnum?
+        end
+        def init_always(reset=false)
+          if @sel.nil? and @rej.nil?
+            !reset
+          elsif @rej.nil? and @sel.always?
+            true
+          elsif @sel.nil?
+            false
+          elsif !@rej.nil? and @rej.always?
+            false
+          else
+            nil
+          end
+        end
+        def remove_passed_ranges(n)
+          @sel = @sel.remove_passed_ranges(n) unless @sel.nil?
+          @rej = @rej.remove_passed_ranges(n) unless @rej.nil?
+          @always = init_always(true)
+          self
+        end
+        def rangetops()
+          rtops = ranges.map { |r| r.val.max }.sort.uniq
+          rtops.empty? ? nil : rtops
+        end
+        def ranges()
+          (@sel.nil? ? [] : @sel.ranges) + (@rej.nil? ? [] : @rej.ranges)
+        end
+        def class_tail
+          self.class.to_s.sub(/^.+::/,'')
+        end
+        def inspect
+          sprintf("#<%s:0x%08x @always=%s @sel=%s @rej=%s>",self.class_tail,self.object_id,@always.inspect,
+                  @sel.inspect,@rej.inspect)
+        end
+        def always?()
+          @always == true
+        end
+        def never?()
+          @always == false
+        end
+        def match?(val,recno)
+          #p "match?(#{val},#{recno}) #{self.inspect}"
+          return @always unless @always.nil?
+          as = nil
+          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
+end
+
+
+
+