wishdev-rio 0.4.3.1

data/lib/rio/scheme/sysio.rb

@@ -0,0 +1,63 @@
+#--
+# =============================================================================== 
+# 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 SysIO #:nodoc: all
+    require 'rio/rl/ioi'
+    RESET_STATE = RL::IOIBase::RESET_STATE
+
+    class RL < RL::SysIOBase
+      RIOSCHEME = 'sysio'
+      RIOPATH = RIO::RL::CHMAP.invert[RIOSCHEME].to_s.freeze
+      def opaque() sprintf('0x%08x',self.ios.object_id) end
+      def open(*args)
+        super(*args)
+      end
+      # must be able to process both
+      # parse('rio:sysio',ios)
+      # parse('rio:sysio: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
+          ios = ObjectSpace._id2ref(oid)
+          [ios]
+        end
+      end
+    end
+  end
+end

data/lib/rio/scheme/tcp.rb

@@ -0,0 +1,75 @@
+#--
+# =============================================================================== 
+# 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/rl/base'
+module RIO
+  module TCP #:nodoc: all
+    RESET_STATE = 'Stream::Duplex::Open'
+    require 'rio/rl/ioi'
+    class RL < RL::IOIBase 
+      RIOSCHEME = 'tcp'.freeze
+      attr_reader :host
+      def initialize(host,port)
+        @host = host
+        @port = port
+        super
+      end
+      def opaque()
+        sprintf('//%s:%s',@host,@port)
+      end
+      require 'socket'
+      def open(*args)
+        #          @host = 'localhost' if @host.nil? or @host.empty?
+        super(::TCPSocket.new(@host || 'localhost',@port))
+      end
+      def to_s() self.url end
+      
+      # must be able to process
+      # parse('rio:tcp',host,port)
+      # parse('rio:tcp://host:port')
+      SPLIT_RE = %r|//([^/:]*):([0-9a-z]+)$|.freeze
+      def self.splitrl(s)
+        sub,opq,whole = split_riorl(s)
+        if bm = SPLIT_RE.match(opq)
+          host = bm[1]
+          port = bm[2]
+          host = nil if host.empty?
+          [host,port]
+        end
+      end
+    end
+  end
+end

data/lib/rio/scheme/temp.rb

