ruby-xz 0.2.3 → 1.0.0

data/lib/xz/fiddle_helper.rb

@@ -0,0 +1,91 @@
+# -*- coding: utf-8 -*-
+#--
+# Basic liblzma-bindings for Ruby.
+#
+# Copyright © 2011-2018 Marvin Gülker et al.
+#
+# See AUTHORS for the full list of contributors.
+#
+# 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 is an internal API not meant for users of ruby-xz.
+  # This mixin modules defines some helper functions on top
+  # of Fiddle's functionality.
+  module FiddleHelper # :nodoc:
+
+    # Define constants that have numeric constants assigned as if
+    # it was a C enum definition. You can specificy values explicitely
+    # or rely on the implicit incrementation; the first implicit value
+    # is zero.
+    #
+    # Example:
+    #
+    #   enum :FOO, :BAR, 5, :BAZ
+    #
+    # This defines a constant FOO with value 0, BAR with value 5, BAZ
+    # with value 6.
+    def enum(*args)
+      @next_enum_val = 0 # First value of an enum is 0 in C
+
+      args.each_cons(2) do |val1, val2|
+        next if val1.respond_to?(:to_int)
+
+        if val2.respond_to?(:to_int)
+          const_set(val1, val2.to_int)
+          @next_enum_val = val2.to_int + 1
+        else
+          const_set(val1, @next_enum_val)
+          @next_enum_val += 1
+        end
+      end
+
+      # Cater for the last element in case it is not an explicit
+      # value that has already been assigned above.
+      unless args.last.respond_to?(:to_int)
+        const_set(args.last, @next_enum_val)
+      end
+
+      @next_enum_val = 0
+      nil
+    end
+
+    # Try loading any of the given names as a shared
+    # object. Raises Fiddle::DLError if none can
+    # be opened.
+    def dlloadanyof(*names)
+      names.each do |name|
+        begin
+          dlload(name)
+        rescue Fiddle::DLError
+          # Continue with next one
+        else
+          # Success
+          return name
+        end
+      end
+
+      raise Fiddle::DLError, "Failed to open any of these shared object files: #{names.join(', ')}"
+    end
+
+  end
+
+end

data/lib/xz/lib_lzma.rb

@@ -1,10 +1,10 @@
 # -*- coding: utf-8 -*-
 #--
-# The MIT License
-#
 # Basic liblzma-bindings for Ruby.
 #
-# Copyright © 2011,2013,2015 Marvin Gülker et al.
+# Copyright © 2011-2018 Marvin Gülker et al.
+#
+# See AUTHORS for the full list of contributors.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a
 # copy of this software and associated documentation files (the ‘Software’),
@@ -27,9 +27,31 @@
 
 module XZ
 
-  # This module wraps functions and enums used by liblzma.
+  # This module wraps functions and enums provided by liblzma.
+  # It contains the direct mapping to the underlying C functions;
+  # you should never have to use this. It's the lowlevel API
+  # the other methods provided by ruby-xz are based on.
   module LibLZMA
-    extend FFI::Library
+    extend Fiddle::Importer
+    extend XZ::FiddleHelper
+
+    dlloadanyof 'liblzma.so.5', 'liblzma.so', 'liblzma.5.dylib', 'liblzma.dylib', 'liblzma'
+
+    typealias "uint32_t", "unsigned int"
+    typealias "uint64_t", "unsigned long long"
+
+    # lzma_ret enum
+    enum :LZMA_OK, 0, :LZMA_STREAM_END, 1, :LZMA_NO_CHECK, 2,
+         :LZMA_UNSUPPORTED_CHECK, 3, :LZMA_GET_CHECK, 4,
+         :LZMA_MEM_ERROR, 5, :LZMA_MEMLIMIT_ERROR, 6,
+         :LZMA_FORMAT_ERROR, 7, :LZMA_OPTIONS_ERROR, 8,
+         :LZMA_DATA_ERROR, 9, :LZMA_BUF_ERROR, 10,
+         :LZMA_PROG_ERROR, 11
+
+    # lzma_action enum
+    enum :LZMA_RUN, 0, :LZMA_SYNC_FLUSH, 1,
+         :LZMA_FULL_FLUSH, 2, :LZMA_FULL_BARRIER, 4,
+         :LZMA_FINISH, 3
 
     # The maximum value of an uint64_t, as defined by liblzma.
     # Should be the same as
