rio 0.3.4 → 0.3.6

data/lib/rio/rl/pathmethods.rb

@@ -0,0 +1,95 @@
+#--
+# =============================================================================== 
+# 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>
+
+
+require 'rio/rl/uri'
+module RIO
+  module RL
+    module PathMethods
+      def urlroot()
+        return nil unless absolute?
+        cp = self.clone
+        cp.urlpath = self.pathroot
+        cp.url
+      end
+      def _parts()
+        pr = self.pathroot
+        ur = self.urlroot.sub(/#{pr}$/,'')
+        up = self.urlpath.sub(/^#{pr}/,'')
+
+        [ur,pr,up]
+      end
+      def split()
+        if absolute?
+          parts = self._parts
+          sparts = []
+          sparts << parts[0] + parts[1]
+          sparts += parts[2].split('/')
+        else
+          sparts = self.urlpath.split('/')
+        end
+        require 'rio/to_rio'
+        rlparts = sparts.map { |str| self.class.new(str) }
+        (1...sparts.length).each { |i|
+          rlparts[i].base = rlparts[i-1].abs.url + '/'
+        }
+        rlparts
+      end
+
+      def join(*args)
+        return self if args.empty?
+        sa = args.map { |arg| ::URI.escape(arg.to_s,ESCAPE) }
+        sa.unshift(self.urlpath) unless self.urlpath.empty?
+        self.urlpath = sa.join('/').squeeze('/')
+      end
+
+      def parse_url(str)
+        ::URI.parse(::URI.escape(str,ESCAPE))
+      end
+
+      def route_from(other)
+        self.class.new(uri.route_from(other.uri),{:base => other.url})
+      end
+      def route_to(other)
+        self.class.new(uri.route_to(other.uri),{:base => self.url})
+      end
+      def merge(other)
+        self.class.new(uri.merge(other.uri))
+      end
+
+    end
+  end
+end

data/lib/rio/rl/uri.rb

@@ -41,82 +41,72 @@ module RIO
     class URIBase < Base
       attr_reader :uri
       attr_writer :base
+      SCHEME = URI::REGEXP::PATTERN::SCHEME
       def initialize(u,*args)
         #p callstr('initialize',u,*args)
         # u should be a ::URI or something that can be parsed to one
-        args = get_base(*args)
+        args = _get_base_from_args(args)
         @uri =  _mkuri(u)
         self.join(*args)
         @uri.path = '/' if @uri.absolute? and @uri.path == ''
       end
       def initialize_copy(*args)
-        #p callstr('initialize_copy',*args)
-
         super
         @uri = @uri.clone unless @uri.nil?
         @base = @base.clone unless @base.nil?
       end
-      def _mkuri(arg)
-        (arg.kind_of?(::URI) ?  arg.dup : parse_url(arg.to_s))
-      end
-      def base(arg=nil)
-        @base = _mkuri(arg) unless arg.nil? or @uri.absolute?
-        (@base.nil? ? @uri : @base)
-      end
-      def join(*args)
-#        self.class.joinuri(self.uri,*args)
-        return @uri if args.empty?
-        sa = args.map(&:to_s).map { |str| ::URI.escape(str,ESCAPE) }
-        sa.unshift @uri.path unless @uri.path.empty?
-        @uri.path = sa.join('/')
-        @uri.path.gsub!(%r|/+|,'/')
-      end
-
-      def parse_url(str)
-        ::URI.parse(::URI.escape(str,ESCAPE))
-      end
-
-      def url() self.uri.to_s end
-      def fs2url(pth) RL.fs2url(pth) end
-      def url2fs(pth) RL.url2fs(pth) end
-      def fspath() RL.url2fs(@uri.path) end
-
-      def route_from(other)
-        self.class.new(@uri.route_from(other.uri),other)
-      end
-      def route_to(other)
-        self.class.new(@uri.route_to(other.uri),self.abs)
-      end
-      def merge(other)
-        self.class.new(@uri.merge(other.uri))
-      end
-      def get_base(*args)
+      def _get_base_from_args(args)
         #      args.each { |a| p "get_base len=#{args.length} #{a.class}##{a.to_s}" }
         @base = nil
-        if args.length > 0
-          b = args.pop
+        if !args.empty? and args[-1].kind_of?(::Hash) and (b = args.pop[:base])
           @base = case b
                   when URIBase then  b.uri if b.uri.absolute?
                   when ::URI then b if b.absolute?
-                  when ::String then  ::URI.parse(b) if b  =~ /^[a-z]+:/
+                  when ::String then  ::URI.parse(b) if b  =~ /^#{SCHEME}:/
                   end
-          args.push b unless @base
         end
         args
       end
-      def abs()
-        return self if @uri.absolute?
-        self.class.new(@base.merge(@uri),@base) 
+      def pathroot() '/' end
+      def _mkuri(arg)
+        (arg.kind_of?(::URI) ?  arg.dup : parse_url(arg.to_s))
       end
-      def path_no_slash
-        path.sub(/\/$/,'')
+      def base(arg=nil)
+        self.base = arg unless arg.nil? or @uri.absolute?
+        @base || @uri
       end
-      def path=(pt)
-        @uri.path = pt
+      def base=(arg) @base = _mkuri(arg) end
+      require 'rio/rl/pathmethods'
+      include PathMethods
+
+      def urlpath=(pt) @uri.path = pt end
+      def urlpath() @uri.path end
+
+      def path=(pt) self.urlpath = pt end
+      def path() self.urlpath end
+      def path_no_slash() self.path.sub(/\/$/,'') end
+
+      def opaque() 
+        u = @uri.dup
+        u.scheme = nil
+        u.to_s
       end
-      extend Forwardable
-      def_instance_delegators(:@uri,:to_s,:path,:absolute?,:host)
+
+      def scheme() @uri.scheme end
+      def host() @uri.host end
+      def host=(arg) @uri.host = arg end
+
+      def absolute?() @uri.absolute? end
       alias abs? absolute?
+
+      def abs()
+        return self if absolute?
+        self.class.new(@base.merge(@uri),{:base => @base}) 
+      end
+
+      def url() @uri.to_s end
+      def to_s() self.url end
+
     end
   end
 end

data/lib/rio/scheme/cmdio.rb

@@ -43,8 +43,12 @@ module RIO
     class RL < RL::SysIOBase 
       RIOSCHEME = 'cmdio'
       RIOPATH = RIO::RL::CHMAP.invert[RIOSCHEME].to_s.freeze
+      attr_reader :cmd
       def initialize(cmd="")
-        @cmd = cmd
+        case cmd
+        when self.class then @cmd = cmd.cmd
+        else @cmd = cmd
+        end
       end
       def opaque() 
         URI.escape(@cmd,RIO::RL::ESCAPE)
@@ -53,6 +57,8 @@ module RIO
         @cmd
       end
       def open(m)
+        #p "opening #{@cmd}"
+        #raise RuntimeError, "Should Not Open"
         ::IO.popen(@cmd,m.to_s)
       end
 

data/lib/rio/scheme/cmdpipe.rb

@@ -0,0 +1,150 @@
+#--
+# =============================================================================== 
+# 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>
+
+
+require 'rio/rl/ioi'
+require 'rio/stream'
+require 'rio/stream/open'
+require 'rio/piper'
+
+module RIO
+  module CmdPipe #:nodoc: all
+    RESET_STATE = 'CmdPipe::Stream::Reset'
+
+    class RL < RL::IOIBase 
+      RIOSCHEME = 'cmdpipe'
+      RIOPATH = RIO::RL::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]
+        else
+          @piper = Piper::Base.new(*args)
+        end
+      end
+      def initialize_copy(*args)
+        @piper = @piper.clone
+      end
+      def opaque()
+        #p callstr('opaque')
+        @piper.rios.map{|cmd| URI.escape(cmd.to_s,RIO::RL::ESCAPE)}.join('|')
+      end
+      def to_s()
+        return "" if @piper.rios.nil? or @piper.rios.empty?
+        @piper.rios.map{|cmd| cmd.to_s}.join('|')
+      end
+      def open(m,*args)
+        @outp = rio(?")
+        rp = Piper::Base.new(@piper,@outp)
+        rp.run
+        @outp
+      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]
+        else
+          []
+        end
+      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)
+        end
+        def piper
+          self.rl.piper
+        end
+        def has_output_dest?
+          piper.has_output_dest?
+        end
+#        def when_missing(sym,*args)
+#          #p callstr('when_missing',sym,*args)
+#          become 'CmdPipe::Stream::Open'
+#        end
+      end
+      class Open < RIO::Stream::Open
+        def input() stream_state('CmdPipe::Stream::Input') end
+        def output() stream_state('CmdPipe::Stream::Output') end
+        def inout() stream_state('CmdPipe::Stream::InOut') end
+        def open_(*args)
+          unless open?
+            ios = self.rl.open(mode?,*args)
+            self.ioh = ios #IOH::Stream.new(ios)
+          end
+          self
+        end
+      end
+
+      module Ops
+      end
+
+      class Input < RIO::Stream::Input
+        include Ops
+        def ior
+          ioh.rd
+        end
+      end
+
+      class Output < RIO::Stream::Output
+        include Ops
+        def iow
+          ioh.wr
+        end
+      end
+
+      class InOut < RIO::Stream::InOut
+        include Ops
+      end
+    end
+  end
+end

