wishdev-rio 0.4.3.1

data/lib/rio/context/skip.rb

@@ -0,0 +1,66 @@
+#--
+# =============================================================================== 
+# Copyright (c) 2005,2006,2007 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
+#  ruby build_doc.rb
+# from the distribution directory.
+#
+# Suggested Reading
+# * RIO::Doc::SYNOPSIS
+# * RIO::Doc::INTRO
+# * RIO::Doc::HOWTO
+# * RIO::Doc::EXAMPLES
+# * RIO::Rio
+#
+
+
+require 'rio/context/cxx.rb'
+
+module RIO
+  module Cx
+    module Methods
+      def _arg_skip(args)
+        #p callstr('_arg_skip',args,cx.inspect)
+        cx['ss_skipped'] = cx['ss_type'].sub(/^skip/,'') if cx['ss_type']
+        cx['ss_type'] = 'skip'
+        cx['skip_args'] = args
+      end
+      def _noarg_skip
+        cx['ss_skipped'] = cx['ss_type'].sub(/^skip/,'') if cx['ss_type']
+        cx['ss_type'] = 'skip'
+        cx['skipping'] = true
+      end
+      def skipping?() cx['skipping'] end
+      def skip(*args,&block)
+        if args.empty?
+          _noarg_skip
+        else
+          _arg_skip(args)
+        end
+        each(&block) if block_given?
+        self
+      end
+
+    end
+  end
+end

data/lib/rio/context/stream.rb

@@ -0,0 +1,229 @@
+#--
+# =============================================================================== 
+# Copyright (c) 2005,2006,2007 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
+#  ruby build_doc.rb
+# from the distribution directory.
+#
+# Suggested Reading
+# * RIO::Doc::SYNOPSIS
+# * RIO::Doc::INTRO
+# * RIO::Doc::HOWTO
+# * RIO::Doc::EXAMPLES
+# * RIO::Rio
+#
+
+
+require 'rio/context/cxx.rb'
+require 'rio/iomode'
+
+module RIO
+  module Cx
+    module Methods
+      def stream_iter?() cx.has_key?('stream_itertype') && !cx['nostreamenum'] end
+      
+      private
+
+      def _set_bytes(nb)
+        nb = 1 if nb.nil? or nb < 1
+        cx['bytes_n'] = nb
+      end
+      def _set_bytes_(nb)
+        nb = 1 if nb.nil? or nb < 1
+        cx.set_('bytes_n',nb)
+      end
+
+      def _set_sstype(ss,explicit=true)
+        case
+        when explicit then cx['ss_type'] = ss
+        else cx.set_('ss_type',ss)
+        end
+      end
+      def _set_rectype(rt,explicit=true)
+        case
+        when explicit then cx['stream_rectype'] = rt
+        else cx.set_('stream_rectype',rt)
+        end
+      end
+      def _set_itertype(rt,explicit=true)
+        case
+        when explicit then cx['stream_itertype'] = rt
+        else cx.set_('stream_itertype',rt)
+        end
+      end
+
+      def _set_selargs(sa,sel=true,&block)
+        key = (sel ? 'stream_sel' : 'stream_nosel')
+        cx[key] = sa
+        each(&block) if block_given?
+        self
+      end
+
+      def _lines(args,sel=true,explicit=true,&block)   
+        #p callstr('lines',*args)
+        _set_itertype('lines',explicit)
+        _set_rectype('lines',explicit)
+        _set_selargs(args,sel,&block)
+      end
+
+      def _records(args,sel=true,explicit=true,&block) 
+        _set_itertype('records',explicit)
+        _set_selargs(args,sel,&block)
+      end
+
+      def _rows(args,sel=true,explicit=true,&block) 
+        _set_itertype('rows',explicit)
+        _set_selargs(args,sel,&block)
+      end
+
+      def _sel()
+        !skipping?
+      end
+      def _sel_key(key)
+        (skipping? ? 'skip'+key : key)
+      end
+      public
+
+      def lines(*args,&block)   
+        #p callstr('lines',*args)
+        if skipping?
+          cx['skipping'] = false
+          skiplines(*args,&block)
+        else
+          _set_sstype('lines')
+          _lines(args,_sel,&block)
+        end
+      end
+      def lines_(*args,&block) 
+        #p callstr('lines_',*args)
+        _set_sstype('lines',false)
+        _lines(args,_sel,false,&block)
+      end
+
+      def line(*args,&block)   
+        #p callstr('line',*args)
+        cx['line'] = true
+        self.lines(*args,&block)
+      end
+      def line_(*args,&block) 
+        #p callstr('line_',*args)
+        cx.set_('line',true)
+        self.lines_(*args,&block)
+      end
+
+      def records(*args,&block) 
+        if skipping?
+          cx['skipping'] = false
+          skiprecords(*args,&block)
+        else
+          _set_sstype('records')
+          _records(args,_sel,&block)
+        end
+      end
+      def records_(*args,&block) 
+        _set_sstype('records',false)
+        _records(args,_sel,false,&block)
+      end
+
+      def record(*args,&block)   
+        #p callstr('record',*args)
+        cx['record'] = true
+        self.records(*args,&block)
+      end
+      def record_(*args,&block) 
+        #p callstr('record_',*args)
+        cx.set_('record',true)
+        self.records_(*args,&block)
+      end
+
+      def rows(*args,&block) 
+        if skipping?
+          cx['skipping'] = false
+          skiprows(*args,&block)
+        else
+          _set_sstype('rows')
+          _rows(args,_sel,&block)
+        end
+      end
+      def rows_(*args,&block) 
+        _set_sstype('rows',false)
+        _rows(args,_sel,false,&block)
+      end
+
+      def row(*args,&block)   
+        #p callstr('row',*args)
+        cx['row'] = true
+        self.rows(*args,&block)
+      end
+      def row_(*args,&block) 
+        #p callstr('row_',*args)
+        cx.set_('row',true)
+        self.rows_(*args,&block)
+      end
+
+
+      def skiplines(*args,&block) 
+        #p callstr('skiplines',*args)
+        self.lines() unless args.empty? or cx.has_key?('stream_sel')
+        _set_sstype('skiplines')
+        _lines(args,false,&block)
+      end
+      def skiprecords(*args,&block) 
+        self.records_() unless args.empty? or cx.has_key?('stream_sel')
+        _set_sstype('skiprecords')
+        _records(args,false,&block)
+      end
+      def skiprecords_(*args,&block) 
+        self.records_() unless args.empty? or cx.has_key?('stream_sel')
+        _set_sstype('skiprecords',false)
+        _records(args,false,false,&block)
+      end
+      def skiprows(*args,&block) 
+        self.rows() unless args.empty? or cx.has_key?('stream_sel')
+        _set_sstype('skiprows')
+        _rows(args,false,&block)
+      end
+
+
+
+      def bytes(nb=1,*args,&block)
+        _set_sstype('bytes')
+        _set_bytes(nb)
+        _set_itertype('records')
+        _set_rectype('bytes')
+        each(&block) if block_given?
+        self
+      end
+      def bytes_(nb=1,*args,&block)
+        _set_bytes_(nb)
+        _set_itertype('records',false)
+        _set_rectype('bytes',false)
+        each(&block) if block_given?
+        self
+      end
+
+
+
+    end
+  end
+end