@@ -39,54 +61,100 @@ module XZ
     # Activates extreme compression. Same as xz's "-e" commandline switch.
     LZMA_PRESET_EXTREME = 1 << 31
 
-    LZMA_TELL_NO_CHECK          = 0x02
+    LZMA_TELL_NO_CHECK          = 0x01
     LZMA_TELL_UNSUPPORTED_CHECK = 0x02
     LZMA_TELL_ANY_CHECK         = 0x04
     LZMA_CONCATENATED           = 0x08
+    LZMA_IGNORE_CHECK           = 0x10
 
     # For access convenience of the above flags.
     LZMA_DECODE_FLAGS = {
       :tell_no_check          => LZMA_TELL_NO_CHECK,
       :tell_unsupported_check => LZMA_TELL_UNSUPPORTED_CHECK,
       :tell_any_check         => LZMA_TELL_ANY_CHECK,
-      :concatenated           => LZMA_CONCATENATED
+      :concatenated           => LZMA_CONCATENATED,
+      :ignore_check           => LZMA_IGNORE_CHECK
     }.freeze
 
     # 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.5', 'lzma.so', 'lzma']
-
-    attach_function :lzma_easy_encoder, [:pointer, :uint32, :int], :int, :blocking => true
-    attach_function :lzma_code, [:pointer, :int], :int, :blocking => true
-    attach_function :lzma_stream_decoder, [:pointer, :uint64, :uint32], :int, :blocking => true
-    attach_function :lzma_end, [:pointer], :void, :blocking => true
+    enum :LZMA_RESERVED_ENUM, 0
+
+    # lzma_check enum
+    enum :LZMA_CHECK_NONE, 0, :LZMA_CHECK_CRC32, 1,
+         :LZMA_CHECK_CRC64, 4, :LZMA_CHECK_SHA256, 10
+
+    # Aliases for the enums as fiddle only understands plain int
+    typealias "lzma_ret", "int"
+    typealias "lzma_check", "int"
+    typealias "lzma_action", "int"
+    typealias "lzma_reserved_enum", "int"
+
+    # lzma_stream struct. When creating one with ::malloc, use
+    # ::LZMA_STREAM_INIT to make it ready for use.
+    #
+    # This is a Fiddle::CStruct. As such, this has a class method
+    # ::malloc for allocating an instance of it on the heap, and
+    # instances of it have a #to_ptr method that returns a
+    # Fiddle::Pointer. That pointer needs to be freed with
+    # Fiddle::free if the instance was created with ::malloc.
+    # To wrap an existing instance, call ::new with the
+    # Fiddle::Pointer to wrap as an argument.
+    LZMAStream = struct [
+      "uint8_t* next_in",
+      "size_t avail_in",
+      "uint64_t total_in",
+      "uint8_t* next_out",
+      "size_t avail_out",
+      "uint64_t total_out",
+      "void* allocator",
+      "void* internal",
+      "void* reserved_ptr1",
+      "void* reserved_ptr2",
+      "void* reserved_ptr3",
+      "void* reserved_ptr4",
+      "uint64_t reserved_int1",
+      "uint64_t reserved_int2",
+      "size_t reserved_int3",
+      "size_t reserved_int4",
+      "lzma_reserved_enum reserved_enum1",
+      "lzma_reserved_enum reserved_enum2"
+    ]
+
+    # This method does basicly the same thing as the
+    # LZMA_STREAM_INIT macro of liblzma. Pass it an instance of
+    # LZMAStream that has not been initialised for use.
+    # The intended use of this method is:
+    #
+    #   stream = LibLZMA::LZMAStream.malloc # ::malloc is provided by fiddle
+    #   LibLZMA.LZMA_STREAM_INIT(stream)
+    #   # ...do something with the stream...
+    #   Fiddle.free(stream.to_ptr)
+    def self.LZMA_STREAM_INIT(stream)
+      stream.next_in        = nil
+      stream.avail_in       = 0
+      stream.total_in       = 0
+      stream.next_out       = nil
+      stream.avail_out      = 0
+      stream.total_out      = 0
+      stream.allocator      = nil
+      stream.internal       = nil
+      stream.reserved_ptr1  = nil
+      stream.reserved_ptr2  = nil
+      stream.reserved_ptr3  = nil
+      stream.reserved_ptr4  = nil
+      stream.reserved_int1  = 0
+      stream.reserved_int2  = 0
+      stream.reserved_int3  = 0
+      stream.reserved_int4  = 0
+      stream.reserved_enum1 = LZMA_RESERVED_ENUM
+      stream.reserved_enum2 = LZMA_RESERVED_ENUM
+      stream
+    end
+
+    extern "lzma_ret lzma_easy_encoder(lzma_stream*, uint32_t, lzma_check)"
+    extern "lzma_ret lzma_code(lzma_stream*, lzma_action)"
+    extern "lzma_ret lzma_stream_decoder(lzma_stream*, uint64_t, uint32_t)"
+    extern "void lzma_end(lzma_stream*)"
 
   end
 
