wishdev-rio 0.4.3.1

data/lib/rio/ext/zipfile.rb

@@ -0,0 +1,110 @@
+#--
+# =============================================================================== 
+# 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/ext/zipfile/rl'
+module RIO
+  module ZipFile
+    module Cx
+      def zipfile(arg=true,&block)
+        rootdir = new_rio_cx(:zipfile,self.to_s)
+        return rootdir.each(&block) if block_given?
+        rootdir
+      end
+    end
+  end
+end
+module RIO
+  module State
+    class Base
+      include RIO::ZipFile::Cx
+    end
+  end
+end
+__END__
+module RIO
+  module_function
+  def load_lib(lib)
+    begin 
+      require lib
+    rescue LoadError => ex
+      begin
+        p "using Gem for #{lib}" if $DEBUG
+        require 'rubygems'
+        require_gem lib
+      rescue
+        raise ex
+      end
+    end
+  end
+end
+
+begin
+  RIO.load_lib('zip/zip')
+  require 'zip/zipfilesystem'
+  require 'rio/ext/zipfile/opt'
+  RIO::Ext::ZipFile.load_extension
+rescue LoadError
+  p "No zipfile support"  if $DEBUG
+end
+
+
+# module RIO
+#   module Ext
+#     module ZipFile
+#       module Cx
+#         def zipfile(&block) 
+#           #require 'rio/ext/zipfile/state'
+#           cxx('zipfile',true,&block)
+#           #self.extend(ZipFile::State).fstream
+#         end
+#         def zipfile?() cxx?('zipfile') end 
+#         def zipfile_() 
+#           cxx_('zipfile',true) 
+#         end
+#         protected :zipfile_
+
+#         def zipent(&block) 
+#           cxx('zipent',true,&block)
+#         end
+#         def zipent?() cxx?('zipent') end 
+#         def zipent_() 
+#           cxx_('zipent',true) 
+#         end
+#         protected :zipent_
+#       end
+#     end
+#   end
+# end
+__END__

data/lib/rio/ext.rb

@@ -0,0 +1,138 @@
+#--
+# =============================================================================== 
+# 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/ext/csv'
+require 'rio/ext/splitlines'
+require 'rio/ext/yaml'
+#require 'rio/ext/zipfile'
+
+require 'rio/util'
+module RIO
+  module Ext #:nodoc: all
+    @@extensions = {}
+
+    module_function
+    def add(cl,meth)
+      @@extensions[cl] ||= []
+      @@extensions[cl].push(meth)
+    end
+    def extend_state(state_class,ext_module)
+      ext_proc = proc{ |obj| obj.extend(ext_module) }
+      RIO::Ext.add(state_class,ext_proc)
+    end
+
+    def became(obj)
+      if @@extensions[obj.class]
+        @@extensions[obj.class].each { |meth|
+          meth[obj]
+        }
+      end
+    end
+  end
+end
+
+module RIO
+  module Ext #:nodoc: all
+    class Extension
+      def initialize(etest,mod)
+        @inc = { 
+          'cx' => mod+'::Cx',
+          'input' => mod+'::Input',
+          'output' => mod+'::Output',
+        }
+      end
+      def add(obj,state)
+        case state
+          when 'Stream::Input' then obj.extend(@inc['input'])
+          when 'Stream::Output' then obj.extend(@inc['output'])
+        end
+      end
+      
+    end
+  end
+end
+module RIO
+  module Ext #:nodoc: all
+    class Extensions
+      def initialize()
+        #@ext
+        @inc = { 
+          'cx' => mod+'::Cx',
+          'input' => mod+'::Input',
+          'output' => mod+'::Output',
+        }
+      end
+      def add(obj)
+        
+      end
+    end
+  end
+end
+
+
+module RIO
+  module Ext #:nodoc: all
+    OUTPUT_SYMS = Util::build_sym_hash(CSV::Output.instance_methods + YAML::Output.instance_methods)
+
+    module Cx
+      include CSV::Cx
+      include SplitLines::Cx
+      include YAML::Cx
+      #include ZipFile::Cx
+    end
+  end
+  module Ext
+    module Input
+      def add_extensions(obj)
+        obj.extend(CSV::Input) if obj.csv?
+        obj.extend(SplitLines::Input) if obj.splitlines?
+        obj.extend(YAML::Input) if obj.yaml?
+        obj
+      end
+      module_function :add_extensions
+    end
+    module Output
+      def add_extensions(obj)
+        obj.extend(CSV::Output) if obj.csv?
+        obj.extend(SplitLines::Output) if obj.splitlines?
+        obj.extend(YAML::Output) if obj.yaml?
+        obj
+      end
+      module_function :add_extensions
+    end
+  end
+end
+

