wishdev-rio 0.4.3.1

data/lib/rio/ops/stream/input.rb

@@ -0,0 +1,267 @@
+#--
+# =============================================================================== 
+# 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/matchrecord'
+require 'rio/arycopy'
+require 'rio/grande'
+require 'rio/rectype'
+require 'rio/ops/stream/read'
+require 'rio/context/stream'
+require 'stringio'
+require 'rio/cp'
+require 'rio/piper/cp'
+
+
+module RIO
+  module Ops
+    module Stream
+      module Input
+        include Status
+        include Ops::Stream::Read
+        include Enumerable
+        include Grande
+        include Cp::Stream::Input
+        include Piper::Cp::Input
+      end
+    end
+  end
+end
+require 'rio/piper'
+module RIO
+  module Ops
+    module Stream
+      module Input
+        public
+        def each(*args,&block)
+          #p callstr('each',*args)
+          each_(*args,&block)
+          self
+        end
+        def empty?()
+          self.eof?
+        end
+        def each_record(*args,&block)
+          #p callstr('each_record',*args)
+          each_record_(*args,&block)
+          self
+        end
+
+        def each_row(*args,&block) 
+          #p callstr('each_row',*args)
+          rows(*args).each_row_(*args,&block)
+          self
+        end
+
+        def get()
+          until self.eof?
+            raw_rec = self._get_rec
+            return to_rec_(raw_rec) if @get_selrej.match?(raw_rec,@recno)
+          end
+          self.close if closeoneof?
+          nil
+#          (closeoneof? ? self.on_eof_close{ nil } : nil)
+        end
+        def get_type(itertype,&block)
+          old_itertype = cx['stream_itertype']
+          _set_itertype(itertype)
+          begin
+            ans = yield
+          ensure
+            _set_itertype(old_itertype)
+          end
+          ans
+        end
+        def getline()
+          get_type('lines') { get() }
+        end
+        def getrow()
+          get_type('rows') { get() }
+        end
+        def getrec()
+          get_type('records') { get() }
+        end
+        private
+
+        def _ss_like_array(selrej)
+          selrej.only_one_fixnum? and !dir_iter?
+        end
+
+        protected
+
+        # iterate over the records, yielding only with matching records
+        # implemented in terms of an underlying iterator like each_line (see RIO::RecType::*)
+        def each_(*args,&block)
+          selrej,rangetops = create_selrej()
+          want_ma = block.arity > 1
+          catch(:stop_iter) do
+            each_rec_ do |raw_rec|
+              _got_rec(raw_rec)
+              rangetops = check_passed_ranges(selrej,@recno) if rangetops and @recno > rangetops[0]
+              if as = selrej.match?(raw_rec,@recno)
+                if want_ma
+                  yield(to_rec_(raw_rec),as)
+                else
+                  yield(to_rec_(raw_rec))
+                end
+              end
+            end
+            return closeoneof? ? self.close : self
+          end
+          closeoneof? ? self.close : self
+        end
+
+        # iterate over the records, yielding only with matching records
+        # implemented in terms of get_ (see RIO::RecType::*)
+        def each_record_(*args,&block)
+          #p callstr('each_record_',*args)
+
+          selrej,rangetops = self.create_selrej()
+          get_arg = self.get_arg_
+          self.each_record_init_(*args)
+          catch(:stop_iter) {
+            until ior.eof?
+              break unless raw_rec = self._get_rec(get_arg)
+              rangetops = check_passed_ranges(selrej,@recno) if rangetops and @recno > rangetops[0]
+              yield to_rec_(raw_rec) if selrej.match?(raw_rec,@recno)
+            end
+            return self
+          }
+          closeoneof? ? self.close : self
+        end
+        alias :each_row_ :each_
+        def clear_selection()
+          cx.delete('stream_sel')
+          cx.delete('stream_nosel')
+          self
+        end
+        def _get_rec(arg=get_arg_)
+          _got_rec(self.get_(arg))
+        end
+
+        def to_rec_(record)
+          record
+        end
+
+        private
+
+        def _got_rec(el=nil)
+          @recno += 1 unless el.nil?
+          el
+        end
+
+        protected
+
+        def each_record_init_
+        end
+        def handle_skipped
+          return self unless cx.has_key?('skip_args')
+          args = cx['skip_args'] || []
+          self.skiprecords_(*args)
+        end
+        def create_selrej()
+          sel_args = cx['stream_sel']
+          nosel_args = cx['stream_nosel']
+          handle_skipped
+          selrej = RIO::Match::Record::SelRej.new(self,sel_args,nosel_args)
+          [selrej,selrej.rangetops]
+        end
+
+        def check_passed_ranges(selrej,recno)
+          throw :stop_iter if selrej.remove_passed_ranges(recno).never?
+          selrej.rangetops
+        end
+
+        def on_closeoneof()
+          #p "on_closeoneof #{self.object_id} #{self.ior.object_id}"
+          self.close
+        end
+
+        private
+
+        def _ss_keys() Cx::SS::STREAM_KEYS end
+
+        def auto(&block)
+          rewind if autorewind?
+          yield 
+        end
+
+        public
+        
+        def rewind(&block)
+          self.ior.rewind
+          @recno = -1
+          each(&block) if block_given?
+          self
+        end
+
+        def close_read(&block)
+          self.ior.close_read
+          each(&block) if block_given?
+          self
+        end
+
+        def copy_stream(dst)
+          #p callstr('copy_stream',dst)
+          ior.copy_stream(dst)
+          self
+        end
+
+        def recno()
+          return nil unless @recno >= 0
+          @recno
+        end
+
+        def to_h
+          { self.to_s => self.to_a }
+        end
+          
+
+        def each_0(sel,&block)
+          if sel.match_all?
+            each_rec_(&block)
+          else
+            each_rec_ { |rec|
+              next unless mtch = sel.match?(rec,@recno)
+              val = (mtch.kind_of?(::MatchData) && mtch.size > 1 ? mtch.to_a[1...mtch.length] : rec)
+              yield val
+            }
+          end
+          self
+        end
+      end
+    end
+  end
+end