data/lib/rio/context.rb

@@ -0,0 +1,117 @@
+#--
+# =============================================================================== 
+# Copyright (c) 2005,2006,2007 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
+#  ruby build_doc.rb
+# from the distribution directory.
+#
+# Suggested Reading
+# * RIO::Doc::SYNOPSIS
+# * RIO::Doc::INTRO
+# * RIO::Doc::HOWTO
+# * RIO::Doc::EXAMPLES
+# * RIO::Rio
+#
+
+
+module RIO
+  module Cx #:nodoc: all
+    class  Vars
+      def initialize(h=Hash.new,exp=Hash.new)
+        @values = h
+        @explicit = exp
+      end
+      def initialize_copy(*args)
+        super
+        @values = @values.clone
+        @explicit = @explicit.clone
+      end
+      BEQUEATH_KEYS = %w[chomp strip rename closeoneof closeoncopy]
+      #BEQUEATH_KEYS = %w[chomp strip rename]
+      def bequeath(oldcx)
+        keys = BEQUEATH_KEYS
+        ncx = oldcx.clone
+        #ncx = Vars.new
+        keys.each { |key|
+          ncx.set_(key,@values[key]) if @values.has_key?(key)
+        }
+        ncx
+      end
+      def delete(key)
+        @values.delete(key)
+        @explicit.delete(key)
+      end
+      def get_keystate(key)
+        key_exists = @values.key?(key)
+        key_val = @values[key]
+        key_explicit = @explicit[key]
+        [key,key_exists,key_val,key_explicit]
+      end
+      def set_keystate(key,key_exists,key_val,key_explicit)
+        if(key_exists) then
+          @values[key] = key_val
+          @explicit[key] = key_explicit
+        else
+          @values.delete(key)
+          @explicit.delete(key)
+        end
+      end
+      def set_(key,val)
+        @values[key] = val unless @explicit[key]
+      end
+      def []=(key,val)
+        @values[key] = val
+        @explicit[key] = true
+      end
+      def inspect()
+        str = sprintf('#<Cx:0x%08x ',self.object_id)
+        vary = {}
+        @values.each { |k,v|
+          name = k
+          name += '_' unless @explicit[k]
+          if v == true
+            vary[name] = nil
+          elsif v == false
+            vary[name] = 'false'
+          else 
+            vary[name] = v
+          end
+        }
+        strs = []
+        vary.each { |k,v|
+         if v.nil?
+           strs << k
+         else
+           strs << "#{k}(#{v.inspect})"
+         end
+        }
+        str += strs.join(',')
+        str +='>'
+        str
+      end
+
+      extend Forwardable
+      def_instance_delegators(:@values,:[],:has_key?,:values_at,:keys)
+    end
+  end
+end  