data/lib/rio/scheme/ftp.rb

@@ -50,8 +50,6 @@ module RIO
         sub,opq,whole = split_riorl(s)
         [whole] 
       end
-      def to_s() self.url end
-      def scheme() self.uri.scheme end
       def open(*args)
         RIO::FTP::Conn.new(@uri)
       end
@@ -62,8 +60,6 @@ module RIO
           sub,opq,whole = split_riorl(s)
           [whole] 
         end
-        def to_s() self.url end
-        def scheme() self.uri.scheme end
         def open(*args)
           @uri.open
         end

data/lib/rio/scheme/http.rb

@@ -45,8 +45,6 @@ module RIO
         sub,opq,whole = split_riorl(s)
         [whole] 
       end
-      def to_s() self.url end
-      def scheme() self.uri.scheme end
       require 'open-uri'
       def open(*args)
         self.uri.open

data/lib/rio/scheme/strio.rb

@@ -50,6 +50,22 @@ module RIO
       def initialize(str="")
         @str = str
       end
+
+      def opaque() sprintf('0x%08x',@str.object_id) end
+
+      # must be able to process both
+      # parse('rio:strio',string)
+      # parse('rio:strio:0xHEXIOS')
+      SPLIT_RE = %r|0x([0-9a-fA-F]+)$|
+      def self.splitrl(s)
+        sub,opq,whole = split_riorl(s)
+        if bm = SPLIT_RE.match(opq)
+          oid = bm[1].hex
+          str = ObjectSpace._id2ref(oid)
+          [str]
+        end
+      end
+
       def open(m,*args)
         ::StringIO.new(@str,m.to_s,*args)
       end

