rio 0.4.2 → 0.5.1

data/lib/rio/rrl/path.rb

@@ -0,0 +1,117 @@
+#--
+# ===========================================================================
+# Copyright (c) 2005-2012 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
+# =========================================================================== 
+#++
+#
+
+
+module RIO
+  autoload :Stream, 'rio/stream'
+  #autoload :Ops, 'rio/ops'
+  #require 'rio/stream'
+  #require 'rio/stream/open'
+  #require 'rio/ops/symlink'
+end
+
+require 'rio/rrl/withpath'
+require 'rio/ops'
+require 'rio/ioh'
+
+
+
+module RIO
+  module RRL
+    class PathBase < URIBase
+      RESET_STATE = 'Path::Reset'
+      def to_s() self.fspath || '' end
+    end
+  end
+end
+
+module RIO
+  module Path
+    autoload :Reset, 'rio/path/reset'
+  end
+end
+
+module RIO
+  module Path #:nodoc: all
+    RESET_STATE = RIO::RRL::PathBase::RESET_STATE
+
+    class RRL < RIO::RRL::PathBase 
+      def file_rl()
+        RIO::File::RRL.new(self.uri, {:fs => self.fs})
+      end
+      def dir_rl()
+        RIO::Dir::RRL.new(self.uri, {:fs => self.fs})
+      end
+      #def absolute?
+      #  p "Path::RRL (rrl/path.rb) absolute?"
+      #  false
+      #end
+    end
+  end
+  module File
+    RESET_STATE = RIO::RRL::PathBase::RESET_STATE
+
+    class RRL < RIO::Path::RRL
+      def open(m)
+        IOH::Stream.new(fs.file.open(self.fspath,m.to_s))
+      end
+      def file_rl()
+        self
+      end
+    end
+  end
+  module Dir
+    RESET_STATE = RIO::RRL::PathBase::RESET_STATE
+
+    class RRL < RIO::Path::RRL
+      def open()
+        #IOH::Dir.new(fs.dir.open(self.fspath, :encoding => 'UTF-8'))
+        #p "Dir::RRL #{self.path},#{self.fspath}"
+        IOH::Dir.new(fs.dir.open(self.fspath))
+      end
+      def dir_rl()
+        self
+      end
+    end
+  end
+  module Path
+    module Stream
+      module Ops
+        include RIO::Ops::Path::Str
+      end
+
+      class Open < RIO::Stream::Open
+        include RIO::Ops::Path::Status
+        include RIO::Ops::Path::URI
+        include RIO::Ops::Path::Query
+        def stream_state(cl)
+          next_state = super
+          next_state.extend(RIO::Ops::Symlink::Existing) if symlink?
+          next_state.extend(Ops)
+        end
+      end
+    end
+  end
+end
+__END__

data/lib/rio/rrl/withpath.rb