data/lib/rio/cp.rb

@@ -0,0 +1,370 @@
+#--
+# =============================================================================== 
+# Copyright (c) 2005,2006,2007 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
+#  ruby build_doc.rb
+# from the distribution directory.
+#
+# Suggested Reading
+# * RIO::Doc::SYNOPSIS
+# * RIO::Doc::INTRO
+# * RIO::Doc::HOWTO
+# * RIO::Doc::EXAMPLES
+# * RIO::Rio
+#
+
+
+require 'rio/exception/copy'
+class String #:nodoc: all
+  def clear()
+    self[0..-1] = ''
+    self
+  end
+end
+require 'rio/no_warn'
+
+module RIO
+  module Cp #:nodoc: all
+    module Util
+      module InOut
+        def cpclose(*args,&block)
+          if args.empty?
+            oldcoc = self.cx.get_keystate('closeoncopy')
+            self.cx['closeoncopy'] = false
+            rtn = yield
+            rtn.cx.set_keystate(*oldcoc)
+            rtn.copyclose
+          else
+            if (ario = args[0]).kind_of?(Rio)
+              oldcoc = ario.cx.get_keystate('closeoncopy')
+              ario.cx['closeoncopy'] = false
+              rtn = yield
+              ario.cx.set_keystate(*oldcoc)
+              ario.copyclose
+              rtn
+            else
+              yield
+            end
+          end
+        end
+        def cpclose0(*args,&block)
+          if args.empty?
+            oldcoc,self.cx['closeoncopy'] = self.cx['closeoncopy'],false
+            rtn = yield
+            rtn.cx['closeoncopy'] = oldcoc
+            rtn.copyclose
+          else
+            if (ario = args[0]).kind_of?(Rio)
+              oldcoc,ario.cx['closeoncopy'] = ario.cx['closeoncopy'],false
+              rtn = yield
+              ario.cx['closeoncopy'] = oldcoc
+              ario.copyclose
+              rtn
+            else
+              yield
+            end
+          end
+        end
+      end
+      module Input
+        include InOut
+        protected
+
+        def cpto_obj_(obj)
+          self.each do |el|
+            obj << el
+          end
+        end
+
+      end
+      module Output
+        include InOut
+
+        protected
+
+        def cpfrom_obj_(obj)
+          obj.each do |el|
+            self << el
+          end
+        end
+        def cpfrom_array_(ary)
+          #p "CPFROM_ARRAY_"
+          ary.inject(self) { |anio,el| anio << el }
+        end
+      end
+    end
+  end
+end
+
+module RIO
+  module Cp
+    module Stream
+      module Input
+        include Util::Input
+        def >>(arg)
+          cpclose(arg) {
+            apto_(arg)
+          }
+        end
+        def >(arg)
+          cpclose(arg) {
+            cpto_(arg)
+          }
+        end
+        alias :copy_to :>
+        alias :append_to :>>
+
+        protected
+        def cpto_(arg)
+          case arg 
+          when ::Array then cpto_array_(arg.clear)
+          when ::String then cpto_string_(arg.clear)
+          when ::IO then cpto_obj_(arg)
+          else cpto_rio_(arg,:<)
+          end
+          self
+        end
+        def apto_(arg)
+          case arg
+          when ::Array then cpto_array_(arg)
+          when ::String then cpto_string_(arg)
+          when ::IO then cpto_obj_(arg)
+          else cpto_rio_(arg,:<<)
+          end
+          self
+        end
+
+        def cpto_array_(arg)
+          cpto_obj_(arg)
+        end
+        def cpto_string_(arg)
+          cpto_obj_(arg)
+        end
+
+        def cpto_rio_(arg,sym)
+          ario = ensure_rio(arg)
+          #p ario
+          ario = ario.join(self.filename) if ario.dir?
+          ario.cpclose {
+            ario = ario.iostate(sym)
+            self.copying(ario).each { |el|
+#              p el
+              ario.putrec(el)
+#              ario << el
+            }.copying_done(ario)
+            ario
+          }
+        end
+      end
+
+      module Output
+        include Util::Output
+        def <<(arg) cpclose { cpfrom_(arg) } end
+        def <(arg) cpclose { cpfrom_(arg) } end
+        alias :copy_from :<
+        alias :append_from :<<
+
+        protected
+
+        def cpfrom_(arg)
+          case arg
+          when ::Array then cpfrom_array_(arg)
+          when ::IO then cpfrom_obj_(arg)
+          when ::String then 
+            self.put_(arg)
+          else cpfrom_rio_(arg)
+          end
+          self
+        end
+        def cpfrom_rio_(arg)
+          ario = ensure_rio(arg)
+          #p ario.cx
+
+          ario.copying(self).each { |el|
+            self << el
+          }.copying_done(self)
+        end
+      end
+    end
+  end
+end
+module RIO
+  module Cp
+    module File
+      module Output
+        include Util::Output
+        def <(arg) cpclose { self.iostate(:<) < arg } end
+        def <<(arg) cpclose { self.iostate(:<<) << arg } end
+        alias :copy_from :<
+        alias :append_from :<<
+      end
+      module Input
+        include Util::Input
+        def >(arg)  
+          spcp(arg) || cpclose(arg) { self.iostate(:>) > arg  } 
+        end
+        def >>(arg) 
+          spcp(arg) || cpclose(arg) { self.iostate(:>>) >> arg } 
+        end
+        alias :copy_to :>
+        alias :append_to :>>
+        def copy_as_file?(arg)
+          arg.kind_of?(Rio) and arg.scheme == 'ftp'
+        end
+        def spcp(arg)
+          if arg.kind_of?(Rio) and arg.scheme == 'ftp'
+            arg.copy_from(new_rio(rl.path))
+            self
+          else
+            nil
+          end
+        end
+      end
+    end
+  end
+end
+module RIO
+  module Cp
+    module Open
+      module Output
+        include Util::Output
+        def <(arg) cpclose { self.iostate(:<) < arg } end
+        def <<(arg) cpclose { self.iostate(:<<) << arg } end
+        alias :copy_from :<
+        alias :append_from :<<
+      end
+      module Input
+        include Util::Input
+        def >(arg) cpclose(arg) { self.iostate(:>) > arg } end
+        def >>(arg) cpclose(arg) { self.iostate(:>>) >> arg } end
+        alias :copy_to :>
+        alias :append_to :>>
+      end
+    end
+  end
+end
+module RIO
+  module Cp
+    module Dir
+      module Output
+        include Util::Output
+        def <<(arg)  cpfrom_(arg); self  end
+        def <(arg)  cpfrom_(arg); self end
+        alias :copy_from :<
+        alias :append_from :<<
+
+        private
+
+        def cpfrom_(arg)
+          case arg
+          when ::Array then cpfrom_array_(arg)
+          else cpfrom_rio_(ensure_rio(arg))
+          end
+        end
+        def cpfrom_rio_(ario)
+          dest = self.join(ario.filename)
+          case
+          when ario.symlink?
+            ::File.symlink(ario.readlink.to_s,dest.to_s)
+          when ario.dir?
+            dest.mkdir
+            ario.nostreamenum.each do |el|
+              dest < el
+            end
+          else
+            dest < ario
+          end
+        end
+      end
+      module Input
+        include Util::Input
+        def >>(arg)
+          case arg
+          when ::Array then cpto_obj_(arg)
+          else cpto_rio_(ensure_rio(arg))
+          end
+          self
+        end
+        def >(arg)
+          case arg
+          when ::Array then cpto_obj_(arg.clear)
+          else cpto_rio_(ensure_rio(arg))
+          end
+          self
+        end
+        alias :copy_to :>
+        alias :append_to :>>
+
+        protected
+
+        def cpto_rio_(ario)
+          ario = ario.join(self.filename) if ario.exist?
+          nostreamenum.cpto_obj_(ario.mkdir)
+        end
+      end
+    end
+  end
+end
+module RIO
+  module Cp
+    module NonExisting
+      module Output
+        include Util::Output
+        def <(arg)  
+          if _switch_direction?(arg)
+            #arg > self
+            arg.copy_to(self)
+            self
+          else 
+            _cpsrc(arg) < arg
+          end
+        end
+        def <<(arg)  
+          if _switch_direction?(arg)
+            arg >> self
+            self
+          else 
+            _cpsrc(arg) << arg
+          end
+        end
+        alias :copy_from :<
+        alias :append_from :<<
+
+        private
+
+        def _cpsrc(arg)
+          if arg.kind_of?(::Array) and !arg.empty? and arg[0].kind_of?(Rio)
+            self.mkdir.reset
+          else
+            self.nfile
+          end
+        end
+        def _switch_direction?(arg)
+          arg.kind_of?(Rio) and arg.dir? and !arg.stream_iter?
+        end
+      end
+    end
+  end
+end
+
+__END__