@@ -0,0 +1,200 @@
+#--
+# =============================================================================== 
+# 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 'tmpdir'
+module RIO
+  module Temp #:nodoc: all
+    RESET_STATE = 'Temp::Reset'
+
+    require 'rio/rl/base'
+    class RL < RL::Base 
+      RIOSCHEME = 'temp'
+      RIOPATH = RIO::RL::CHMAP.invert[RIOSCHEME].to_s.freeze
+      DFLT_PREFIX = 'rio'
+      DFLT_TMPDIR = ::Dir::tmpdir
+      attr_reader :prefix,:tmpdir
+      def initialize(file_prefix=DFLT_PREFIX,temp_dir=DFLT_TMPDIR)
+        #puts "initialize(#{file_prefix.inspect},#{temp_dir.inspect})"
+        @prefix = file_prefix || DFLT_PREFIX
+        @tmpdir = temp_dir || DFLT_TMPDIR
+        super
+      end
+      #def path() nil end
+      def scheme() self.class.const_get(:RIOSCHEME) end
+      def opaque()
+        td = self.escape(@tmpdir.to_s)
+        td += '/' unless td.nil? or td.empty? or (td != '/' and td[-1] == ?/)
+        td + self.escape(@prefix)
+      end
+      
+      SPLIT_RE = %r|(?:(.*)/)?([^/]*)$|.freeze
+      def self.splitrl(s)
+        sub,opq,whole = split_riorl(s)
+        if opq.nil? or opq.empty?
+          []
+        elsif bm = SPLIT_RE.match(opq)
+          tdir = bm[1] unless bm[1].nil? or bm[1].empty?
+          tpfx = bm[2] unless bm[2].nil? or bm[2].empty?
+          [tpfx,tdir]
+        else
+          []
+        end
+      end
+    end
+    module Dir
+      require 'rio/rl/path'
+      RESET_STATE = RIO::RL::PathBase::RESET_STATE
+      require 'tmpdir'
+      class RL < RIO::RL::PathBase 
+        RIOSCHEME = 'tempdir'
+        DFLT_PREFIX = Temp::RL::DFLT_PREFIX
+        DFLT_TMPDIR = Temp::RL::DFLT_TMPDIR
+        attr_reader :prefix,:tmpdir,:tmprl
+        def initialize(file_prefix=DFLT_PREFIX,temp_dir=DFLT_TMPDIR)
+          #puts "initialize(#{file_prefix.inspect},#{temp_dir.inspect})"
+          @prefix = file_prefix || DFLT_PREFIX
+          @tmpdir = temp_dir || DFLT_TMPDIR
+          require 'rio/tempdir'
+          @td = ::Tempdir.new( @prefix.to_s, @tmpdir.to_s)
+          super(@td.to_s)
+        end
+        def dir_rl() 
+          #p "temp:dir_rl: #{self.uri.inspect}"
+          RIO::Dir::RL.new(self.uri, {:fs => self.fs})
+          #self 
+        end
+        SPLIT_RE = Temp::RL::SPLIT_RE
+        def self.splitrl(s)
+          Temp::RL.splitrl(s)
+        end
+      end
+    end
+    module File
+      require 'rio/rl/path'
+      RESET_STATE = 'Temp::Stream::Open'
+      class RL < RIO::RL::PathBase 
+        RIOSCHEME = 'tempfile'
+        DFLT_PREFIX = Temp::RL::DFLT_PREFIX
+        DFLT_TMPDIR = Temp::RL::DFLT_TMPDIR
+        attr_reader :prefix,:tmpdir,:tmprl
+        def initialize(file_prefix=DFLT_PREFIX,temp_dir=DFLT_TMPDIR)
+          #puts "initialize(#{file_prefix.inspect},#{temp_dir.inspect})"
+          @prefix = file_prefix || DFLT_PREFIX
+          @tmpdir = temp_dir || DFLT_TMPDIR
+          require 'tempfile'
+          @tf = ::Tempfile.new( @prefix.to_s, @tmpdir.to_s)
+          super(@tf.path)
+        end
+        def file_rl() 
+        RIO::File::RL.new(self.uri,{:fs => self.fs})
+          #self 
+        end
+        def open(mode='ignored')
+          #p callstr('open',mode)
+          @tf
+        end
+        def close 
+          super
+          @tf = nil
+        end
+        SPLIT_RE = Temp::RL::SPLIT_RE
+        def self.splitrl(s)
+          Temp::RL.splitrl(s)
+        end
+      end
+    end
+    require 'rio/state'
+    class Reset < State::Base
+      def initialize(*args)
+        super
+        #p args
+        @tempobj = nil
+      end
+      def self.default_cx
+        Cx::Vars.new( { 'closeoneof' => false, 'closeoncopy' => false } )
+      end
+
+      def check?() true end
+      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 chdir(&block)
+        self.mkdir.chdir(&block)
+      end
+      def file(prefix=rl.prefix,tmpdir=rl.tmpdir)
+        self.rl = RIO::Temp::File::RL.new(prefix, tmpdir)
+        become 'Temp::Stream::Open'
+      end
+      def scheme() rl.scheme() end
+      def host() rl.host() end
+      def opaque() rl.opaque() end
+      def to_s() rl.url() end
+      def exist?() false end
+      def file?() false end
+      def dir?() false end
+      def open?() false end
+      def closed?() true end
+      def when_missing(sym,*args)
+        #p @rl.scheme
+        if @tempobj.nil?
+          file()
+        else
+          gofigure(sym,*args)
+        end
+      end
+    end
+    require 'rio/stream/open'
+    module Stream
+      class Open < RIO::Stream::Open
+        def iostate(sym)
+          mode_('w+').open_.inout()
+        end
+#        def inout() stream_state('Temp::Stream::InOut') end
+      end
+#      require 'rio/stream'
+#      class InOut < RIO::Stream::InOut
+#        def base_state() 'Temp::Stream::Close' end
+#      end
+#      class Close < RIO::Stream::Close
+#        def base_state() 'Temp::Reset' end
+#      end
+
+    end
+  end
+end

