ruby-xz 0.0.1 → 0.1.0

data/HISTORY.rdoc

@@ -0,0 +1,6 @@
+== 0.1.0
+
+* <b>Add XZ::StreamReader and XZ::StreamWriter for io-like behaviour.</b>
+* New dependency on the +io-like+ gem.
+* <b>Add Ruby 1.8 compatibility.</b> Thanks to Christoph Plank.
+* We now have proper unit tests.

data/README.rdoc

@@ -7,12 +7,24 @@ you the possibility of creating and extracting XZ archives on any platform
 where liblzma is installed. No compilation is needed, because ruby-xz is
 written ontop of ffi[https://github.com/ffi/ffi].
 
+ruby-xz supports both "intuitive" (de)compression by providing methods to
+directly operate on strings and files, but also allows you to operate
+directly on IO streams (see the various methods of the XZ module). On top
+of that, ruby-xz offers an advanced interface that allows you to treat
+XZ-compressed data as IO streams, both for reading and for writing. See the
+XZ::StreamReader and XZ::StreamWriter classes for more information on this.
+
 == Installation
 
 Install it the way you install all your gems.
 
   # gem install ruby-xz
 
+Although it is designed for Ruby 1.9 (which I highly recommend),
+ruby-xz should also work with Ruby 1.8.7. However, the Ruby 1.8
+compatibility may be skipped anytime (causing at least a minor version
+bump), so you shouldn’t rely on it.
+
 == Usage
 
 The documentation of the XZ module is well and you should be able to find
@@ -54,7 +66,9 @@ what is possible.
 
 Basic liblzma-bindings for Ruby.
 
-Copyright © 2011 Marvin Gülker
+Copyright © 2011,2012 Marvin Gülker
+
+Copyright © 2011 Christoph Plank
 
 Permission is hereby granted, free of charge, to any person obtaining a
 copy of this software and associated documentation files (the ‘Software’),
@@ -72,4 +86,36 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
+THE SOFTWARE.
+
+==== require_relative
+
+This library includes the sourcecode of Steve Klabnik’s
+{require_relative gem}[http://steveklabnik.github.com/require_relative/]
+in order to make it 1.8-compatible. It’s licensed under the BSD license:
+
+Copyright (c) 2011, Steve Klabnik
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/xz.rb

@@ -1,167 +1,113 @@
-#Encoding: UTF-8
-=begin (The MIT License)
+# -*- coding: utf-8 -*-
+# (The MIT License)
+# 
+# Basic liblzma-bindings for Ruby.
+# 
+# Copyright © 2011,2012 Marvin Gülker
+# Copyright © 2011 Christoph Plank
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the ‘Software’),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the Software
+# is furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED ‘AS IS’, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
 
-Basic liblzma-bindings for Ruby.
+if RUBY_VERSION < "1.9"
+  require "rubygems"
+  
+  # The following is the complete sourcode of the require_relative gem
+  # by Steve Klabnik, licensed under the BSD license:
+  #
+  # Copyright (c) 2011, Steve Klabnik
+  # All rights reserved.
+  #
+  # Redistribution and use in source and binary forms, with or without
+  # modification, are permitted provided that the following conditions are
+  # met:
+  #
+  # * Redistributions of source code must retain the above copyright
+  #   notice, this list of conditions and the following disclaimer.
+  # * Redistributions in binary form must reproduce the above copyright
+  #   notice, this list of conditions and the following disclaimer in the
+  #   documentation and/or other materials provided with the distribution.
+  #
+  # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+  # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+  # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+  # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+  # HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+  # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+  # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+  # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+  # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+  # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+  # require\_relative has no effect on Ruby 1.9 (or other versions that provide Kernel#require_relative
+  # out of the box)
+  unless Object.new.respond_to?(:require_relative, true)
+    # Yep, you're looking at it! This gem is pretty small, and for good reason.
+    # There's not much to do! We use split to find the filename that we're
+    # looking to require, raise a LoadError if it's called in a context (like eval)
+    # that it shouldn't be, and then require it via regular old require.
+    #
+    # Now, in 1.9, "." is totally removed from the $LOAD_PATH. We don't do that
+    # here, because that would break a lot of other code! You're still vulnerable
+    # to the security hole that caused this change to happen in the first place.
+    # You will be able to use this gem to transition the code you write over to
+    # the 1.9 syntax, though.
+    def require_relative(relative_feature) # :nodoc:
 
-Copyright © 2011 Marvin Gülker
+      file = caller.first.split(/:\d/,2).first
 
-Permission is hereby granted, free of charge, to any person obtaining a
-copy of this software and associated documentation files (the ‘Software’),
-to deal in the Software without restriction, including without limitation
-the rights to use, copy, modify, merge, publish, distribute, sublicense,
-and/or sell copies of the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following conditions:
+      raise LoadError, "require_relative is called in #{$1}" if /\A\((.*)\)/ =~ file
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+      require File.expand_path(relative_feature, File.dirname(file))
+    end
+  end
 
-THE SOFTWARE IS PROVIDED ‘AS IS’, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-=end
+  unless String.instance_methods.include?(:clear)
+    class String # :nodoc:
+      def clear
+        replace("")
+      end
+    end
+  end
+end
 
+require "pathname"
 require "ffi"
+require 'stringio'
+require "io/like"
 
 #The namespace and main module of this library. Each method of this module
 #may raise exceptions of class XZ::LZMAError, which is not named in the
 #methods' documentations anymore.
+#
+#All strings you receive from any method defined in this module
+#and the classes defined in it are encoded in BINARY, so you may
+#have to call #force_encoding on them to tag them with the correct
+#encoding (assuming you _know_ what their correct encoding should be).
+#ruby-xz can’t handle this as compiled strings don’t come with encoding
+#information.
 module XZ
   
-  #This module wraps functions and enums used by liblzma.
-  module LibLZMA
-    extend FFI::Library
-    
-    #The maximum value of an uint64_t, as defined by liblzma.
-    #Should be the same as
-    #  (2 ** 64) - 1
-    UINT64_MAX = 18446744073709551615
-    
-    #Activates extreme compression. Same as xz's "-e" commandline switch.
-    LZMA_PRESET_EXTREME = 1 << 31
-    
-    LZMA_TELL_NO_CHECK = 0x02
-    LZMA_TELL_UNSUPPORTED_CHECK = 0x02
-    LZMA_TELL_ANY_CHECK = 0x04
-    LZMA_CONCATENATED = 0x08
-    
-    #Placeholder enum used by liblzma for later additions.
-    LZMA_RESERVED_ENUM = enum :lzma_reserved_enum, 0
-    
-    #Actions that can be passed to the lzma_code() function.
-    LZMA_ACTION = enum  :lzma_run, 0,
-                        :lzma_sync_flush,
-                        :lzma_full_flush,
-                        :lzma_finish
-                        
-    #Integrity check algorithms supported by liblzma.
-    LZMA_CHECK = enum :lzma_check_none, 0,
-                      :lzma_check_crc32, 1,
-                      :lzma_check_crc64, 4,
-                      :lzma_check_sha256, 10
-                      
-    #Possible return values of liblzma functions.
-    LZMA_RET = enum :lzma_ok, 0,
-                    :lzma_stream_end,
-                    :lzma_no_check,
-                    :lzma_unsupported_check,
-                    :lzma_get_check,
-                    :lzma_mem_error,
-                    :lzma_memlimit_error,
-                    :lzma_format_error,
-                    :lzma_options_error,
-                    :lzma_data_error,
-                    :lzma_buf_error,
-                    :lzma_prog_error
-    
-    ffi_lib "liblzma"
-    
-    attach_function :lzma_easy_encoder, [:pointer, :uint32, :int], :int
-    attach_function :lzma_code, [:pointer, :int], :int
-    attach_function :lzma_stream_decoder, [:pointer, :uint64, :uint32], :int
-    attach_function :lzma_end, [:pointer], :void
-    
-  end
-  
-  #The class of the error that this library raises.
-  class LZMAError < StandardError
-    
-    #Raises an appropriate exception if +val+ isn't a liblzma success code.
-    def self.raise_if_necessary(val)
-      case val
-      when :lzma_mem_error then raise(self, "Couldn't allocate memory!")
-      when :lzma_memlimit_error then raise(self, "Decoder ran out of (allowed) memory!")
-      when :lzma_format_error then raise(self, "Unrecognized file format!")
-      when :lzma_options_error then raise(self, "Invalid options passed!")
-      when :lzma_data_error then raise raise(self, "Archive is currupt.")
-      when :lzma_buf_error then raise(self, "Buffer unusable!")
-      when :lzma_prog_error then raise(self, "Program error--if you're sure your code is correct, you may have found a bug in liblzma.")
-      end
-    end
-    
-  end
-  
-  #The main struct of the liblzma library.
-  class LZMAStream < FFI::Struct
-    layout  :next_in, :pointer, #uint8
-            :avail_in, :size_t,
-            :total_in, :uint64,
-            :next_out, :pointer, #uint8
-            :avail_out, :size_t,
-            :total_out, :uint64,
-            :lzma_allocator, :pointer,
-            :lzma_internal, :pointer,
-            :reserved_ptr1, :pointer,
-            :reserved_ptr2, :pointer,
-            :reserved_ptr3, :pointer,
-            :reserved_ptr4, :pointer,
-            :reserved_int1, :uint64,
-            :reserved_int2, :uint64,
-            :reserved_int3, :size_t,
-            :reserved_int4, :size_t,
-            :reserved_enum1, :int,
-            :reserved_enum2, :int
-            
-            #This method does basicly the same thing as the
-            #LZMA_STREAM_INIT macro of liblzma. Creates a new LZMAStream
-            #that has been initialized for usage. If any argument is passed,
-            #it is assumed to be a FFI::Pointer to a lzma_stream structure
-            #and that structure is wrapped.
-            def initialize(*args)
-              if args.empty? #Got a pointer, want to wrap it
-                super
-              else
-                s = super()
-                s[:next] = nil
-                s[:avail_in] = 0
-                s[:total_in] = 0
-                s[:next_out] = nil
-                s[:avail_out] = 0
-                s[:total_out] = 0
-                s[:lzma_allocator] = nil
-                s[:lzma_internal] = nil
-                s[:reserved_ptr1] = nil
-                s[:reserved_ptr2] = nil
-                s[:reserved_ptr3] = nil
-                s[:reserved_ptr4] = nil
-                s[:reserved_int1] = 0
-                s[:reserved_int2] = 0
-                s[:reserved_int3] = 0
-                s[:reserved_int4] = 0
-                s[:reserved_enum1] = LibLZMA::LZMA_RESERVED_ENUM[:lzma_reserved_enum]
-                s[:reserved_enum2] = LibLZMA::LZMA_RESERVED_ENUM[:lzma_reserved_enum]
-                s
-              end
-            end
-          end
   
   #Number of bytes read in one chunk.
   CHUNK_SIZE = 4096
   #The version of this library.
-  VERSION = "0.0.1".freeze
+  VERSION = Pathname.new(__FILE__).dirname.expand_path.parent.join("VERSION").read.chomp.freeze
   
   class << self
     
@@ -179,7 +125,7 @@ module XZ
     #[flags]        (<tt>[:tell_unsupported_check]</tt>) Additional flags
     #               passed to liblzma (an array). Possible flags are:
     #               [:tell_no_check] Spit out a warning if the archive hasn't an
-    #                                itnegrity checksum.
+    #                                integrity checksum.
     #               [:tell_unsupported_check] Spit out a warning if the archive
     #                                         has an unsupported checksum type.
     #               [:concatenated] Decompress concatenated archives.
@@ -199,7 +145,7 @@ module XZ
     #The block form is *much* better on memory usage, because it doesn't have
     #to load everything into RAM at once. If you don't know how big your
     #data gets or if you want to decompress much data, use the block form. Of
-    #course you shouldn't store the data your read in RAM then as in the
+    #course you shouldn't store the data you read in RAM then as in the
     #example above.
     def decompress_stream(io, memory_limit = LibLZMA::UINT64_MAX, flags = [:tell_unsupported_check], &block)
       raise(ArgumentError, "Invalid memory limit set!") unless (0..LibLZMA::UINT64_MAX).include?(memory_limit)
@@ -211,12 +157,13 @@ module XZ
       res = LibLZMA.lzma_stream_decoder(
         stream.pointer,
         memory_limit,
-        flags.inject(0){|val, flag| val | LibLZMA.const_get(:"LZMA_#{flag.upcase}")}
+        flags.inject(0){|val, flag| val | LibLZMA.const_get(:"LZMA_#{flag.to_s.upcase}")}
       )
       
       LZMAError.raise_if_necessary(res)
       
       res = ""
+      res.encode!("BINARY") if RUBY_VERSION >= "1.9"
       if block_given?
         res = lzma_code(io, stream, &block)
       else
@@ -274,15 +221,14 @@ module XZ
       raise(ArgumentError, "Invalid checksum specified!") unless [:none, :crc32, :crc64, :sha256].include?(check)
       
       stream = LZMAStream.new
-      res = LibLZMA.lzma_easy_encoder(
-      stream.pointer,
-      compression_level | (extreme ? LibLZMA::LZMA_PRESET_EXTREME : 0),
-      LibLZMA::LZMA_CHECK[:"lzma_check_#{check}"]
-      )
+      res = LibLZMA.lzma_easy_encoder(stream.pointer,
+                                      compression_level | (extreme ? LibLZMA::LZMA_PRESET_EXTREME : 0),
+                                      LibLZMA::LZMA_CHECK[:"lzma_check_#{check}"])
       
       LZMAError.raise_if_necessary(res)
       
       res = ""
+      res.encode!("BINARY") if RUBY_VERSION >= "1.9"
       if block_given?
         res = lzma_code(io, stream, &block)
       else
@@ -300,7 +246,7 @@ module XZ
     #[in_file]  The path to the file to read from.
     #[out_file] The path of the file to write to. If it exists, it will be
     #           overwritten.
-    #For the other parameters, see the compress_stream method.
+    #For the other parameters, see the ::compress_stream method.
     #===Return value
     #The number of bytes written, i.e. the size of the archive.
     #===Example
@@ -385,7 +331,11 @@ module XZ
     def binary_size(str)
       #Believe it or not, but this is faster than str.bytes.to_a.size.
       #I benchmarked it, and it is as twice as fast.
-      str.dup.force_encoding("BINARY").size
+      if str.respond_to? :force_encoding
+        str.dup.force_encoding("BINARY").size
+      else
+        str.bytes.to_a.size
+      end
     end
     
     #This method does the heavy work of (de-)compressing a stream. It takes
@@ -396,16 +346,16 @@ module XZ
     #(de-)compressing of very large files that can't be loaded fully into
     #memory.
     def lzma_code(io, stream)
-      input_buffer_p = FFI::MemoryPointer.new(CHUNK_SIZE)
+      input_buffer_p  = FFI::MemoryPointer.new(CHUNK_SIZE)
       output_buffer_p = FFI::MemoryPointer.new(CHUNK_SIZE)
       
       while str = io.read(CHUNK_SIZE)
         input_buffer_p.write_string(str)
         
         #Set the data for compressing
-        stream[:next_in] = input_buffer_p
+        stream[:next_in]  = input_buffer_p
         stream[:avail_in] = binary_size(str)
-        
+
         #Now loop until we gathered all the data in stream[:next_out]. Depending on the
         #amount of data, this may not fit into the buffer, meaning that we have to
         #provide a pointer to a "new" buffer that liblzma can write into. Since
@@ -413,10 +363,10 @@ module XZ
         #lzma_code() function doesn't hurt (indeed the pipe_comp example from
         #liblzma handles it this way too). Sometimes it happens that the compressed data
         #is bigger than the original (notably when the amount of data to compress
-        #is small)
+        #is small).
         loop do
           #Prepare for getting the compressed_data
-          stream[:next_out] = output_buffer_p
+          stream[:next_out]  = output_buffer_p
           stream[:avail_out] = CHUNK_SIZE
           
           #Compress the data
@@ -444,9 +394,9 @@ module XZ
     def check_lzma_code_retval(code)
       e = LibLZMA::LZMA_RET
       case code
-      when e[:lzma_no_check] then warn("Couldn't verify archive integrity--archive has not integrity checksum.")
+      when e[:lzma_no_check]          then warn("Couldn't verify archive integrity--archive has not integrity checksum.")
       when e[:lzma_unsupported_check] then warn("Couldn't verify archive integrity--archive has an unsupported integrity checksum.")
-      when e[:lzma_get_check] then nil #This isn't useful for us. It indicates that the checksum type is now known.
+      when e[:lzma_get_check]         then nil #This isn't useful for us. It indicates that the checksum type is now known.
       else
         LZMAError.raise_if_necessary(code)
       end
@@ -455,3 +405,8 @@ module XZ
   end #class << self
   
 end
+
+require_relative "xz/lib_lzma"
+require_relative "xz/stream"
+require_relative "xz/stream_writer"
+require_relative "xz/stream_reader"

data/lib/xz/lib_lzma.rb

@@ -0,0 +1,155 @@
+# -*- coding: utf-8 -*-
+# The MIT License
+#
+# Basic liblzma-bindings for Ruby.
+#
+# Copyright © 2011 Marvin Gülker
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the ‘Software’),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the Software
+# is furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED ‘AS IS’, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+module XZ
+  
+  #This module wraps functions and enums used by liblzma.
+  module LibLZMA
+    extend FFI::Library
+    
+    #The maximum value of an uint64_t, as defined by liblzma.
+    #Should be the same as
+    #  (2 ** 64) - 1
+    UINT64_MAX = 18446744073709551615
+    
+    #Activates extreme compression. Same as xz's "-e" commandline switch.
+    LZMA_PRESET_EXTREME = 1 << 31
+    
+    LZMA_TELL_NO_CHECK          = 0x02
+    LZMA_TELL_UNSUPPORTED_CHECK = 0x02
+    LZMA_TELL_ANY_CHECK         = 0x04
+    LZMA_CONCATENATED           = 0x08
+    
+    #Placeholder enum used by liblzma for later additions.
+    LZMA_RESERVED_ENUM = enum :lzma_reserved_enum, 0
+    
+    #Actions that can be passed to the lzma_code() function.
+    LZMA_ACTION = enum  :lzma_run, 0,
+    :lzma_sync_flush,
+    :lzma_full_flush,
+    :lzma_finish
+    
+    #Integrity check algorithms supported by liblzma.
+    LZMA_CHECK = enum :lzma_check_none,   0,
+    :lzma_check_crc32,  1,
+    :lzma_check_crc64,  4,
+    :lzma_check_sha256, 10
+    
+    #Possible return values of liblzma functions.
+    LZMA_RET = enum :lzma_ok, 0,
+    :lzma_stream_end,
+    :lzma_no_check,
+    :lzma_unsupported_check,
+    :lzma_get_check,
+    :lzma_mem_error,
+    :lzma_memlimit_error,
+    :lzma_format_error,
+    :lzma_options_error,
+    :lzma_data_error,
+    :lzma_buf_error,
+    :lzma_prog_error
+    
+    ffi_lib ['lzma.so.2', 'lzma.so', 'lzma']
+    
+    attach_function :lzma_easy_encoder, [:pointer, :uint32, :int], :int
+    attach_function :lzma_code, [:pointer, :int], :int
+    attach_function :lzma_stream_decoder, [:pointer, :uint64, :uint32], :int
+    attach_function :lzma_end, [:pointer], :void
+    
+  end
+
+  #The class of the error that this library raises.
+  class LZMAError < StandardError
+    
+    #Raises an appropriate exception if +val+ isn't a liblzma success code.
+    def self.raise_if_necessary(val)
+      case LibLZMA::LZMA_RET[val]
+      when :lzma_mem_error      then raise(self, "Couldn't allocate memory!")
+      when :lzma_memlimit_error then raise(self, "Decoder ran out of (allowed) memory!")
+      when :lzma_format_error   then raise(self, "Unrecognized file format!")
+      when :lzma_options_error  then raise(self, "Invalid options passed!")
+      when :lzma_data_error     then raise(self, "Archive is currupt.")
+      when :lzma_buf_error      then raise(self, "Buffer unusable!")
+      when :lzma_prog_error     then raise(self, "Program error--if you're sure your code is correct, you may have found a bug in liblzma.")
+      end
+    end
+    
+  end
+
+  #The main struct of the liblzma library.
+  class LZMAStream < FFI::Struct
+    layout :next_in, :pointer, #uint8
+    :avail_in, :size_t,
+    :total_in, :uint64,
+    :next_out, :pointer, #uint8
+    :avail_out, :size_t,
+    :total_out, :uint64,
+    :lzma_allocator, :pointer,
+    :lzma_internal, :pointer,
+    :reserved_ptr1, :pointer,
+    :reserved_ptr2, :pointer,
+    :reserved_ptr3, :pointer,
+    :reserved_ptr4, :pointer,
+    :reserved_int1, :uint64,
+    :reserved_int2, :uint64,
+    :reserved_int3, :size_t,
+    :reserved_int4, :size_t,
+    :reserved_enum1, :int,
+    :reserved_enum2, :int
+    
+    #This method does basicly the same thing as the
+    #LZMA_STREAM_INIT macro of liblzma. Creates a new LZMAStream
+    #that has been initialized for usage. If any argument is passed,
+    #it is assumed to be a FFI::Pointer to a lzma_stream structure
+    #and that structure is wrapped.
+    def initialize(*args)
+      if args.empty? #Got a pointer, want to wrap it
+        super
+      else
+        s = super()
+        s[:next]           = nil
+        s[:avail_in]       = 0
+        s[:total_in]       = 0
+        s[:next_out]       = nil
+        s[:avail_out]      = 0
+        s[:total_out]      = 0
+        s[:lzma_allocator] = nil
+        s[:lzma_internal]  = nil
+        s[:reserved_ptr1]  = nil
+        s[:reserved_ptr2]  = nil
+        s[:reserved_ptr3]  = nil
+        s[:reserved_ptr4]  = nil
+        s[:reserved_int1]  = 0
+        s[:reserved_int2]  = 0
+        s[:reserved_int3]  = 0
+        s[:reserved_int4]  = 0
+        s[:reserved_enum1] = LibLZMA::LZMA_RESERVED_ENUM[:lzma_reserved_enum]
+        s[:reserved_enum2] = LibLZMA::LZMA_RESERVED_ENUM[:lzma_reserved_enum]
+        s
+      end
+    end
+  end
+
+end

