rio 0.4.2 → 0.5.1

data/lib/rio/scheme/cmdpipe.rb

@@ -1,6 +1,6 @@
 #--
-# =============================================================================== 
-# Copyright (c) 2005,2006,2007,2008 Christopher Kleckner
+# ===========================================================================
+# Copyright (c) 2005-2012 Christopher Kleckner
 # All rights reserved
 #
 # This file is part of the Rio library for ruby.
@@ -18,100 +18,163 @@
 # 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/rl/ioi'
+require 'rio/rrl/ioi'
 require 'rio/stream'
 require 'rio/stream/open'
 require 'rio/piper'
+require 'rio/cxuri'
+require 'rio/scheme/cmdio'
+require 'rio/fibpipe'
 
 module RIO
   module CmdPipe #:nodoc: all
     RESET_STATE = 'CmdPipe::Stream::Reset'
 
-    class RL < RL::IOIBase 
+    class RRL < RRL::IOIBase 
       RIOSCHEME = 'cmdpipe'
-      RIOPATH = RIO::RL::CHMAP.invert[RIOSCHEME].to_s.freeze
+      RIOPATH = RIO::RRL::CHMAP.invert[RIOSCHEME].to_s.freeze
       attr_reader :piper
 
-      def initialize(*args)
-        case args[0]
-        when CmdPipe::RL
-          @piper = args[0].piper
-        when Piper::Base 
-          @piper = args[0]
+      def initialize(u, *args)
+        nuri = case u
+               when ::Alt::URI::Base,RIO::CmdPipe,RIO::CmdIO 
+                 u
+               else ::Alt::URI.parse(u)
+               end
+        super(nuri)
+
+        case uri.scheme
+        when 'cmdio'
+          rios = args.map{ |el| ensure_rio(el) }
+          self.query = [ensure_rio(uri),rios]
+        when 'cmdpipe'
+          rios = args.map{ |el| ensure_rio(el) }
+          self.append_to_query(rios)
         else
-          @piper = Piper::Base.new(*args)
+          rios = args.map{ |el| ensure_rio(el) }
+          self.query = [ensure_rio(uri),rios]
         end
-        super
       end
-      def initialize_copy(*args)
-        super
-        @piper = @piper.clone
+      def ensure_rio(arg)
+        case arg
+        when RIO::Rio then arg
+        when RIO::State::Base then arg.clone_rio
+        else RIO::Rio.new(arg)
+        end
       end
-      def opaque()
-        #p callstr('opaque')
-        @piper.rios.map{|cmd| URI.escape(cmd.to_s,RIO::RL::ESCAPE)}.join('|')
+      def self.parse(*a)
+        u = a.shift.sub(/^rio:/,'')
+        new(u,*a)
       end
-      def to_s()
-        return "" if @piper.rios.nil? or @piper.rios.empty?
-        @piper.rios.map{|cmd| cmd.to_s}.join('|')
+      def query=(a)
+        uri.query = if a.instance_of?(::Array)
+                      a.map{ |el| CxURI.new(ensure_rio(el)).to_s }
+                    else
+                     CxURI.new(ensure_rio(a)).to_s
+                    end
       end