data/lib/rio/state/error.rb

@@ -0,0 +1,72 @@
+#--
+# =============================================================================== 
+# 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/state'
+module RIO
+
+  module State
+    class Error < Base
+      attr_accessor :obj,:msg,:sym
+      def initialize
+        super
+        @obj = nil
+        @msg = nil
+        @sym = nil
+#        self.send(sym,*args) #unless obj == self
+      end
+      def check?() true end
+      def when_missing(sym,*args) self end
+      def method_missing(sym,*args,&block)
+ #       emsg = sprintf("Can't Handle %s[%s].%s(%s)",@obj.class.to_s,@obj.to_s,sym.to_s,args.join(','))
+ #       emsg += "\n  "+@msg unless @msg.nil? or @msg.empty?
+        emsg = @msg
+        raise Exception::CantHandle.new(@obj,sym,*args),emsg
+      end
+      def self.error(emsg,obj,sym,*args)
+        require 'rio/exception'
+        state = new
+        state.obj = obj
+        state.sym = sym
+        msg = sprintf("%s[%s].%s(%s)",obj.class.to_s,obj.to_s,sym.to_s,args.join(','))
+        msg += "\n  "+emsg unless emsg.nil? or emsg.empty?
+        state.msg = msg
+        state
+#        raise CantHandle.new(obj,sym,*args),emsg
+      end
+    end
+  end 
+
+end # module RIO

data/lib/rio/state.rb