data/lib/xz/stream.rb

@@ -0,0 +1,67 @@
+# -*- coding: utf-8 -*-
+# (The MIT license)
+#
+# Basic liblzma-bindings for Ruby.
+# 
+# Copyright © 2012 Marvin Gülker
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the ‘Software’),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the Software
+# is furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED ‘AS IS’, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+#The base class for XZ::StreamReader and XZ::StreamWriter.
+#This is an abstract class that is not meant to be used
+#directly; if you try, you will soon recognise that you’ve
+#created a quite limited object ;-). You can, however, test
+#against this class in <tt>kind_of?</tt> tests.
+#
+#XZ::StreamReader and XZ::StreamWriter are IO-like classes that
+#allow you to access XZ-compressed data the same way you access
+#an IO-object, easily allowing to fool other libraries that expect
+#IO objects. The most noticable example for this may be reading
+#and writing XZ-compressed tarballs; see XZ::StreamReader and
+#XZ::StreamWriter for respective examples.
+#
+#Neither this class nor its subclasses document the IO-methods
+#they contain--this is due to the reason that they include the
+#great IO::Like module that provides all the necessary IO methods
+#based on a few methods you define. For all defined IO methods,
+#see the +io-like+ gem’s documentation.
+class XZ::Stream
+  include IO::Like
+
+  #Creates a new instance of this class. Don’t use this directly,
+  #it’s only called by subclasses’ ::new methods.
+  def initialize(delegate_io)
+    @delegate_io    = delegate_io
+    @lzma_stream    = XZ::LZMAStream.new
+  end
+
+  private
+
+  #This method returns the size of +str+ in bytes.
+  def binary_size(str)
+    #Believe it or not, but this is faster than str.bytes.to_a.size.
+    #I benchmarked it, and it is as twice as fast.
+    if str.respond_to? :force_encoding
+      str.dup.force_encoding("BINARY").size
+    else
+      str.bytes.to_a.size
+    end
+  end
+
+end