-      def open(m,*args)
-        @outp = rio(?")
-        rp = Piper::Base.new(@piper,@outp)
-        rp.run
-        @outp
+      def query
+        v = uri.query
+        case v
+        when nil then v
+        when ::Array
+          v.map{ |el| CxURI.new(el).to_rio }
+        else
+          CxURI.new(v).to_rio
+        end
       end
-      SPLIT_RE = %r|(?:([^\|]+)(?:\|([^\|]+))*)?$|.freeze
-      def self.splitrl(s)
-        #p "S='#{s}'"
-        sub,opq,whole = split_riorl(s)
-        if opq.nil? or opq.empty?
-          []
-        elsif bm = SPLIT_RE.match(opq)
-          escaped_cmd = bm[1]
-          cmd = URI.unescape(escaped_cmd)
-          [cmd]
+
+      def append_to_query(rios)
+        q = self.query
+        case q
+        when nil
+          self.query = rios
+        when Alt::URI::Base
+          self.query = [rios].flatten
+        when ::Array
+          self.query = q + [rios].flatten
         else
-          []
+          raise ArgumentError, "append_to_query: #{q}, #{uris}"
         end
       end
+      def initialize_copy(other)
+        super
+      end
+      def to_s()
+        super
+      end
+      def run
+        rios = self.query
+        (1...rios.size-1).each { |i| rios[i].w! }
+        (1...rios.size).each { |i|
+          rios[i-1] > rios[i]
+        }
+        rios.each { |r| r.close.softreset }
+        rios[-1]
+      end
+      def open(m,*args)
+        run
+      end
     end
     module Stream
       class Reset < State::Base
         include Ops::Path::URI
-        include Piper::Cp::Util
         def check?() true end
         def |(arg)
           ario = ensure_cmd_rio(arg)
-          npiper = Piper::Base.new(self.rl.piper,ario)
-          process_pipe_arg_(npiper)
+          nrio = new_rio(self,ario)
+          has_output_dest?(nrio) ? nrio.run :  nrio
+        end
+        #def last_rio(r)
+        #  r.scheme == 'cmdpipe' ? last_rio(r.rl.query[-1]) : r
+        #end
+        def last_rio(r)
+          r = r.rl.query[-1] while r.scheme == 'cmdpipe'
+          r
+        end
+
+        def has_output_dest?(nrio)
+          !%w[cmdio cmdpipe].include?(last_rio(nrio).scheme)
+        end
+        def run
+          rios = get_rios(self)
+
+          rio0 = rios.shift
+          input = if rio0.scheme == 'cmdio'
+                    rio0.rl.fib_proc(::RIO::Mode::Str.new("r"))
+                  else
+                    Cmd::FromEnum.new(rio0.to_enum)
+                  end
+          procs = []
+          while rios.size > 1
+            fp = rios.shift.rl.fib_proc(::RIO::Mode::Str.new('w+'))
+            procs.unshift(fp) 
+          end
+          orio = rios.shift
+          orio.touch if orio && orio.scheme.nil? # TODO: is this right???
+          output = Cmd::ToOutput.new(orio)
+          output.resume procs + [input]
+          #p "RUN orio.scheme=#{orio.scheme}"
+          orio
         end
+
+        private
+
         def piper
           self.rl.piper
         end
-        def has_output_dest?
-          piper.has_output_dest?
+        def get_rios(r)
+          r.scheme == 'cmdpipe' ? r.rl.query.inject([]){|rios,r1| rios+get_rios(r1)} : [r]
+        end
+
+        def is_output_dest?(erio)
+          erio.scheme != 'cmdio' && erio.scheme != 'cmdpipe'
         end
-#        def when_missing(sym,*args)
-#          #p callstr('when_missing',sym,*args)
-#          become 'CmdPipe::Stream::Open'
-#        end
       end
     end
   end

data/lib/rio/scheme/fd.rb

@@ -1,6 +1,6 @@
 #--
-# =============================================================================== 
-# Copyright (c) 2005,2006,2007,2008 Christopher Kleckner
+# ===========================================================================
+# Copyright (c) 2005-2012 Christopher Kleckner
 # All rights reserved
 #
 # This file is part of the Rio library for ruby.
@@ -18,47 +18,33 @@
 # 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 FD #:nodoc: all
-    require 'rio/rl/ioi'
-    RESET_STATE = RL::IOIBase::RESET_STATE
+    require 'rio/rrl/ioi'
+    RESET_STATE = RRL::IOIBase::RESET_STATE
 
-    class RL < RL::SysIOBase
+    class RRL < RRL::SysIOBase
       RIOSCHEME = 'fd'
-      RIOPATH = RIO::RL::CHMAP.invert[RIOSCHEME].freeze
-      def initialize(fd)
-        @fd = fd
-        super
+      RIOPATH = RIO::RRL::CHMAP.invert[RIOSCHEME].freeze
+      attr_reader :fd
+      def initialize(u,*args)
+        super(::Alt::URI.parse(u.to_s))
+        self.query ||= args.shift
       end
-      def open(m,*args)
-        super(::IO.new(@fd,m.to_s))
+      def query=(arg)
+        uri.query = arg.nil? ? nil : arg.to_s
+        arg
       end
-      def opaque() "#{@fd}" end
-      # must be able to process
-      # parse('rio:fd:<number>')
-      SPLIT_RE = %r|(\d+)$|
-      def self.splitrl(s)
-        sub,opq,whole = split_riorl(s)
-        if bm = SPLIT_RE.match(opq)
-          fd = bm[1].to_i
-          [fd]
-        end
+      def query
+        uri.query.nil? ? nil :  uri.query.to_i
+      end
+      def open(m,*args)
+        super(::IO.new(self.query,m.to_s))
       end
     end
   end

data/lib/rio/scheme/ftp.rb

@@ -1,6 +1,6 @@
 #--
-# =============================================================================== 
-# Copyright (c) 2005,2006,2007,2008 Christopher Kleckner
+# ===========================================================================
+# Copyright (c) 2005-2012 Christopher Kleckner
 # All rights reserved
 #
 # This file is part of the Rio library for ruby.
@@ -18,43 +18,32 @@
 # 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 'net/ftp'
 require 'open-uri'
 require 'rio/ftp/fs'
-require 'rio/rl/path'
+require 'rio/rrl/path'
 require 'rio/ftp/dir'
 require 'rio/ftp/ftpfile'
 
 module RIO
   module FTP #:nodoc: all
     #RESET_STATE = 'FTP::State::Reset'
-    RESET_STATE = RIO::RL::PathBase::RESET_STATE
+    RESET_STATE = RIO::RRL::PathBase::RESET_STATE
     
-    require 'rio/rl/uri'
+    require 'rio/rrl/withpath'
 
-    class RL < RIO::RL::URIBase
-      def initialize(arg0,*args)
-        #p callstr('initialize',arg0,*args)
-        super(*_sup_args(arg0,*args))
-        @ftype = nil
-        @names = nil
-      end
+    class RRL < RIO::RRL::URIBase
+    #  def initialize(arg0,*args)
+    #    p callstr('initialize',arg0.inspect,args.inspect)
+    #    super(*_sup_args(arg0,*args))
+    #    @ftype = nil
+    #    @names = nil
+    #  end
       def _sup_args(arg0,*args)
         if arg0 == 'ftp:'
           hn = args.shift || 'localhost'
@@ -75,7 +64,7 @@ module RIO
 #         case arg0
 #         when RIO::Rio
 #           return _init_from_arg(arg0.rl)
-#         when RIO::RL::URIBase,RIO::FTP::RL
+#         when RIO::RRL::URIBase,RIO::FTP::RL
 #           vuri,vbase,vfs = arg0.uri,arg0.base,arg0.fs
 #         when ::URI 
 #           vuri = arg0
@@ -89,34 +78,35 @@ module RIO
 #       def build_arg0_(path_str)
 #         path_str
 #       end
-      def join(*args)
-        return self if args.empty?
-        join_(args.map{ |arg| RIO::RL.fs2url(arg.to_s)})
-      end
-
+#      def join(*args)
+#        return self if args.empty?
+#        join_(args.map{ |arg| RIO::RL.fs2url(arg.to_s)})
+#      end
+      def typecode() uri.typecode end
+      def typecode=(val) uri.typecode = val end
 
-      def self.splitrl(s)
-        #p "splitrl(#{s})"
-        sub,opq,whole = split_riorl(s)
-        #p sub,opq,whole
-        [whole] 
-      end
+#      def self.splitrl(s)
+#        #p "splitrl(#{s})"
+#        sub,opq,whole = split_riorl(s)
+#        #p sub,opq,whole
+#        [whole] 
+#      end
       def openfs_
-        #p callstr('openfs_')
+        #p callstr('openfs_',self.uri)
         RIO::FTP::FS.create(self.uri)
       end
       def open(*args)
         IOH::Dir.new(RIO::FTP::Dir::Stream.new(self.uri))
       end
       def file_rl() 
-        RIO::FTP::Stream::RL.new(self.uri) 
+        RIO::FTP::Stream::RRL.new(self.uri) 
       end
       def dir_rl() 
         self 
       end
     end
     module Stream
-      class RL < RIO::RL::URIBase
+      class RRL < RIO::RRL::URIBase
         def self.splitrl(s) 
           sub,opq,whole = split_riorl(s)
           [whole] 
@@ -129,7 +119,11 @@ module RIO
           when m.primarily_write?
             RIO::IOH::Stream.new(RIO::FTP::FTPFile.new(fs.remote_path(@uri.to_s),fs.conn))
           else
-            RIO::IOH::Stream.new(@uri.open)
+            #p "scheme/ftp uri=#{@uri.inspect}"
+            u = URI.parse(@uri.to_s)
+            #p "scheme/ftp u=#{u.inspect}"
+            hndl = u.open
+            RIO::IOH::Stream.new(hndl)
           end
         end
         def file_rl() 

data/lib/rio/scheme/http.rb

@@ -1,6 +1,6 @@
 #--
-# =============================================================================== 
-# Copyright (c) 2005,2006,2007,2008 Christopher Kleckner
+# ===========================================================================
+# Copyright (c) 2005-2012 Christopher Kleckner
 # All rights reserved
 #
 # This file is part of the Rio library for ruby.
@@ -18,35 +18,26 @@
 # 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 HTTP #:nodoc: all
     RESET_STATE = 'HTTP::Stream::Open'
     
-    require 'rio/rl/uri'
-    class RL < RIO::RL::URIBase
-      def self.splitrl(s) 
-        sub,opq,whole = split_riorl(s)
-        [whole] 
-      end
+    require 'rio/rrl/withpath'
+    class RRL < RIO::RRL::URIBase
+      #def self.splitrl(s) 
+      #  sub,opq,whole = split_riorl(s)
+      #  [whole] 
+      #end
+      require 'uri'
       require 'open-uri'
       def open(*args)
-        IOH::Stream.new(self.uri.open)
+        u = ::URI.parse(self.to_s)
+        IOH::Stream.new(u.open)
       end
     end
 
@@ -59,7 +50,7 @@ module RIO
         include Ops::Path::URI
         include Ops::Path::Query
         def input() 
-          self.rl.base = self.ioh.base_uri
+          self.rl.base = self.ioh.base_uri.to_s
           stream_state('HTTP::Stream::Input') 
         end
       end