@@ -95,71 +163,17 @@ module XZ
 
     # 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.")
+      case val
+      when LibLZMA::LZMA_MEM_ERROR      then raise(self, "Couldn't allocate memory!")
+      when LibLZMA::LZMA_MEMLIMIT_ERROR then raise(self, "Decoder ran out of (allowed) memory!")
+      when LibLZMA::LZMA_FORMAT_ERROR   then raise(self, "Unrecognized file format!")
+      when LibLZMA::LZMA_OPTIONS_ERROR  then raise(self, "Invalid options passed!")
+      when LibLZMA::LZMA_DATA_ERROR     then raise(self, "Archive is currupt.")
+      when LibLZMA::LZMA_BUF_ERROR      then raise(self, "Buffer unusable!")
+      when LibLZMA::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_in]        = 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

@@ -1,10 +1,10 @@
 # -*- coding: utf-8 -*-
 #--
-# (The MIT license)
-#
 # Basic liblzma-bindings for Ruby.
 #
-# Copyright © 2012, 2015 Marvin Gülker
+# Copyright © 2011-2018 Marvin Gülker et al.
+#
+# See AUTHORS for the full list of contributors.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a
 # copy of this software and associated documentation files (the ‘Software’),
@@ -25,44 +25,441 @@
 # 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.
+# The base class for XZ::StreamReader and XZ::StreamWriter.  This is
+# an abstract class that is not meant to be used directly. 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 using the minitar
+# RubyGem; see the README.md file for an example.
+#
+# Most of IO's methods are implemented in this class or one of the
+# subclasses. The most notable exception is that it is not possible
+# to seek in XZ archives (#seek and #pos= are not defined).
+# Many methods that are not expressly documented in the RDoc
+# still exist; this class uses Ruby's Forwardable module to forward
+# them to the underlying IO object.
 #
-# 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.
+# Stream and its subclasses honour Ruby's external+internal encoding
+# system just like Ruby's own IO does. All of what the Ruby docs say
+# about external and internal encodings applies to this class with one
+# important difference. The "external encoding" does not refer to the
+# encoding of the file on the hard disk (this file is always a binary
+# file as it's compressed data), but to the encoding of the
+# decompressed data inside the compressed file.
 #
-# 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.
+# As with Ruby's IO class, instances of this class and its subclasses
+# default their external encoding to Encoding.default_external and
+# their internal encoding to Encoding.default_internal. You can use
+# #set_encoding or pass appropriate arguments to the +new+ method to
+# change these encodings per-instance.
 class XZ::Stream