data/lib/xz/stream_reader.rb

@@ -0,0 +1,285 @@
+# -*- coding: utf-8 -*-
+# (The MIT license)
+#
+# Basic liblzma-bindings for Ruby.
+# 
+# Copyright © 2012 Marvin Gülker
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the ‘Software’),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the Software
+# is furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED ‘AS IS’, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+#An IO-like reader class for XZ-compressed data, allowing you to
+#access XZ-compressed data as if it was a normal IO object, but
+#please note you can’t seek in the data--this doesn’t make much
+#sense anyway. Where would you want to seek? The plain or the XZ
+#data?
+#
+#A StreamReader object actually wraps another IO object it reads
+#the compressed data from; you can either pass this IO object directly
+#to the ::new method, effectively allowing you to pass any IO-like thing
+#you can imagine (just ensure it is readable), or you can pass a path
+#to a filename to ::new, in which case StreamReader takes care of both
+#opening and closing the file correctly. You can even take it one step
+#further and use the block form of ::new which will automatically call
+#the #close method for you after the block finished. However, if you pass
+#an IO, remember you have to close:
+#
+#1. The StreamReader instance.
+#2. The IO object you passed to ::new.
+#
+#Do it <b>in exactly that order</b>, otherwise you may lose data.
+#
+#See the +io-like+ gem’s documentation for the IO-reading methods
+#available for this class (although you’re probably familiar with
+#them through Ruby’s own IO class ;-)).
+#
+#==Example
+#In this example, we’re going to use ruby-xz together with the
+#+archive-tar-minitar+ gem that allows to read tarballs. Used
+#together, the two libraries allow us to read XZ-compressed tarballs.
+#
+#  require "xz"
+#  require "archive/tar/minitar"
+#  
+#  XZ::StreamReader.open("foo.tar.xz") do |txz|
+#    # This automatically closes txz
+#    Archive::Tar::Minitar.unpack(txz, "foo")
+#  end
+class XZ::StreamReader < XZ::Stream
+
+  #The memory limit you set for this reader (in ::new).
+  attr_reader :memory_limit
+  #The flags you set for this reader (in ::new).
+  attr_reader :flags
+
+  #call-seq:
+  #  new(delegate, memory_limit = XZ::LibLZMA::UINT64_MAX, flags = [:tell_unsupported_check])  → a_stream_reader
+  #  open(delegate, memory_limit = XZ::LibLZMA::UINT64_MAX, flags = [:tell_unsupported_check]) → a_stream_reader
+  #
+  #Creates a new StreamReader instance. If you pass an IO,
+  #remember you have to close *both* the resulting instance
+  #(via the #close method) and the IO object you pass to flush
+  #any internal buffers in order to be able to read all decompressed
+  #data.
+  #==Parameters
+  #[delegate] An IO object to read the data from, or a path
+  #           to a file to open. If you’re in an urgent need to
+  #           pass a plain string, use StringIO from Ruby’s
+  #           standard library. If this is an IO, it must be
+  #           opened for reading.
+  #The other parameters are identical to what the XZ::decompress_stream
+  #method expects.
+  #==Return value
+  #The newly created instance.
+  #==Example
+  #  # Wrap it around a file
+  #  f = File.open("foo.xz")
+  #  r = XZ::StreamReader.new(f)
+  #
+  #  # Ignore any XZ checksums (may result in invalid data being read!)
+  #  File.open("foo.xz") do |f|
+  #    r = XZ::StreamReader.new(f, XZ::LibLZMA::UINT64_MAX, [:tell_no_check]
+  #  end
+  #
+  #  # Let StreamReader handle file closing automatically
+  #  XZ::StreamReader.new("myfile.xz"){|r| r.raed}
+  def initialize(delegate, memory_limit = XZ::LibLZMA::UINT64_MAX, flags = [:tell_unsupported_check])
+    raise(ArgumentError, "Invalid memory limit set!") unless (0..XZ::LibLZMA::UINT64_MAX).include?(memory_limit)
+    flags.each do |flag|
+      raise(ArgumentError, "Unknown flag #{flag}!") unless [:tell_no_check, :tell_unsupported_check, :tell_any_check, :concatenated].include?(flag)
+    end
+    
+    if delegate.respond_to?(:to_io)
+      super(delegate)
+    else
+      @file = File.open(delegate, "rb")
+      super(@file)
+    end
+
+    @memory_limit = memory_limit
+    @flags        = flags
+
+    res = XZ::LibLZMA.lzma_stream_decoder(@lzma_stream,
+                                          @memory_limit,
+                                          @flags.inject(0){|val, flag| val | XZ::LibLZMA.const_get(:"LZMA_#{flag.to_s.upcase}")})
+    XZ::LZMAError.raise_if_necessary(res)
+    
+    @input_buffer_p = FFI::MemoryPointer.new(XZ::CHUNK_SIZE)
+
+    # These two are only used in #unbuffered read.
+    @__lzma_finished = false
+    @__lzma_action   = nil
+
+    if block_given?
+      begin
+        yield(self)
+      ensure
+        close unless closed?
+      end
+    end
+  end
+  self.class.send(:alias_method, :open, :new)
+  
+  #Closes this StreamReader instance. Don’t use it afterwards
+  #anymore.
+  #==Return value
+  #The total number of bytes decompressed.
+  #==Example
+  #  r.close #=> 6468
+  #==Remarks
+  #If you passed an IO to ::new, this method doesn’t close it, so
+  #you have to close it yourself.
+  def close
+    super
+    
+    # Close the XZ stream
+    res = XZ::LibLZMA.lzma_end(@lzma_stream.pointer)
+    XZ::LZMAError.raise_if_necessary(res)
+
+    #If we created a File object, close this as well.
+    @file.close if @file
+
+    # Return the number of bytes written in total.
+    @lzma_stream[:total_out]
+  end
+
+  #call-seq:
+  #  pos()  → an_integer
+  #  tell() → an_integer
+  #
+  #Total number of output bytes provided to you yet.
+  def pos
+    @lzma_stream[:total_out]
+  end
+  alias tell pos
+
+  #Instrcuts liblzma to immediately stop decompression,
+  #rewinds the wrapped IO object and reinitalizes the
+  #StreamReader instance with the same values passed
+  #originally to the ::new method. The wrapped IO object
+  #must support the +rewind+ method for this method to
+  #work; if it doesn’t, this method throws an IOError.
+  #After the exception was thrown, the StreamReader instance
+  #is in an unusable state. You cannot continue using it
+  #(don’t call #close on it either); close the wrapped IO
+  #stream and create another instance of this class.
+  #==Raises
+  #[IOError] The wrapped IO doesn’t support rewinding.
+  #          Do not use the StreamReader instance anymore
+  #          after receiving this exception.
+  #==Remarks
+  #I don’t really like this method, it uses several dirty
+  #tricks to circumvent both io-like’s and liblzma’s control
+  #mechanisms. I only implemented this because the
+  #<tt>archive-tar-minitar</tt> gem calls this method when
+  #unpacking a TAR archive from a stream.
+  def rewind
+    # HACK: Wipe all data from io-like’s internal read buffer.
+    # This heavily relies on io-like’s internal structure.
+    # Be always sure to test this when a new version of
+    # io-like is released!
+    __io_like__internal_read_buffer.clear
+    
+    # Forcibly close the XZ stream (internally frees it!)
+    res = XZ::LibLZMA.lzma_end(@lzma_stream.pointer)
+    XZ::LZMAError.raise_if_necessary(res)
+
+    # Rewind the wrapped IO
+    begin
+      @delegate_io.rewind
+    rescue => e
+      raise(IOError, "Delegate IO failed to rewind! Original message: #{e.message}")
+    end
+    
+    # Reinitialize everything. Note this doesn’t affect @file as it
+    # is already set and stays so (we don’t pass a filename here,
+    # but rather an IO)
+    initialize(@delegate_io, @memory_limit, @flags)
+  end
+
+  #NO, you CANNOT seek in this object!!
+  #io-like’s default behaviour is to raise Errno::ESPIPE
+  #when calling a non-defined seek, which is not what some
+  #libraries such as RubyGem’s TarReader expect (they expect
+  #a NoMethodError/NameError instead).
+  undef seek
+
+  private
+
+  #Called by io-like’s read methods such as #read. Does the heavy work
+  #of feeding liblzma the compressed data and reading the returned
+  #uncompressed data.
+  def unbuffered_read(length)
+    raise(EOFError, "Input data completely processed!") if @__lzma_finished
+    
+    output_buffer_p = FFI::MemoryPointer.new(length) # User guarantees that this fits into RAM
+
+    @lzma_stream[:next_out]  = output_buffer_p
+    @lzma_stream[:avail_out] = output_buffer_p.size
+
+    loop do
+      # DON’T overwrite any not yet consumed input from any previous
+      # run! Instead, wait until the last input data is entirely
+      # consumed, then provide new data.
+      # TODO: Theoretically, one could move the remaining data to the
+      # beginning of the pointer and fill the rest with new data,
+      # being a tiny bit more performant.
+      if @lzma_stream[:avail_in].zero?
+        compressed_data = @delegate_io.read(@input_buffer_p.size) || "" # nil at EOS → ""
+        @input_buffer_p.write_string(compressed_data)
+        @lzma_stream[:next_in] = @input_buffer_p
+        @lzma_stream[:avail_in] = binary_size(compressed_data)
+
+        # Now check if we’re at the last bytes of data and set accordingly the
+        # LZMA-action to carry out (for any subsequent runs until
+        # all input data has been consumed and the above condition
+        # is triggered again).
+        #
+        # The @__lzma_action variable is only used in this method
+        # and is _not_ supposed to be accessed from any other method.
+        if compressed_data.empty?
+          @__lzma_action = XZ::LibLZMA::LZMA_ACTION[:lzma_finish]
+        else
+          @__lzma_action = XZ::LibLZMA::LZMA_ACTION[:lzma_run]
+        end
+      end
+
+      res = XZ::LibLZMA.lzma_code(@lzma_stream.pointer, @__lzma_action)
+
+      # liblzma signals LZMA_BUF_ERROR when the output buffer is
+      # completely filled, which means we can return now.
+      # When it signals LZMA_STREAM_END, the buffer won’t be filled
+      # completely anymore as the whole input data has been consumed.
+      if res == XZ::LibLZMA::LZMA_RET[:lzma_buf_error]
+        # @lzma_stream[:avail_out] holds the number of free bytes _behind_
+        # the produced output!
+        return output_buffer_p.read_string(output_buffer_p.size - @lzma_stream[:avail_out])
+      elsif res == XZ::LibLZMA::LZMA_RET[:lzma_stream_end]
+        # @__lzma_finished is not supposed to be used outside this method!
+        @__lzma_finished = true
+        return output_buffer_p.read_string(output_buffer_p.size - @lzma_stream[:avail_out])
+      else
+        XZ::LZMAError.raise_if_necessary(res)
+      end
+    end #loop
+
+  rescue XZ::LZMAError => e
+    raise(SystemCallError, e.message)
+  end
+
+end