data/lib/rio/factory.rb

@@ -0,0 +1,436 @@
+#--
+# =============================================================================== 
+# 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
+#
+
+
+# class String
+#  def to_fs
+#    require 'rio/resource'
+#    RIO::Resource::Pathname.new(self)
+#  end
+# end
+require 'singleton'
+require 'rio/handle'
+require 'rio/rl/builder'
+#require 'rio/state/machine'
+
+module RIO
+#   class StateDesc
+#     attr_accessor :class_name,:class_file
+#     def initialize(class_name,class_file)
+#       @class_name = class_name
+#       @class_file = class_file
+#     end
+#   end
+#   module StateMap
+#     class Base
+#       STATE_FILE = {
+#         'Path::Reset' => 'rio/path/reset',
+#         'Path::Empty' => 'rio/path',
+#         'Path::Str' => 'rio/path',
+#         'Path::NonExisting' => 'rio/path',
+        
+#         'File::Existing' => 'rio/file',
+#         'File::NonExisting' => 'rio/file',
+        
+#         'Dir::Existing' => 'rio/dir',
+#         'Dir::Open' => 'rio/dir',
+#         'Dir::Close' => 'rio/dir',
+#         'Dir::Stream' => 'rio/dir',
+#         'Dir::NonExisting' => 'rio/dir',
+        
+#         'Stream::Reset' => 'rio/stream',
+#         'Stream::Open' => 'rio/stream/open',
+#         'Stream::Input' => 'rio/stream',
+#         'Stream::Output' => 'rio/stream',
+#         'Stream::InOut' => 'rio/stream',
+#         'Stream::Close' => 'rio/stream/open',
+#       }
+#       def class_name(state_name)
+#         'State::' + state_name
+#       end
+#       def file_name(state_name)
+#         STATE_FILE[state_name]
+#       end
+#       def path_reset() 'Path::Reset' end
+#       def path_empty() 'Path::Empty' end
+#       def path_str() 'Path::Str' end
+#       def path_nonexisting() 'Path::NonExisting' end
+#       def file_existing() 'File::Existing' end
+#       def file_nonexisting() 'File::NonExisting' end
+#       def dir_existing() 'Dir::Existing' end
+#       def dir_open() 'Dir::Open' end
+#       def dir_close() 'Dir::Close' end
+#       def dir_stream() 'Dir::Stream' end
+#       def dir_nonexisting() 'Dir::NonExisting' end
+#       def stream_reset() 'Stream::Reset' end
+#       def stream_open() 'Stream::Open' end
+#       def stream_input() 'Stream::Input' end
+#       def stream_output() 'Stream::Output' end
+#       def stream_inout() 'Stream::InOut' end
+#       def stream_close() 'Stream::Close' end
+#     end
+#   end
+#   module Path
+#     class StateMap < RIO::StateMap::Base
+#       def stream_open() 'Path::Stream::Open' end
+#     end
+#   end
+#   module Path
+#     class StateMap < RIO::StateMap::Base
+#       STATE_FILE = { 'Stream::Open' => 'rio/scheme/path' }
+#       def stream_open() 'Path::Stream::Open' end
+#     end
+#   end
+#   module CmdPipe
+#     class StateMap < RIO::StateMap::Base
+#       def stream_reset() 'CmdPipe::Stream::reset' end
+#     end
+#   end
+
+#   module States
+#     class Base
+#     end
+#   end
+
+#   class StateMapper
+#     include Singleton
+
+#     STD_STATE_FILES = {
+#       'Path::Reset' => 'rio/path/reset',
+#       'Path::Empty' => 'rio/path',
+#       'Path::Str' => 'rio/path',
+#       'Path::NonExisting' => 'rio/path',
+
+#       'File::Existing' => 'rio/file',
+#       'File::NonExisting' => 'rio/file',
+
+#       'Dir::Existing' => 'rio/dir',
+#       'Dir::Open' => 'rio/dir',
+#       'Dir::Close' => 'rio/dir',
+#       'Dir::Stream' => 'rio/dir',
+#       'Dir::NonExisting' => 'rio/dir',
+
+#       'Stream::Reset' => 'rio/stream',
+#       'Stream::Open' => 'rio/stream/open',
+#       'Stream::Input' => 'rio/stream',
+#       'Stream::Output' => 'rio/stream',
+#       'Stream::InOut' => 'rio/stream',
+#       'Stream::Close' => 'rio/stream/open',
+#     }
+#     SCHEME_STATE_FILES = {
+#       'Stream::Duplex::Open' => 'rio/stream/duplex',
+
+#       #'Path::Stream::Open' => 'rio/scheme/path',
+
+#       #'StrIO::Stream::Open' => 'rio/scheme/strio',
+
+#       #'Null::Stream::Open' => 'rio/scheme/null',
+
+#       #'CmdPipe::Stream::Reset' => 'rio/scheme/cmdpipe',
+
+#       #'HTTP::Stream::Input' => 'rio/scheme/http',
+#       #'HTTP::Stream::Open' => 'rio/scheme/http',
+
+#       'Temp::Reset' => 'rio/scheme/temp',
+#       'Temp::Stream::Open' => 'rio/scheme/temp',
+
+#       'Ext::YAML::Doc::Existing' => 'rio/ext/yaml/doc',
+#       'Ext::YAML::Doc::Open' => 'rio/ext/yaml/doc',
+#       'Ext::YAML::Doc::Stream' => 'rio/ext/yaml/doc',
+#       'Ext::YAML::Doc::Close' => 'rio/ext/yaml/doc',
+#     }
+#     def initialize()
+#       @state_cache = {}
+#     end
+#     def scheme_states()
+#       { 
+#         'path' => { 'Stream::Open' => 'Path::Stream::Open' },
+#         'file' => { 'Stream::Open' => 'Path::Stream::Open' },
+#         'strio' => { 'Stream::Open' => 'StrIO::Stream::Open' },
+#         'cmdpipe' => { 'Stream::Reset' => 'CmdPipe::Stream::Reset' },
+#         'http' => {'Stream::Input' => 'HTTP::Stream::Input', 
+#                    'Stream::Open' => 'HTTP::Stream::Open' },
+#       }
+#     end
+#     def known?(state_name)
+#       STD_STATE_FILES.has_key?(state_name) or SCHEME_STATE_FILES.has_key?(state_name)
+#     end
+#     def std_state_name(state_name)
+#       case 
+#       when STD_STATE_FILES.has_key?(state_name) then 'State::'+state_name
+#       when SCHEME_STATE_FILES.has_key?(state_name) then state_name
+#       else raise ArgumentError,"Unknown State Name (#{state_name})" 
+#       end
+#     end
+#     def mode_mixins()
+#       { 
+#         'Stream::Input' => { 'splitlines' => 'Ext::SplitLines::Stream::Input', },
+#         'Stream::Output' => { 'splitlines' => 'Ext::SplitLines::Stream::Output', },
+#       }
+#     end
+#     def mode_state_name(state_name,cx)
+#       mixins = mode_mixins()
+#       return state_name unless mixins.has_key?(state_name)
+#       modes = mstates[state_name]
+#       for mode in modes.keys
+#         next unless cx[mode]
+#         return modes[mode]
+#       end
+#     end
+
+#     def scheme_state_name(state_name,scheme)
+#       schemes = scheme_states()
+#       if schemes.has_key?(scheme)
+#         states = schemes[scheme]
+#         if states.has_key?(state_name)
+#           return scheme_states[scheme][state_name]
+#         end
+#       end
+#       return std_state_name(state_name)
+#     end
+#     def state_file(state_name,rio_handle)
+#       case 
+#       when STD_STATE_FILES.has_key?(state_name) then STD_STATE_FILES[state_name]
+#       when SCHEME_STATE_FILES.has_key?(state_name) then SCHEME_STATE_FILES[state_name]
+#       else raise ArgumentError,"Unknown State Name (#{state_name})" 
+#       end
+#     end
+#     def state2class(state_name,rio_handle=nil)
+#       scheme = rio_handle.rl.scheme unless rio_handle.nil?
+#       state = nil
+#       if scheme_cache = @state_cache[scheme]
+#         return state if state = scheme_cache[state_name]
+#       end
+#       mapped_name = rio_handle.nil? ? std_state_name(state_name) : scheme_state_name(state_name,rio_handle.rl.scheme)
+#       if self.known?(state_name)
+#         require self.state_file(state_name,rio_handle)
+#         @state_cache[scheme] ||= {}
+#         @state_cache[scheme][state_name] = RIO.module_eval(mapped_name)
+#         return @state_cache[scheme][state_name]
+#       else
+#         raise ArgumentError,"Unknown State Name (#{state_name})" 
+#       end
+#     end
+                   
+#   end
+
+
+  class Factory  #:nodoc: all
+    include Singleton
+    def initialize()
+      @ss_module = {}
+      @reset_class = {}
+      @state_class = {}
+      @ss_class = {}
+    end
+
+    def subscheme_module(sch)
+      #p "subscheme_module(#{sch})"
+      @ss_module[sch] ||= case sch
+                          when 'file','path'
+                            require 'rio/scheme/path'
+                            Path
+                          when 'zipfile'
+                            require 'rio/ext/zipfile/rl'
+                            ZipFile::RootDir
+                          when 'stdio','stdin','stdout'
+                            require 'rio/scheme/stdio'
+                            StdIO
+                          when 'stderr'
+                            require 'rio/scheme/stderr'
+                            StdErr
+                          when 'null'
+                            require 'rio/scheme/null'
+                            Null
+                          when 'tempfile'
+                            require 'rio/scheme/temp'
+                            Temp::File
+                          when 'temp'
+                            require 'rio/scheme/temp'
+                            Temp
+                          when 'tempdir'
+                            require 'rio/scheme/temp'
+                            Temp::Dir
+                          when 'strio','stringio','string'
+                            require 'rio/scheme/strio'
+                            StrIO
+                          when 'cmdpipe'
+                            require 'rio/scheme/cmdpipe'
+                            CmdPipe
+                          when 'aryio'
+                            require 'rio/scheme/aryio'
+                            AryIO
+                          when 'http','https'
+                            require 'rio/scheme/http'
+                            HTTP
+                          when 'ftp'
+                            require 'rio/scheme/ftp'
+                            FTP
+                          when 'tcp'
+                            require 'rio/scheme/tcp'
+                            TCP
+                          when 'sysio'
+                            require 'rio/scheme/sysio'
+                            SysIO
+                          when 'fd'
+                            require 'rio/scheme/fd'
+                            FD
+                          when 'cmdio'
+                            require 'rio/scheme/cmdio'
+                            CmdIO
+                          else
+                            require 'rio/scheme/path'
+                            Path
+                          end
+    end
+
+    STATE2FILE = {
+      'Path::Reset' => 'rio/path/reset',
+      'Path::Empty' => 'rio/path',
+      'Path::Str' => 'rio/path',
+      'Path::NonExisting' => 'rio/path',
+
+      'File::Existing' => 'rio/file',
+      'File::NonExisting' => 'rio/file',
+
+      'Dir::Existing' => 'rio/dir',
+      'Dir::Open' => 'rio/dir',
+      'Dir::Close' => 'rio/dir',
+      'Dir::Stream' => 'rio/dir',
+      'Dir::NonExisting' => 'rio/dir',
+
+      'Stream::Close' => 'rio/stream/open',
+      'Stream::Reset' => 'rio/stream',
+      'Stream::Open' => 'rio/stream/open',
+      'Stream::Input' => 'rio/stream',
+      'Stream::Output' => 'rio/stream',
+      'Stream::InOut' => 'rio/stream',
+
+      'Stream::Duplex::Open' => 'rio/stream/duplex',
+
+      'Path::Stream::Open' => 'rio/scheme/path',
+
+      'StrIO::Stream::Open' => 'rio/scheme/strio',
+
+      'Null::Stream::Open' => 'rio/scheme/null',
+
+      'CmdPipe::Stream::Reset' => 'rio/scheme/cmdpipe',
+
+      'HTTP::Stream::Input' => 'rio/scheme/http',
+      'HTTP::Stream::Open' => 'rio/scheme/http',
+
+      'Temp::Reset' => 'rio/scheme/temp',
+      'Temp::Stream::Open' => 'rio/scheme/temp',
+
+      'Ext::YAML::Doc::Existing' => 'rio/ext/yaml/doc',
+      'Ext::YAML::Doc::Open' => 'rio/ext/yaml/doc',
+      'Ext::YAML::Doc::Stream' => 'rio/ext/yaml/doc',
+      'Ext::YAML::Doc::Close' => 'rio/ext/yaml/doc',
+
+
+    }
+    def riorl_class(sch)
+      subscheme_module(sch).const_get(:RL) 
+    end
+
+    def reset_state(rl)
+      mod = subscheme_module(rl.scheme)
+      mod.const_get(:RESET_STATE) unless mod.nil?
+    end
+
+    def state2class(state_name)
+      return @state_class[state_name] if @state_class.has_key?(state_name)
+      if STATE2FILE.has_key?(state_name)
+        require STATE2FILE[state_name]
+        return @state_class[state_name] = RIO.module_eval(state_name)
+      else
+        raise ArgumentError,"Unknown State Name (#{state_name})" 
+      end
+    end
+    def try_state_proc1(current_state,rio_handle)
+      #p "try_state_proc cur=#{current_state}[#{current_state.class}] han=#{rio_handle}[#{rio_handle.class}]"
+      proc { |new_state_name|
+#        new_state_class = state2class(new_state_name)
+        _change_state(state2class(new_state_name,rio_handle),current_state,rio_handle)
+      }
+    end
+    def try_state_proc(current_state,rio_handle)
+      proc { |new_state_name|
+#        new_state_class = state2class(new_state_name)
+        _change_state(state2class(new_state_name),current_state,rio_handle)
+      }
+    end
+
+    def _change_state(new_state_class,current_state,rio_handle)
+      # wipe out the reference to this proc so GC can get rid of rsc
+      current_state.try_state = proc { p "try_state for "+current_state.to_s+" used already??" }
+      new_state = new_state_class.new_other(current_state)
+      new_state.try_state = try_state_proc(new_state,rio_handle)
+      
+      rio_handle.target = new_state
+      return rio_handle.target
+    end
+    private :_change_state
+
+    # factory creates a state from args
+    def create_state1(*args)
+      riorl = RIO::RL::Builder.build(*args)
+      create_handle(state2class(reset_state(riorl)).new(riorl))
+    end
+    def create_state(*args)
+      riorl = RIO::RL::Builder.build(*args)
+      create_handle(state2class(reset_state(riorl)).new(riorl))
+    end
+    def clone_state(state)
+      create_handle(state.target.clone)
+    end
+    def create_handle(new_state)
+      hndl = Handle.new(new_state)
+      new_state.try_state = try_state_proc(new_state,hndl)
+      hndl
+    end
+
+  end
+end
+
+
+if $0 == __FILE__
+  eval DATA.read, nil, $0, __LINE__+4
+end
+
+__END__
+
+require 'test/unit'
+