@@ -0,0 +1,269 @@
+#--
+# ===========================================================================
+# Copyright (c) 2005-2012 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
+# =========================================================================== 
+#++
+#
+
+
+
+require 'rio/alturi'
+require 'rio/uriref'
+require 'rio/fwd'
+
+#require 'rio/local'
+#require 'rio/rrl/chmap'
+#require 'rio/rrl/base'
+
+require 'rio/exception/notimplemented'
+#require 'rio/rrl/builder'
+require 'rio/fs'
+
+module RIO
+  module RRL
+    module PathUtil
+    end
+  end
+end
+      # 
+
+module RIO
+  module RRL
+    class WithPath < RIO::RRL::Base
+      include RIO::RRL::PathUtil
+      include RIO::Error::NotImplemented
+
+      # returns an appriate FS object for the scheme
+      def openfs_() nodef() end
+
+      # returns the path portion of a URL. All spaces would be %20
+      # returns a String
+      #def urlpath() nodef() end
+      #def urlpath=(arg) nodef(arg) end
+
+      # For RLs that are on the file system this is fspath()
+      # For RLs that are remote (http,ftp) this is urlpath()
+      # For RLs that have no path this is nil
+      # returns a String
+      def path() nodef{} end
+      def path=(arg) nodef(arg) end
+
+      # returns A URI object representation of the RL if one exists
+      # otherwise it returns nil
+      # returns a URI
+      #def uri() nodef() end
+
+      # when the URL is legal it is the URI scheme
+      # otherwise it is one of Rio's schemes
+      # returns a String
+      def scheme() nodef() end
+
+      # returns the host portion of the URI if their is one
+      # otherwise it returns nil
+      # returns a String
+      def host() nodef() end
+      def host=(arg) nodef(arg) end
+
+      # returns the portion of the URL starting after the colon
+      # following the scheme, and ending before the query portion
+      # of the URL
+      # returns a String
+      def opaque() nodef() end
+
+      # returns the portion of the path that when prepended to the 
+      # path would make it usable.
+      # For paths on the file system this would be '/'
+      # For http and ftp paths it would be http://host/
+      # For zipfile paths it would be ''
+      # For windows paths with a drive it would be 'C:/'
+      # For windows UNC paths it would be '//host/'
+      # returns a String
+      def pathroot() nodef() end
+
+
+      # returns the base of a path. 
+      # merging the value returned with this yields the absolute path
+      def base(thebase=nil) nodef(thebase) end
+
+    end
+  end
+end
+
+module RIO
+  module RRL
+    class WithPath < RIO::RRL::Base
+      extend Forwardable
+      extend Fwd
+
+      # The value of urlpath() with any trailing slash removed
+      # returns a String
+      def path_no_slash() 
+        path.sub(%r{/*$},'')
+      end
+      # The value of fspath() with any trailing slash removed
+      # returns a String
+      def fspath_no_slash() 
+        fspath.sub(%r{/*$},'')
+      end
+      def pathdepth()
+        pth = self.path_no_slash
+        #is_root?(pth) ? 0 : pth.count('/')
+        pth.count('/')
+      end
+
+      def_delegators :uri,:netpath, :netpath=, :fspath, :fspath=
+      def_delegators :uri, :abs, :rel, :route_to, :route_from
+      def_delegators :uri, :join, :rel, :route_to, :route_from
+      fwd :uri, :dirname, :basename, :extname, :filename
+      fwd :uri, :scheme, :authority, :path, :query, :fragment
+      fwd :uri, :host, :port, :userinfo, :netpath, :user, :password
+
+      def absolute?
+        #p 'rrl/withpath.rb absolute?'
+        uri.absolute?
+      end
+      # Marty Cell 319-210-3284
+      #def abs?
+      #  p 'rrl/withpath.rb abs?'
+      #  uri.absolute?
+      #nd
+      #fwd :uri, :base
+      def base
+        #p "IN BASE: uri=#{uri.inspect}" 
+        uri.base
+      end
+
+      def base=(other)
+        #p "IN BASE: uri=#{uri.inspect}" 
+        uri.base = other
+      end
+
+      def split()
+        u = self.uri.normalize
+        scheme = u.scheme == 'file' ? nil : u.scheme
+        uauth = u.authority
+        authpart = uauth unless (scheme.nil? and (uauth.nil? || uauth.empty? || uauth == 'localhost'))
+        if u.path.start_with?("/")
+          rootpathpart = "/"
+          pathpart = u.path[1..-1]
+        else
+          pathpart = u.path
+        end
+        pparts = pathpart.split("/")
+        
+        rootpath = ::Alt::URI.create(:scheme => scheme, :authority => authpart, :path => rootpathpart).to_s
+        #p "ROOTPATH=#{rootpath}"
+        sparts = [rootpath,pparts].flatten
+        #p "SPARTS=#{sparts.inspect}"
+        #p ::Dir.getwd
+        basepart = if rootpath.empty?
+                     ::Alt::URI.create(:scheme => 'file', :authority => "", :path => ::Dir.getwd + "/").to_s
+                   else
+                     rootpath
+                   end
+        #p "basepart=#{basepart}"
+        bparts = [basepart]
+        bparts << basepart.clone
+
+        (1...sparts.length).each do |n|
+          basepart += sparts[n] + "/"
+          bparts << basepart.clone
+        end
+        #p "BPARTS=#{bparts.inspect}"
+        if sparts[0].empty?
+          sparts.shift
+          bparts.shift
+        end
+        
+        [sparts,bparts]
+
+      end
+
+    end
+  end
+end
+
+
+module RIO
+  module RRL
+    class URIBase < WithPath
+
+      def initialize(u,*args)
+        # u should be a ::URI or something that can be parsed to one
+        #p callstr('initialize',u,*args)
+        #p "URIBASE u=#{u} (#{u.class}) args=#{args.inspect} "
+        args,opts = _get_opts_from_args(args)
+        #opts[:fs] ||= openfs_
+        #opts[:encoding] = opts[:fs] ? opts[:fs].encoding : nil
+        #p "URIBase OPTS=#{opts.inspect} U=#{u.inspect}"
+        uriref = case u
+                 when ::Alt::URI::Base
+                   _uriref_from_alturi(u,opts,*args)
+                 when ::RIO::URIRef
+                   if opts[:base]
+                     _uriref_from_alturi(u.ref,opts,*args)
+                   else
+                     rtn = u.clone.join(*args)
+                     rtn
+                   end
+                 else
+                   _uriref_from_alturi(::Alt::URI.parse(u.to_s,opts),opts,*args)
+                 end
+        #p "URIBASE uriref=#{uriref} (#{uriref.inspect}) "
+        super(uriref,opts[:fs])
+        opts[:fs] ||= openfs_
+        #p opts[:fs]
+        self.uri.parts.encoding ||= opts[:fs].encoding
+      end
+
+      private
+
+      def _uriref_from_alturi(alturi,opts,*args)
+        alturi.join(*args)
+        #p "ZIPPY #{alturi.absolute?} #{alturi.inspect} opts=#{opts.inspect}"
+        #p "withpath: _uriref_from_alturi enc=#{opts[:encoding].inspect}"
+        ::RIO::URIRef.build(alturi,opts)
+      end
+      def _get_opts_from_args(args)
+        opts = {}
+        if !args.empty? and args[-1].kind_of?(::Hash) 
+          opts = args.pop
+        end
+        [args,opts]
+      end
+
+      public
+
+      def self.parse(*a)
+        u = a.shift.sub(/^rio:/,'')
+        #p "URIBASE#parse u=#{u} (#{u.class}) args=#{a.inspect} "
+        new(u,*a)
+      end
+      def initialize_copy(other)
+        super
+      end
+      def openfs_()
+        #p callstr('openfs_')
+        #p "URIBase: openfs_  enc=#{::Dir.pwd.encoding}"
+        self.fs || RIO::FS::LOCAL
+      end
+    end
+  end
+end

data/lib/rio/scheme/aryio.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,20 +18,9 @@
 # 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
-#
 
 __END__
 require 'rio/rl/ioi'

data/lib/rio/scheme/cmdio.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,63 +18,94 @@
 # 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/stream'
+require 'rio/stream/open'
+require 'rio/fibpipe'
+require 'rio/rrl/ioi'
+require 'rio/rrl/chmap'
+
 
 
 module RIO
   module CmdIO #:nodoc: all
-    require 'rio/rl/ioi'
-    RESET_STATE = 'Stream::Duplex::Open'
+     RESET_STATE = 'Stream::Duplex::Open'
 
-    class RL < RL::SysIOBase 
+    class RRL < RRL::SysIOBase 
       RIOSCHEME = 'cmdio'
-      RIOPATH = RIO::RL::CHMAP.invert[RIOSCHEME].to_s.freeze
-      attr_reader :cmd
-      def initialize(cmd="")
-        case cmd
-        when self.class then @cmd = cmd.cmd
-        else @cmd = cmd
+      RIOPATH = RIO::RRL::CHMAP.invert[RIOSCHEME].to_s.freeze
+      
+      attr_reader :ior,:iow
+      def initialize(u,*a)
+        # p "CMDIO initialize: u=#{u.inspect} a=#{a.inspect}"
+        super(u)
+        a = a.map(&:to_s)
+        com = case c = a.shift
+              when self.class then c.cmd
+              else c
+              end
+        unless com.nil?
+          self.path = com
+          self.query = a
         end
-        super
       end
-      def opaque() 
-        URI.escape(@cmd,RIO::RL::ESCAPE)
+      extend Forwardable
+      def_delegators :uri, :path=, :path
+      def query
+        uri.query
+      end
+      def query=(args)
+        uri.query = args
+      end
+      def self.parse(*a)
+        u = a.shift.sub(/^rio:/,'')
+        new(u,*a)
+      end
+      alias :cmd :path
+      alias :args :query
+      def fib_proc(m)
+        #fibproc
+        #p "CMD=#{cmd},args=#{args.inspect}"
+        poargs = args.nil? ? cmd : [cmd,args]
+        if m.allows_write?
+          Cmd::FibPipeProc.new(poargs,m.to_s)
+        else
+          Cmd::FibSourceProc.new(poargs,m.to_s)
+        end
       end
+
       def to_s()
-        @cmd
+        [cmd,args].flatten.join(' ').strip
       end
       def open(m)
-        #p "opening #{@cmd}"
-        #raise RuntimeError, "Should Not Open"
-        super(::IO.popen(@cmd,m.to_s))
+        poarg = args.nil? ? cmd : [cmd,args].flatten
+        #p "CMDIO poarg=#{poarg.inspect}"
+        io = IO.popen(poarg,m.to_s)
+        super(io)
       end
 
-      # must be able to process
-      # parse('rio:cmdio',cmd)
-      # parse('rio:cmdio:escaped_cmd')
-      SPLIT_RE = %r|(?:(.+))$|.freeze
-      def self.splitrl(s)
-        sub,opq,whole = split_riorl(s)
-        if bm = SPLIT_RE.match(opq)
-          escaped_cmd = bm[1]
-          cmd = URI.unescape(escaped_cmd)
-          [cmd]
-        end
-      end
 
     end
   end
+  module Stream
+    module Duplex
+      class Open < RIO::Stream::Open
+        include Piper::Cp::Input
+        
+        def cmd() rl.path end
+        def cmd_args() rl.query end
+        #def cmd_str() [cmd,cmd_args].flatten.join(' ') end
+        #def |(arg)
+        #  #p "CMDIO#| #{self}|#{arg}"
+        #  nrio = new_rio(:cmdpipe,self,arg)
+        #  end_rio = nrio.rl.query[-1]
+        #  p "CmdIO#end_rio=#{end_rio}"
+        #  nrio
+        #end
+      end
+    end
+  end
 end