em-files 0.1.1 → 0.2.0

data/README.md

@@ -26,6 +26,37 @@ methods only, so for special operations use simply:
     EM::File::open("some_file.txt", "r") do |io|
         io.native   # returns native Ruby File class object
     end
+    
+### Special Uses
+
+It's possible to use also another IO objects than `File` object by 
+giving appropriate IO instance instead of filename to methods:
+
+    require "em-files"
+    require "stringio"
+    
+    io = StringIO::new
+    
+    EM::run do
+        EM::File::open(io) do |io|
+            # some multiplexed operations
+        end
+    end
+    
+By this way you can also perform for example more time consuming
+operations by simple way (if they can be processed in block manner) 
+using filters:
+
+    require "em-files"
+    require "zlib"
+
+    zip = Zlib::Deflate::new
+    filter = Proc::new { |chunk| zip.deflate(chunk, Zlib::SYNC_FLUSH) }
+    data = "..."    # some bigger than big data
+    
+    EM::run do
+        EM::File::write(data, filter)   # done in several ticks
+    end
 
     
 Contributing

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.2.0

data/em-files.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{em-files}
-  s.version = "0.1.1"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Martin Kozák"]
-  s.date = %q{2011-03-09}
+  s.date = %q{2011-03-19}
   s.email = %q{martinkozak@martinkozak.net}
   s.extra_rdoc_files = [
     "LICENSE.txt",

data/lib/em-files.rb

@@ -15,6 +15,12 @@ module EM
     #
     
     class File
+    
+        ##
+        # Holds the default size of block operated during one tick.
+        #
+        
+        RWSIZE = 65536
 
         ##
         # Opens the file.
@@ -31,7 +37,9 @@ module EM
         # @return [File] file access object
         #
 
-        def self.open(filepath, mode = "r", rwsize = 65536, &block)   # 64 kilobytes
+        def self.open(filepath, mode = "r", rwsize = self::RWSIZE, &block)   # 64 kilobytes
+            rwsize = self::RWSIZE if rwsize.nil?
+            
             file = self::new(filepath, mode, rwsize)
             if not block.nil?
                 block.call(file)
@@ -42,38 +50,47 @@ module EM
         
         ##
         # Reads whole content of the file. Be warn, it reads it in 
-        # binary mode.
+        # binary mode. If IO object is given instead of filepath, uses 
+        # it as native one and +mode+ argument is ignored.
         #
         # @param [String] filepath path to file
         # @param [Integer] rwsize size of block operated during one tick
+        # @param [Proc] filter filter which for postprocessing each 
+        #   read chunk
         # @param [Proc] block block for giving back the result
         #
         
         
-        def self.read(filepath, rwsize = 65536, &block)
+        def self.read(filepath, rwsize = self::RWSIZE, filter = nil, &block)
+            rwsize = self::RWSIZE if rwsize.nil?
             self::open(filepath, "rb", rwsize) do |io|
-                io.read do |out|
-                    block.call(out)
+                io.read(nil, filter) do |out|
                     io.close()
+                    block.call(out)
                 end
             end
         end
         
         ##
-        # Writes data to file and closes it. Writes them in binary mode.
+        # Writes data to file and closes it. Writes them in binary mode. 
+        # If IO object is given instead of filepath, uses it as native 
+        # one and +mode+ argument is ignored.
         #
         # @param [String] filepath path to file
         # @param [String] data data for write
         # @param [Integer] rwsize size of block operated during one tick
+        # @param [Proc] filter filter which for preprocessing each 
+        #   written chunk
         # @param [Proc] block block called when writing is finished with
         #   written bytes size count as parameter
         #
         
-        def self.write(filepath, data = "", rwsize = 65536, &block)
+        def self.write(filepath, data = "", rwsize = self::RWSIZE, filter = nil, &block)
+            rwsize = self::RWSIZE if rwsize.nil?
             self::open(filepath, "wb", rwsize) do |io|
-                io.write(data) do |length|
-                    block.call(length)
+                io.write(data, filter) do |length|
                     io.close()
+                    block.call(length)
                 end
             end
         end
@@ -82,7 +99,7 @@ module EM
         
         ##
         # Holds file object.
-        # @return [::File]
+        # @return [IO]
         #
         
         attr_accessor :native
@@ -97,32 +114,64 @@ module EM
         @rw_len
         
         ##
-        # Constructor.
+        # Holds mode of the object.
+        # @return [String]
         #
-        # @param [String] filepath path to file
+        
+        attr_reader :mode
+        @mode
+        
+        ##
+        # Constructor. If IO object is given instead of filepath, uses 
+        # it as native one and +mode+ argument is ignored.
+        #
+        # @param [String, IO] filepath path to file or IO object
         # @param [String] mode file access mode (see equivalent Ruby method)
         # @param [Integer] rwsize size of block operated during one tick
         #
                 
-        def initialize(filepath, mode = "r", rwsize = 65536)
-            @native = ::File::open(filepath, mode)
+        def initialize(filepath, mode = "r", rwsize = self.class::RWSIZE)
+            @mode = mode
             @rw_len = rwsize
+            
+            rwsize = self::RWSIZE if rwsize.nil?
+            
+            # If filepath is directly IO, uses it
+            if filepath.kind_of? IO
+                @native = filepath
+            else
+                @native = ::File::open(filepath, mode)
+            end
+            
         end
 
         ##
         # Reads data from file.
         #
+        # It will reopen the file if +EBADF: Bad file descriptor+ of 
+        # +File+ class IO object will occur.
+        #
         # @overload read(length, &block)
         #   Reads specified amount of data from file.
         #   @param [Integer] length length for read from file
+        #   @param [Proc] filter filter which for postprocessing each 
+        #       read chunk
         #   @param [Proc] block callback for returning the result
         # @overload read(&block)
         #   Reads whole content of file.
+        #   @param [Proc] filter filter which for processing each block
         #   @param [Proc] block callback for returning the result
         #
         
-        def read(length = nil, &block)
+        def read(length = nil, filter = nil, &block)
             buffer = ""
+            pos = 0
+            
+            # Arguments
+            if length.kind_of? Proc
+                filter = length
+            end
+            
             
             worker = Proc::new do
             
@@ -137,7 +186,23 @@ module EM
                 end
                 
                 # Reads
-                buffer << @native.read(rlen)
+                begin
+                    chunk = @native.read(rlen)
+                    if not filter.nil?
+                        chunk = filter.call(chunk)
+                    end
+                    buffer << chunk
+                rescue Errno::EBADF
+                    if @native.kind_of? ::File
+                        self.reopen!
+                        @native.seek(pos)
+                        redo
+                    else
+                        raise
+                    end
+                end
+                
+                pos = @native.pos
                 
                 # Returns or continues work
                 if @native.eof? or (buffer.length == length)
@@ -153,22 +218,52 @@ module EM
             worker.call()
         end
         
+        ##
+        # Reopens the file with the original mode.
+        #
+        
+        def reopen!
+            @native = ::File.open(@native.path, @mode)
+        end
+        
         ##
         # Writes data to file.
         #
+        # It will reopen the file if +EBADF: Bad file descriptor+ of 
+        # +File+ class IO object will occur.
+        #
         # @param [String] data data for write
+        # @param [Proc] filter filter which for preprocessing each 
+        #   written chunk
         # @param [Proc] block callback called when finish and for giving
         #   back the length of written data
         #
         
-        def write(data, &block)
+        def write(data, filter = nil, &block)
             written = 0
+            pos = 0
             
             worker = Proc::new do
             
                 # Writes
-                written += @native.write(data[written...(written + @rw_len)])
+                begin
+                    chunk = data[written...(written + @rw_len)]
+                    if not filter.nil?
+                        chunk = filter.call(chunk)
+                    end
+                    written += @native.write(chunk)
+                rescue Errno::EBADF
+                    if @native.kind_of? File
+                        self.reopen!
+                        @native.seek(pos)
+                        redo
+                    else
+                        raise
+                    end
+                end
             
+                pos = @native.pos
+                
                 # Returns or continues work
                 if written >= data.bytesize
                     if not block.nil?

metadata

@@ -2,7 +2,7 @@
 name: em-files
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors: 
 - "Martin Koz\xC3\xA1k"
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-09 00:00:00 +01:00
+date: 2011-03-19 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -91,7 +91,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 50982926357626224
+      hash: -3958276784463008069
       segments: 
       - 0
       version: "0"