data/lib/xz/stream_writer.rb

@@ -0,0 +1,215 @@
+# -*- coding: utf-8 -*-
+# (The MIT license)
+#
+# Basic liblzma-bindings for Ruby.
+# 
+# Copyright © 2012 Marvin Gülker
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the ‘Software’),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the Software
+# is furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED ‘AS IS’, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+#An IO-like writer class for XZ-compressed data, allowing you to write
+#uncompressed data to a stream which ends up as compressed data in
+#a wrapped stream such as a file.
+#
+#A StreamWriter object actually wraps another IO object it writes the
+#XZ-compressed data to. Here’s an ASCII art image to demonstrate
+#way data flows when using StreamWriter to write to a compressed
+#file:
+#
+#          +----------------+  +------------+
+#  YOUR  =>|StreamWriter's  |=>|Wrapped IO's|=> ACTUAL
+#  DATA  =>|internal buffers|=>|buffers     |=>  FILE
+#          +----------------+  +------------+
+#
+#This graphic also illustrates why it is unlikely to see written
+#data directly appear in the file on your harddisk; the data is
+#cached at least twice before it actually gets written out. Regarding
+#file closing that means that before you can be sure any pending data
+#has been written to the file you have to close both the StreamWriter
+#instance and then the wrapped IO object (in *exactly* that order, otherwise
+#data loss and unexpected exceptions may occur!).
+#
+#As it might be tedious to always remember the correct closing order,
+#it’s possible to pass a filename to the ::new method. In this case,
+#StreamWriter will open the file internally and also takes care closing
+#it when you call the #close method.
+#
+#See the +io-like+ gem’s documentation for the IO-writing methods
+#available for this class (although you’re probably familiar with
+#them through Ruby’s own IO class ;-)).
+#
+#==Example
+#Together with the <tt>archive-tar-minitar</tt> gem, this library
+#can be used to create XZ-compressed TAR archives (these commonly
+#use a file extension of <tt>.tar.xz</tt> or rarely <tt>.txz</tt>).
+#
+#  XZ::StreamWriter.open("foo.tar.xz") do |txz|
+#    # This automatically closes txz
+#    Archive::Tar::Minitar.pack("foo", txz)
+#  end
+class XZ::StreamWriter < XZ::Stream
+
+  #call-seq:
+  # open(delegate, compression_level = 6, check = :crc64, extreme = false) → a_stream_writer
+  # new(delegate, compression_level = 6, check = :crc64, extreme = false)  → a_stream_writer
+  #
+  #Creates a new StreamWriter instance. The block form automatically
+  #calls the #close method when the block has finished executing.
+  #==Parameters
+  #[delegate] An IO object to write the data to or a filename
+  #           which will be opened internally. If you pass an IO,
+  #           the #close method won’t close the passed IO object;
+  #           if you passed a filename, the created internal file
+  #           of course gets closed.
+  #The other parameters are identical to what the XZ::compress_stream
+  #method expects.
+  #==Return value
+  #The newly created instance.
+  #==Example
+  #  # Wrap it around a file
+  #  f = File.open("data.xz")
+  #  w = XZ::StreamWriter.new(f)
+  #
+  #  # Use SHA256 as the checksum and use a higher compression level
+  #  # than the default (6)
+  #  f = File.open("data.xz")
+  #  w = XZ::StreamWriter.new(f, 8, :sha256)
+  #
+  #  # Instruct liblzma to use ultra-really-high compression
+  #  # (may take eternity)
+  #  f = File.open("data.xz")
+  #  w = XZ::StreamWriter.new(f, 9, :crc64, true)
+  #
+  #  # Passing a filename
+  #  w = XZ::StreamWriter.new("compressed_data.xz")
+  def initialize(delegate, compression_level = 6, check = :crc64, extreme = false)
+    if delegate.respond_to?(:to_io)
+      super(delegate)
+    else
+      @file = File.open(delegate, "wb")
+      super(@file)
+    end
+    
+    # Initialize the internal LZMA stream for encoding
+    res = XZ::LibLZMA.lzma_easy_encoder(@lzma_stream.pointer, 
+                                  compression_level | (extreme ? XZ::LibLZMA::LZMA_PRESET_EXTREME : 0),
+                                  XZ::LibLZMA::LZMA_CHECK[:"lzma_check_#{check}"])
+    XZ::LZMAError.raise_if_necessary(res)
+
+    if block_given?
+      begin
+        yield(self)
+      ensure
+        close unless closed?
+      end
+    end
+  end
+  self.class.send(:alias_method, :open, :new)
+
+  #Closes this StreamWriter instance and flushes all internal buffers.
+  #Don’t use it afterwards anymore.
+  #==Return vaule
+  #The total number of bytes written, i.e. the size of the compressed
+  #data.
+  #==Example
+  #  w.close #=> 424
+  #==Remarks
+  #If you passed an IO object to ::new, this method doesn’t close it,
+  #you have to do that yourself.
+  def close
+    super
+    
+    #1. Close the current block ("file") (an XZ stream may actually include
+    #   multiple compressed files, which however is not supported by
+    #   this library). For this we have to tell liblzma that
+    #   the next bytes we pass to it are the last bytes (by means of
+    #   the FINISH action). Just that we don’t pass any new input ;-)
+    
+    output_buffer_p         = FFI::MemoryPointer.new(XZ::CHUNK_SIZE)
+    
+    # Get any pending data (LZMA_FINISH causes libzlma to flush its
+    # internal buffers) and write it out to our wrapped IO.
+    loop do
+      @lzma_stream[:next_out]  = output_buffer_p
+      @lzma_stream[:avail_out] = output_buffer_p.size
+      
+      res = XZ::LibLZMA.lzma_code(@lzma_stream.pointer, XZ::LibLZMA::LZMA_ACTION[:lzma_finish])
+      XZ::LZMAError.raise_if_necessary(res)
+      
+      @delegate_io.write(output_buffer_p.read_string(output_buffer_p.size - @lzma_stream[:avail_out]))
+      
+      break unless @lzma_stream[:avail_out] == 0
+    end
+
+    #2. Close the whole XZ stream.
+    res = XZ::LibLZMA.lzma_end(@lzma_stream.pointer)
+    XZ::LZMAError.raise_if_necessary(res)
+
+    #2b. If we wrapped a file automatically, close it.
+    @file.close if @file
+
+    #3. Return the number of bytes written in total.
+    @lzma_stream[:total_out]
+  end
+
+  #call-seq:
+  #  pos()  → an_integer
+  #  tell() → an_integer
+  #
+  #Total number of input bytes read so far from what you
+  #supplied to any writer method.
+  def pos
+    @lzma_stream[:total_in]
+  end
+  alias tell pos
+
+  private
+
+  #Called by io-like’s write methods such as #write. Does the heavy
+  #work of feeding liblzma the uncompressed data and reading the
+  #returned compressed data.
+  def unbuffered_write(data)
+    output_buffer_p = FFI::MemoryPointer.new(XZ::CHUNK_SIZE)
+    input_buffer_p  = FFI::MemoryPointer.from_string(data) # This adds a terminating NUL byte we don’t want to compress!
+
+    @lzma_stream[:next_in]  = input_buffer_p
+    @lzma_stream[:avail_in] = input_buffer_p.size - 1 # Don’t hand the terminating NUL
+
+    loop do
+      @lzma_stream[:next_out]  = output_buffer_p
+      @lzma_stream[:avail_out] = output_buffer_p.size
+
+      # Compress the data
+      res = XZ::LibLZMA.lzma_code(@lzma_stream.pointer, XZ::LibLZMA::LZMA_ACTION[:lzma_run])
+      XZ::LZMAError.raise_if_necessary(res) # TODO: Warnings
+      
+      # Write the compressed data
+      result = output_buffer_p.read_string(output_buffer_p.size - @lzma_stream[:avail_out])
+      @delegate_io.write(result)
+
+      # Loop until liblzma ate the whole data.
+      break if @lzma_stream[:avail_in] == 0
+    end
+
+    binary_size(data)
+  rescue XZ::LZMAError => e
+    raise(SystemCallError, e.message)
+  end
+  
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-xz
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,12 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-03-16 00:00:00.000000000 +01:00
-default_executable: 
+date: 2012-02-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
-  requirement: &15267800 !ruby/object:Gem::Requirement
+  requirement: &12835000 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -22,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *15267800
+  version_requirements: *12835000
 - !ruby/object:Gem::Dependency
   name: hanna-nouveau
-  requirement: &15267300 !ruby/object:Gem::Requirement
+  requirement: &12834200 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -33,7 +32,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *15267300
+  version_requirements: *12834200
 description: ! 'This is a basic binding for liblzma that allows you to
 
   create and extract XZ-compressed archives. It can cope with big
@@ -49,9 +48,14 @@ extensions: []
 extra_rdoc_files:
 - README.rdoc
 files:
+- lib/xz/stream_reader.rb
+- lib/xz/stream.rb
+- lib/xz/lib_lzma.rb
+- lib/xz/stream_writer.rb
 - lib/xz.rb
 - README.rdoc
-has_rdoc: true
+- HISTORY.rdoc
+- VERSION
 homepage: 
 licenses: []
 post_install_message: 
@@ -67,7 +71,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      version: '1.9'
+      version: 1.8.7
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -76,7 +80,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.6.2
+rubygems_version: 1.8.16
 signing_key: 
 specification_version: 3
 summary: XZ compression via liblzma for Ruby.