-  include IO::Like
+  extend Forwardable
+
+  def_delegator :@delegate_io, :"autoclose="
+  def_delegator :@delegate_io, :"autoclose?"
+  def_delegator :@delegate_io, :binmode
+  def_delegator :@delegate_io, :"binmode?"
+  def_delegator :@delegate_io, :"close_on_exec="
+  def_delegator :@delegate_io, :"close_on_exec?"
+  def_delegator :@delegate_io, :fcntl
+  def_delegator :@delegate_io, :fdatasync
+  def_delegator :@delegate_io, :fileno
+  def_delegator :@delegate_io, :to_i
+  def_delegator :@delegate_io, :flush # TODO: liblzma might have its own flush method that should be used
+  def_delegator :@delegate_io, :fsync
+  def_delegator :@delegate_io, :ioctl
+  def_delegator :@delegate_io, :isatty
+  def_delegator :@delegate_io, :pid
+  #def_delegator :@delegate_io, :stat # If this is available the minitar gem thinks it's a File and wants to seek it O_o
+  def_delegator :@delegate_io, :sync # TODO: use liblzma's own syncing functionality?
+  def_delegator :@delegate_io, :"sync=" # TODO: use liblzma's own syncing functionality?
+  def_delegator :@delegate_io, :"tty?"
+
+  # Like IO#lineno and IO#lineno=.
+  attr_accessor :lineno
+
+  # Returns the encoding used inside the compressed data stream.
+  # Like IO#external_encoding.
+  attr_reader :external_encoding
+
+  # When compressed data is read, the decompressed data is transcoded
+  # from the external_encoding to this encoding. If this encoding is
+  # nil, no transcoding happens.
+  attr_reader :internal_encoding
+
+  # Private API only for use by subclasses.
+  def initialize(delegate_io) # :nodoc:
+    @delegate_io = delegate_io
+    @lzma_stream = XZ::LibLZMA::LZMAStream.malloc
+    XZ::LibLZMA::LZMA_STREAM_INIT(@lzma_stream)
+
+    @finished = false
+    @lineno = 0
+    @pos = 0
+    @external_encoding = Encoding.default_external
+    @internal_encoding = Encoding.default_internal
+    @transcode_options = {}
+    @input_buffer_p  = Fiddle::Pointer.malloc(XZ::CHUNK_SIZE)
+    @output_buffer_p = Fiddle::Pointer.malloc(XZ::CHUNK_SIZE)
+  end
+
+  # Pass the given +str+ into libzlma's lzma_code() function.
+  # +action+ is either LibLZMA::LZMA_RUN (still working) or
+  # LibLZMA::LZMA_FINISH (this is the last piece).
+  def lzma_code(str, action) # :nodoc:
+    previous_encoding = str.encoding
+    str.force_encoding(Encoding::BINARY) # Need to operate on bytes now
+
+    begin
+      pos = 0
+      until pos > str.bytesize # Do not use >=, that conflicts with #lzma_finish
+        substr = str[pos, XZ::CHUNK_SIZE]
+        @input_buffer_p[0, str.bytesize] = substr
+        pos += XZ::CHUNK_SIZE
+
+        @lzma_stream.next_in  = @input_buffer_p
+        @lzma_stream.avail_in = substr.bytesize
+
+        loop do
+          @lzma_stream.next_out  = @output_buffer_p
+          @lzma_stream.avail_out = XZ::CHUNK_SIZE
+          res = XZ::LibLZMA.lzma_code(@lzma_stream.to_ptr, action)
+          XZ.send :check_lzma_code_retval, res # call package-private method
+
+          data = @output_buffer_p[0, XZ::CHUNK_SIZE - @lzma_stream.avail_out]
+          yield(data)
+
+          break unless @lzma_stream.avail_out == 0
+        end
+      end
+    ensure
+      str.force_encoding(previous_encoding)
+    end
+  end
+
+  # Partial implementation of +rewind+ abstracting common operations.
+  # The subclasses implement the rest.
+  def rewind # :nodoc:
+    # Free the current lzma stream and rewind the underlying IO.
+    # It is required to call #rewind before allocating a new lzma
+    # stream, because if #rewind raises an exception (because the
+    # underlying IO is not rewindable), a memory leak would occur
+    # with regard to an allocated-but-never-freed lzma stream.
+    finish
+    @delegate_io.rewind
+
+    # Reset internal state
+    @pos = @lineno = 0
+    @finished = false
+
+    # Allocate a new lzma stream (subclasses will configure it).
+    @lzma_stream = XZ::LibLZMA::LZMAStream.malloc
+    XZ::LibLZMA::LZMA_STREAM_INIT(@lzma_stream)
+
+    0 # Mimic IO#rewind's return value
+  end
+
+  # You can mostly treat this as if it were an IO object.
+  # At least for subclasses. This class itself is abstract,
+  # you shouldn't be using it directly at all.
+  #
+  # Returns the receiver.
+  def to_io
+    self
+  end
+
+  # Overridden in StreamReader to be like IO#eof?.
+  # This abstract implementation only raises IOError.
+  def eof?
+    raise(IOError, "Stream not opened for reading")
+  end
+
+  # Alias for #eof?
+  def eof
+    eof?
+  end
+
+  # True if the delegate IO has been closed.
+  def closed?
+    @delegate_io.closed?
+  end
+
+  # True if liblzma's internal memory has been freed. For writer
+  # instances, receiving true from this method also means that all
+  # of liblzma's compressed data has been flushed to the underlying
+  # IO object.
+  def finished?
+    @finished
+  end
+
+  # Free internal libzlma memory. This needs to be called before
+  # you leave this object for the GC. If you used a block-form
+  # initializer, this done automatically for you.
+  #
+  # Subsequent calls to #read or #write will cause an IOError.
+  #
+  # Returns the underlying IO object. This allows you to retrieve
+  # the File instance that was automatically created when using
+  # the +open+ method's block form.
+  def finish
+    return if @finished
+
+    # Clean up the lzma_stream structure's internal memory.
+    # This would belong into a destructor if Ruby had that.
+    XZ::LibLZMA.lzma_end(@lzma_stream)
+    @finished = true
+
+    @delegate_io
+  end
+
+
+  # If not done yet, call #finish. Then close the delegate IO.
+  # The latter action is going to cause the delegate IO to
+  # flush its buffer. After this method returns, it is guaranteed
+  # that all pending data has been flushed to the OS' kernel.
+  def close
+    finish unless @finished
+    @delegate_io.close unless @delegate_io.closed?
+    nil
+  end
+
+  # Always raises IOError, because XZ streams can never be duplex.
+  def close_read
+    raise(IOError, "Not a duplex I/O stream")
+  end
+
+  # Always raises IOError, because XZ streams can never be duplex.
+  def close_write
+    raise(IOError, "Not a duplex I/O stream")
+  end
+
+  # Overridden in StreamReader to be like IO#read.
+  # This abstract implementation only raises IOError.
+  def read(*args)
+    raise(IOError, "Stream not opened for reading")
+  end
+
+  # Overridden in StreamWriter to be like IO#write.
+  # This abstract implementation only raises IOError.
+  def write(*args)
+    raise(IOError, "Stream not opened for writing")
+  end
+
+  # Returns the position in the *decompressed* data (regardless of
+  # whether this is a reader or a writer instance).
+  def pos
+    @pos
+  end
+  alias tell pos
+
+  # Like IO#set_encoding.
+  def set_encoding(*args)
+    if args.count < 1 || args.count > 3
+      raise ArgumentError, "Wrong number of arguments: Expected 1-3, got #{args.count}"
+    end
+
+    # Clean `args' to [external_encoding, internal_encoding],
+    # and @transcode_options.
+    return set_encoding($`, $', *args[1..-1]) if args[0].respond_to?(:to_str) && args[0].to_str =~ /:/
+    @transcode_options = args.delete_at(-1) if args[-1].kind_of?(Hash)
+
+    # `args' is always [external, internal] or [external] at this point
+    @external_encoding = args[0].kind_of?(Encoding) ? args[0] : Encoding.find(args[0])
+    if args[1]
+      @internal_encoding = args[1].kind_of?(Encoding) ? args[1] : Encoding.find(args[1])
+    else
+      @internal_encoding = Encoding.default_internal # Encoding.default_internal defaults to nil
+    end
+
+    self
+  end
+
+  # Do not define #pos= and #seek, not even to throw NotImplementedError.
+  # Reason: The minitar gem thinks it can use this methods then and provokes
+  # the NotImplementedError exception.
+
+  # Like IO#<<.
+  def <<(obj)
+    write(obj.to_s)
+  end
+
+  # Like IO#advise. No-op, because not meaningful on compressed data.
+  def advise
+    nil
+  end
+
+  # Like IO#getbyte. Note this method isn't exactly performant,
+  # because it actually reads compressed data as a string and then
+  # needs to figure out the bytes from that again.
+  def getbyte
+    return nil if eof?
+    read(1).bytes.first
+  end
+
+  # Like IO#readbyte.
+  def readbyte
+    getbyte || raise(EOFError, "End of stream reached")
+  end
+
+  # Like IO#getc.
+  def getc
+    str = String.new
+
+    # Read byte-by-byte until a valid character in the external
+    # encoding was built.
+    loop do
+      str.force_encoding(Encoding::BINARY)
+      str << read(1)
+      str.force_encoding(@external_encoding)
+
+      break if str.valid_encoding? || eof?
+    end
+
+    # Transcode to internal encoding if one was requested
+    if @internal_encoding
+      str.encode(@internal_encoding)
+    else
+      str
+    end
+  end
+
+  # Like IO#readchar.
+  def readchar
+    getc || raise(EOFError, "End of stream reached")
+  end
+
+  # Like IO#gets.
+  def gets(separator = $/, limit = nil)
+    return nil if eof?
+    @lineno += 1
+
+    # Mirror IO#gets' weird call-seq
+    if separator.respond_to?(:to_int)
+      limit = separator.to_int
+      separator = $/
+    end
+
+    buf = String.new
+    buf.force_encoding(target_encoding)
+    until eof? || (limit && buf.length >= limit)
+      buf << getc
+      return buf if buf[-1] == separator
+    end
+
+    buf
+  end
+
+  # Like IO#readline.
+  def readline(*args)
+    gets(*args) || raise(EOFError, "End of stream reached")
+  end
+
+  # Like IO#each.
+  def each(*args)
+    return enum_for __method__ unless block_given?
+
+    while line = gets(*args)
+      yield(line)
+    end
+  end
+  alias each_line each
+
+  # Like IO#each_byte.
+  def each_byte
+    return enum_for __method__ unless block_given?
+
+    while byte = getbyte
+      yield(byte)
+    end
+  end
+
+  # Like IO#each_char.
+  def each_char
+    return enum_for __method__ unless block_given?
+
+    while char = getc
+      yield(char)
+    end
+  end
+
+  # Like IO#each_codepoint.
+  def each_codepoint
+    return enum_for __method__ unless block_given?
+
+    each_char{|c| yield(c.ord)}
+  end
+
+  # Like IO#printf.
+  def printf(*args)
+    write(sprintf(*args))
+    nil
+  end
+
+  # Like IO#putc.
+  def putc(obj)
+    if obj.respond_to? :chr
+      write(obj.chr)
+    elsif obj.respond_to? :to_str
+      write(obj.to_str)
+    else
+      raise(TypeError, "Can only #putc strings and numbers")
+    end
+  end
+
+  def puts(*objs)
+    if objs.empty?
+      write("\n")
+      return nil
+    end
+
+    objs.each do |obj|
+      if obj.respond_to? :to_ary
+        puts(*obj.to_ary)
+      else
+        # Don't squeeze multiple subsequent trailing newlines in `obj'
+        obj = obj.to_s
+        if obj.end_with?("\n".encode(obj.encoding))
+          write(obj)
+        else
+          write(obj + "\n".encode(obj.encoding))
+        end
+      end
+    end
+    nil
+  end
+
+  # Like IO#print.
+  def print(*objs)
+    if objs.empty?
+      write($_)
+    else
+      objs.each do |obj|
+        write(obj.to_s)
+        write($,) if $,
+      end
+    end
+
+    write($\) if $\
+    nil
+  end
 
-  # 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
+  # It is not possible to reopen an lzma stream, hence this
+  # method always raises NotImplementedError.
+  def reopen(*args)
+    raise(NotImplementedError, "Can't reopen an lzma stream")
   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(Encoding::BINARY).size
+  def target_encoding
+    if @internal_encoding
+      @internal_encoding
     else
-      str.bytes.to_a.size
+      @external_encoding
     end
   end