data/lib/rio/scheme/temp.rb

@@ -54,9 +54,9 @@ module RIO
       #def path() nil end
       def scheme() self.class.const_get(:RIOSCHEME) end
       def opaque()
-        td = @tmpdir.to_s
+        td = self.escape(@tmpdir.to_s)
         td += '/' unless td.nil? or td.empty? or (td.ends_with?('/') and td != '/')
-        td+@prefix
+        td + self.escape(@prefix)
       end
       
       SPLIT_RE = %r|(?:(.*)/)?([^/]*)$|.freeze
@@ -134,15 +134,15 @@ module RIO
         @tempobj = nil
       end
       def check?() true end
-      def dir(prefix=rl.prefix,tmpdir=rl.tmpdir)
+      def mkdir(prefix=rl.prefix,tmpdir=rl.tmpdir)
         self.rl = RIO::Temp::Dir::RL.new(prefix, tmpdir)
         become 'Dir::Existing'
       end
-      def mkdir()
-        dir()
-      end
+#      def mkdir()
+#        dir()
+#      end
       def chdir(&block)
-        dir.chdir(&block)
+        self.mkdir.chdir(&block)
       end
       def file(prefix=rl.prefix,tmpdir=rl.tmpdir)
         self.rl = RIO::Temp::File::RL.new(prefix, tmpdir)