data/lib/rio/ops/stream/output.rb

@@ -0,0 +1,100 @@
+#--
+# =============================================================================== 
+# 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/cp'
+
+module RIO
+  module Impl
+    module U
+      def self.copy_stream(s,d)
+        require 'fileutils'
+        ::FileUtils::copy_stream(s,d)
+      end
+    end
+  end
+end
+module RIO
+  module Ops
+    module Stream
+      module Output
+        include Status
+        require 'rio/ops/stream/write'
+        include Ops::Stream::Write
+        include Cp::Stream::Output
+        def putrec(rec,*args)
+          self.put_(rec,*args)
+          self
+        end
+
+        def putrec!(rec,*args)
+          rtn_close { self.put_(rec,*args) }
+        end
+
+        def close_write(&block)
+          self.iow.close_write
+          each(&block) if block_given?
+          self
+        end
+
+        def wclose
+          self.close.softreset
+        end
+
+        def then_close(*args,&block) 
+          rtn = yield(*args)
+          wclose
+          rtn
+        end
+
+        def rtn_close(*args,&block) 
+          yield(*args)
+          wclose
+        end
+
+        def copyclose()
+          #p "#{callstr('copyclose')} closeoncopy=#{cx['closeoncopy']} iow=#{iow}"
+          #raise RuntimeError,"copclose"
+          if cx['closeoncopy']
+            wclose
+          else
+            self
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/rio/ops/stream/read.rb

@@ -0,0 +1,86 @@
+#--
+# =============================================================================== 
+# 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 Ops
+    module Stream
+      module Read
+
+        private
+
+        def _post_eof_close(&block)
+          rtn = yield
+          self.close if closeoneof?
+          rtn
+        end
+        def _pre_eof_close(&block)
+          begin
+            closit = ior.eof? && closeoneof?
+            rtn = yield
+          ensure
+            self.close if closit
+          end
+          rtn
+        end
+
+        public
+
+        def contents()                  _post_eof_close { ior.gets(nil) || "" }         end
+        def readlines(*args)            _post_eof_close { ior.readlines(*args) }        end
+        def each_line(*args,&block)     
+          _post_eof_close { ior.each_line(*args,&block) } 
+        end
+        def each_byte(*args,&block)     _post_eof_close { ior.each_byte(*args,&block) } end
+        def each_bytes(nb,*args,&block) _post_eof_close { ior.each_bytes(nb,&block) }   end
+
+        def read(*args)                 _pre_eof_close { ior.read(*args) }               end
+        def gets(*args)                 _pre_eof_close { ior.gets(*args) }               end
+        def readline(*args)             _pre_eof_close { ior.readline(*args) }           end
+        def readpartial(*args)          _pre_eof_close { ior.readpartial(*args) }        end
+        def readchar(*args)             _pre_eof_close { ior.readchar(*args) }           end
+        def getc(*args)                 _pre_eof_close { ior.getc(*args) }               end
+
+        def ungetc(*args)
+          ior.ungetc(*args)
+          self
+        end
+        def lineno()     ior.lineno       end
+        def lineno=(arg) ior.lineno = arg end
+      end 
+    end 
+  end
+end