@@ -0,0 +1,242 @@
+#--
+# =============================================================================== 
+# 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/state'
+require 'rio/context'
+require 'rio/context/methods'
+require 'rio/ext'
+require 'rio/symantics'
+require 'rio/filter'
+require 'rio/fs/native'
+
+module RIO
+
+                   
+  module State #:nodoc: all
+    # = State
+    # the abstract state from which all are derived
+    # this level handles 
+    # * some basic house keeping methods
+    # * the methods to communicate with the rio object
+    # * the state changing mechanism
+    # * and some basic error handling stubs
+    class Base
+      KIOSYMS = [:gets,:open,:readline,:readlines,:putc,:puts,:print,:printf,
+                 :=~,:===,:==,:eql?,:load]
+      @@kernel_cleaned ||= KIOSYMS.each { |sym| undef_method(sym) } 
+      undef_method(:rio)
+    end 
+    
+    class Base
+      attr_accessor :try_state
+      #attr_accessor :handled_by
+
+      attr_accessor :rl
+      attr_accessor :ioh
+
+      attr_accessor :cx
+
+      # Context handling
+      include Cx::Methods
+      include RIO::Ext::Cx
+
+      
+      def initialize(rl=nil,cx=nil,ioh=nil)
+        cx ||= self.class.default_cx
+        _init(rl,cx,ioh)
+        #        @handled_by = self.class.to_s
+      end
+      
+      def _init(riorl,cntx,iohandle=nil)
+        @rl = riorl
+        @cx = cntx
+        @ioh = iohandle
+#        raise Exception::FailedCheck.new(self) unless check?
+        self
+      end
+      private :_init
+
+      def initialize_copy(*args)
+        #p callstr('initialize_copy',args[0].inspect)
+        super
+        @rl = @rl.clone unless @rl.nil?
+        @cx = @cx.clone unless @cx.nil?
+        @ioh = @ioh.clone unless @ioh.nil?
+        # @fs = @fs
+      end
+
+      def self.default_cx
+         Cx::Vars.new( { 'closeoneof' => true, 'closeoncopy' => true } )
+      end
+      def self.new_other(other)
+        new(other.rl,other.cx,other.ioh)
+      end
+
+      alias :ior :ioh
+      alias :iow :ioh
+
+
+
+
+      # Section: State Switching
+
+      # the method for changing states
+      # it's job is create an instance of the next state
+      # and change the value in the handle that is shared with the rio object
+      def become(new_class,*args)
+        p "become : #{self.class.to_s} => #{new_class.to_s} (#{self.mode?})" if $trace_states
+        #p "BECOME #{new_class}: #{cx['ss_type']}"
+        return self if new_class == self.class
+
+        begin
+          new_state = try_state[new_class,*args]
+        rescue Exception::FailedCheck => ex
+          p "not a valid "+new_class.to_s+": "+ex.to_s+" '"+self.to_s+"'"
+          raise
+        end
+        became(new_state)
+        new_state
+      end
+      def became(obj)
+        #RIO::Ext.became(obj)
+      end
+      def method_missing_trace_str(sym,*args)
+        "missing: "+self.class.to_s+'['+self.to_url+" {#{self.rl.fs}}"+']'+'.'+sym.to_s+'('+args.join(',')+')'
+        #"missing: "+self.class.to_s+'['+self.to_url+""+']'+'.'+sym.to_s+'('+args.join(',')+')'
+      end
+
+      def method_missing(sym,*args,&block)
+        p method_missing_trace_str(sym,*args) if $trace_states
+
+        obj = when_missing(sym,*args)
+        raise RuntimeError,"when_missing returns nil" if obj.nil?
+        obj.__send__(sym,*args,&block) #unless obj == self
+      end
+      
+      def when_missing(sym,*args) gofigure(sym,*args) end
+
+
+      def base_state() Factory.instance.reset_state(@rl) end
+
+      def softreset 
+        #p "softreset(#{self.class}) => #{self.base_state}"
+        cx['retrystate'] = nil
+        become(self.base_state) 
+      end
+      def retryreset 
+        #p "retryreset(#{self.class}) => #{self.base_state}"
+        become(self.base_state) 
+      end
+      def reset
+        softreset()
+      end
+
+      # Section: Error Handling
+      def gofigure(sym,*args)
+        cs = "#{sym}("+args.map{|el| el.to_s}.join(',')+")"
+        msg = "Go Figure! rio('#{self.to_s}').#{cs} Failed"
+        error(msg,sym,*args)
+      end
+
+      def error(emsg,sym,*args)
+        require 'rio/state/error'
+        Error.error(emsg,self,sym,*args)
+      end
+
+      def to_rl() self.rl.rl end
+      def fs() self.rl.fs end
+
+      extend Forwardable
+      def_instance_delegators(:rl,:path,:to_s,:fspath,:urlpath,:length)
+
+      def ==(other) @rl == other end
+      def ===(other) self == other end
+      def =~(other) other =~ self.to_str end
+      def to_url() @rl.url end
+      def to_uri() @rl.uri end
+      alias to_str to_s
+
+      def hash() @rl.to_s.hash end
+      def eql?(other) @rl.to_s.eql?(other.to_s) end
+
+      def stream?() false end
+
+      # Section: Rio Interface
+      # gives states the ability to create new rio objects
+      # (should this be here???)
+      def new_rio(arg0,*args,&block)
+        Rio.rio(arg0,*args,&block)
+      end
+      def new_rio_cx(*args)
+        n = new_rio(*args)
+        n.cx = self.cx.bequeath(n.cx)
+        n
+      end
+      def clone_rio()
+        cp = Rio.new(self.rl)
+        cp.cx = self.cx.clone
+        cp.ioh = self.ioh.clone unless self.ioh.nil?
+        cp.rl = self.rl.clone
+        cp
+      end
+      
+      def ensure_rio(arg0)
+        case arg0
+        when RIO::Rio then arg0
+        when RIO::State::Base then arg0.clone_rio
+        else new_rio(arg0)
+        end
+      end
+      def ensure_cmd_rio(arg)
+        case arg
+        when ::String then new_rio(:cmdio,arg)
+        when ::Fixnum then new_rio(arg)
+        when Rio then arg.clone
+        else ensure_rio(arg)
+        end
+      end
+
+      include Symantics
+
+      def callstr(func,*args)
+        self.class.to_s+'['+self.to_url+']'+'.'+func.to_s+'('+args.join(',')+')'
+      end
+
+    end
+
+  end
+
+end # module RIO