ruby-xz 0.2.3 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: efdc22da09c7e44e2c6d20b307e103f74975f430
-  data.tar.gz: 5c6bc972a178bd963e8f932fe7c13f7dc7b3e03e
+  metadata.gz: 820fac81115af7c562998d1c80cce241d045c210
+  data.tar.gz: 31823023e5de3c452f8d0b82b643732ff0294658
 SHA512:
-  metadata.gz: 1c9e49f86d2b1fd3c7174b45580b5567b34ac644e3b59733c1dafe758d6d4066f253662e16d0313ef7fb55332efb394eef15264102338ca4edb684f3e8aef61f
-  data.tar.gz: cef131976e91ece8b49a152d882271524bd3869931b45b75d1ce04ad8ca6829c3b82f77873a459e984ea1dcd59d2b135ba40515a5180f811c3f9573a724c2953
+  metadata.gz: 35aa3ebe08c3e82b4cc81339c23af1d78073ffb4d174f56079808f482ae60061c329aeed2fcbec56eb34e81102ed30bb3f32240f85436d5b99142df48e925f29
+  data.tar.gz: a83b6fc3ca7b397af5695877fde63ff8642fa60a689d36b505cbf08717ea2b4c22b182e484bd55aa66a49f90fb132da17e7cd7a2caf1250175590127fb7f0565

data/AUTHORS

@@ -2,7 +2,5 @@
 
 All the people who worked on this project, in alphabetical order.
 
-* Lars Christensen (larsch)
-* Marvin Gülker (Quintus) <quintus ät quintilianus döt eu>
+* Marvin Gülker (Quintus) <m-guelker@phoenixmail.de>
 * Christoph Plank (chrisistuff)
-* Nana Sakisaka (saki7)

data/HISTORY.rdoc

@@ -1,5 +1,50 @@
 = Version history
 
+== 1.0.0 (2018-05-20)
+
+* *BreakingChange* The XZ module's methods now take any parameters
+  beyond the IO object as real Ruby keyword arguments rather than
+  a long argument list.
+* *BreakingChange* XZ.decompress_stream now honours Ruby's
+  external and internal encoding concept instead of just
+  returning BINARY-tagged strings.
+* *BreakingChange* Remove deprecated API on stream reader/writer
+  class and instead sync the API with Ruby's zlib library
+  (Ticket #12 by me).
+* *BreakingChange* StreamWriter.new and StreamReader.new do not accept
+  a block anymore. This is part of syncing with Ruby's zlib API.
+* *BreakingChange* StreamReader.open and StreamWriter.open always
+  return the new instance, even if a block is given to the method
+  (previous behaviour was to return the return value of the block).
+  This is part of the syncing with Ruby's zlib API.
+* *BreakingChange* StreamReader.new and StreamWriter.new as well as
+  the ::open variants take additional arguments as real Ruby keyword
+  arguments now instead of a long parameter list plus options hash.
+  This is different from Ruby's own zlib API as that one takes both
+  a long parameter list and a hash of additional options. ruby-xz
+  is meant to follow zlib's semantics mostly, but not as a drop-in
+  replacement, so this divergence from zlib's API is okay (also
+  given that it isn't possible to replicate all possible options
+  1:1 anyway, since liblzma simply accepts different options as
+  libz). If you've never used these methods' optional arguments,
+  you should be fine.
+* *BreakingChange* Stream#close now returns nil instead of the
+  number of bytes written. This syncs Stream#close with Ruby's
+  own IO#close, which also returns nil.
+* *BreakingChange* Remove Stream#pos=, Stream#seek, Stream#stat. These
+  methods irritated the minitar gem, which doesn't expect them to
+  raise NotImplementedError, but directly to be missing if the object
+  does not support seeking.
+* *BreakingChange* StreamReader and StreamWriter now honour Ruby's
+  encoding system instead of returning only BINARY-tagged strings.
+* *Dependency* Remove dependency on ffi. ruby-xz now uses fiddle from
+  the stdlib instead.
+* *Dependency* Remove dependency on io-like. ruby-xz now implements
+  all the IO mechanics itself. (Ticket #10 by me)
+* *Dependency* Bump required Ruby version to 2.3.0.
+* *Fix* libzlma.dylib not being found on OS X (Ticket #15 by
+  s0nspark).
+
 == 0.2.3 (2015-12-29)
 
 * *Fix* documentation of XZ module (a :nodoc: was causing havoc

data/LICENSE

@@ -0,0 +1,21 @@
+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.

data/README.md

@@ -5,16 +5,20 @@ ruby-xz
 best known for the extreme compression-ratio it's native *XZ* format
 achieves. ruby-xz gives 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][2].
+is needed, because ruby-xz is written on top of Ruby's “fiddle” library
+(part of the standard libary). ruby-xz does not have any dependencies
+other than Ruby itself.
 
-ruby-xz supports both "intuitive" (de)compression by providing methods to
+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.
 
+**Note**: Version 1.0.0 breaks the API quite heavily. Refer to
+HISTORY.rdoc for details.
+
 Installation
 ------------
 
@@ -28,7 +32,7 @@ Alternatively, you can clone the repository and build the most recent
 code yourself:
 
 ```
-$ git clone git://github.com/Quintus/ruby-xz.git
+$ git clone git://git.guelker.eu/ruby-xz.git
 $ cd ruby-xz
 $ rake gem
 $ gem install pkg/ruby-xz-*.gem
@@ -42,26 +46,23 @@ everything you need to use ruby-xz. As said, it's not big, but powerful:
 You can create and extract whole archive files, compress or decompress
 streams of data or just plain strings.
 
-You can read the documentation on your local gemserver, or browse it [online][3].
+You can read the documentation on your local gemserver, or browse it [online][2].
 
-### First step ###
+### Require ###
 
-You have to require ruby-xz. Note the file you have to require is named
-"xz.rb", so do
+You have to require the “xz.rb” file:
 
 ``` ruby
 require "xz"
 ```
 
-to get it.
-
 ### Examples ###
 
 ``` ruby
-# Compress a TAR archive
-XZ.compress_file("myfile.tar", "myfile.tar.xz")
+# Compress a file
+XZ.compress_file("myfile.txt", "myfile.txt.xz")
 # Decompress it
-XZ.decompress_file("myfile.tar.xz", "myfile.tar")
+XZ.decompress_file("myfile.txt.xz", "myfile.txt")
 
 # Compress everything you get from a socket (note that there HAS to be a EOF
 # sometime, otherwise this will run infinitely)
@@ -76,42 +77,42 @@ data = XZ.decompress(comp)
 Have a look at the XZ module's documentation for an in-depth description of
 what is possible.
 
-Links
------
-
-* Code repository: https://github.com/Quintus/ruby-xz
-* Issue tracker: https://github.com/Quintus/ruby-xz/issues
-* Online documentation: http://quintus.github.io/ruby-xz
+### Usage with the minitar gem ###
 
-License
--------
+ruby-xz can be used together with the [minitar][3] library (formerly
+“archive-tar-minitar”) to create XZ-compressed tarballs. This works by
+employing the IO-like classes XZ::StreamReader and XZ::StreamWriter
+analogous to how one would use Ruby's “zlib” library together with
+“minitar”. Example:
 
-(The MIT License)
+``` ruby
+require "xz"
+require "minitar"
 
-Basic liblzma-bindings for Ruby.
+# Create an XZ-compressed tarball
+XZ::StreamWriter.open("tarball.tar.xz") do |txz|
+  Minitar.pack("path/to/directory", txz)
+end
 
-Copyright © 2011-2015 Marvin Gülker et al.
+# Unpack it again
+XZ::StreamReader.open("tarball.tar.xz") do |txz|
+  Minitar.unpack(txz, "path/to/target/directory")
+end
+```
 
-See AUTHORS for the full list of contributors.
+Links
+-----
 
-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:
+* Website: https://mg.guelker.eu/projects/ruby-xz/
+* Online documentation: https://mg.guelker.eu/projects/ruby-xz/doc
+* Code repository: https://git.guelker.eu/?p=ruby-xz.git;a=summary
+* Issue tracker: https://github.com/Quintus/ruby-xz/issues
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+License
+-------
 
-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.
+MIT license; see LICENSE for the full license text.
 
-[1]: http://tukaani.org/xz/
-[2]: https://github.com/ffi/ffi
-[3]: http://quintus.github.io/ruby-xz
+[1]: https://tukaani.org/xz/
+[2]: https://mg.guelker.eu/projects/ruby-xz/doc
+[3]: https://github.com/halostatue/minitar

data/lib/xz.rb

@@ -1,11 +1,10 @@
 # -*- coding: utf-8 -*-
 #--
-# (The MIT License)
-#
 # Basic liblzma-bindings for Ruby.
 #
-# Copyright © 2011,2012,2015 Marvin Gülker
-# Copyright © 2011 Christoph Plank
+# 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,20 +26,14 @@
 #++
 
 require "pathname"
-require "ffi"
-require 'stringio'
-require "io/like"
+require "fiddle"
+require "fiddle/import"
+require "stringio"
+require "forwardable"
 
 # 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
 
   # Number of bytes read in one chunk.
@@ -68,17 +61,24 @@ module XZ
     end
 
     # call-seq:
-    #   decompress_stream(io [, memory_limit [, flags ] ] )               → a_string
-    #   decompress_stream(io [, memory_limit [, flags ] ] ){|chunk| ... } → an_integer
-    #   decode_stream(io [, memory_limit [, flags ] ] )                   → a_string
-    #   decode_stream(io [, memory_limit [, flags ] ] ){|chunk| ... }     → an_integer
+    #   decompress_stream(io [, kw ] )                 → a_string
+    #   decompress_stream(io [, kw ] ] ){|chunk| ... } → an_integer
+    #   decode_stream(io [, kw ] ] )                   → a_string
+    #   decode_stream(io [, kw ] ){|chunk| ... }       → an_integer
     #
     # Decompresses a stream containing XZ-compressed data.
     #
     # === Parameters
+    # ==== Positional parameters
     #
     # [io]
-    #   The IO to read from. It must be opened for reading.
+    #   The IO to read from. It must be opened for reading in
+    #   binary mode.
+    # [chunk (Block argument)]
+    #   One piece of decompressed data. See Remarks section below
+    #   for information about its encoding.
+    #
+    # ==== Keyword arguments
     #
     # [memory_limit (+UINT64_MAX+)]
     #   If not XZ::LibLZMA::UINT64_MAX, makes liblzma
@@ -96,9 +96,13 @@ module XZ
     #     has an unsupported checksum type.
     #   [:concatenated]
     #     Decompress concatenated archives.
-    #
-    # [chunk (Block argument)]
-    #   One piece of decompressed data.
+    # [external_encoding (Encoding.default_external)]
+    #   Assume the decompressed data inside the compressed data
+    #   has this encoding. See Remarks section.
+    # [internal_encoding (Encoding.default_internal)]
+    #   Request transcoding of the decompressed data into this
+    #   encoding if not nil. Note that Encoding.default_internal
+    #   is nil by default. See Remarks section.
     #
     # === Return value
     #
@@ -106,6 +110,18 @@ module XZ
     # written. Otherwise, returns the decompressed data as a
     # BINARY-encoded string.
     #
+    # === Raises
+    #
+    # [Encoding::InvalidByteSequenceError]
+    #   1. You requested an “internal encoding” conversion
+    #      and the archive contains invalid byte sequences
+    #      in the external encoding.
+    #   2. You requested an “internal encoding” conversion, used
+    #      the block form of this method, and liblzma decided
+    #      to cut the decompressed data into chunks in mid of
+    #      a multibyte character. See Remarks section for an
+    #      explanation.
+    #
     # === Example
     #
     #   data = File.open("archive.xz", "rb"){|f| f.read}
@@ -125,8 +141,52 @@ module XZ
     # 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
     # you read in RAM then as in the example above.
-    def decompress_stream(io, memory_limit = LibLZMA::UINT64_MAX, flags = [:tell_unsupported_check], &block)
+    #
+    # This method honours Ruby's external and internal encoding concept.
+    # All documentation about this applies to this method, with the
+    # exception that the external encoding does not refer to the data
+    # on the hard disk (that's compressed XZ data, it's always binary),
+    # but to the data inside the XZ container, i.e. to the *decompressed*
+    # data. Any strings you receive from this method (regardless of
+    # whether via return value or via the +chunk+ block argument) will
+    # first be tagged with the external encoding. If you set an internal
+    # encoding (either via the +internal_encoding+ parameter or via
+    # Ruby's default internal encoding) that string will be transcoded
+    # from the external encoding to the internal encoding before you
+    # even see it; in that case, the return value or chunk block argument
+    # will be encoded in the internal encoding. Internal encoding is
+    # disabled in Ruby by default and the argument for this method also
+    # defaults to nil.
+    #
+    # Due to the external encoding being applied, it can happen that
+    # +chunk+ contains an incomplete multibyte character causing
+    # <tt>valid_encoding?</tt> to return false if called on +chunk+,
+    # because liblzma doesn't know about encodings. The rest of the
+    # character will be yielded to the block in the next iteration
+    # then as liblzma progresses with the decompression from the XZ
+    # format. In other words, be prepared that +chunk+ can contain
+    # incomplete multibyte chars.
+    #
+    # This can have nasty side effects if you requested an internal
+    # encoding automatic transcoding and used the block form. Since
+    # this method applies the internal encoding transcoding before the
+    # chunk is yielded to the block, String#encode gets the incomplete
+    # multibyte character. In that case, you will receive an
+    # Encoding::InvalidByteSequenceError exception even though your
+    # data is perfectly well-formed inside the XZ data. It's just
+    # that liblzma during decompression cut the chunks at an
+    # unfortunate place. To avoid this, do not request internal encoding
+    # conversion when using the block form, but instead transcode
+    # the data manually after you have decompressed the entire data.
+    def decompress_stream(io, memory_limit: LibLZMA::UINT64_MAX, flags: [:tell_unsupported_check], external_encoding: nil, internal_encoding: nil, &block)
       raise(ArgumentError, "Invalid memory limit set!") unless memory_limit > 0 && memory_limit <= LibLZMA::UINT64_MAX
+      raise(ArgumentError, "external_encoding must be set if internal_encoding transcoding is requested") if internal_encoding && !external_encoding
+
+      # The ArgumentError above is only about the concrete arguments
+      # (to sync with Ruby's IO API), not about the implied internal
+      # encoding, which might still kick in (and does, see below).
+      external_encoding ||= Encoding.default_external
+      internal_encoding ||= Encoding.default_internal
 
       # bit-or all flags
       allflags = flags.inject(0) do |val, flag|
@@ -134,8 +194,9 @@ module XZ
         val | flag
       end
 
-      stream = LZMAStream.new
-      res = LibLZMA.lzma_stream_decoder(stream.pointer,
+      stream = LibLZMA::LZMAStream.malloc
+      LibLZMA.LZMA_STREAM_INIT(stream)
+      res = LibLZMA.lzma_stream_decoder(stream.to_ptr,
                                         memory_limit,
                                         allflags)
 
@@ -144,32 +205,46 @@ module XZ
       res = ""
       res.encode!(Encoding::BINARY)
       if block_given?
-        res = lzma_code(io, stream, &block)
+        res = lzma_code(io, stream) do |chunk|
+          chunk = chunk.dup # Do not write somewhere into the fiddle pointer while encoding (-> can segfault)
+          chunk.force_encoding(external_encoding) if external_encoding
+          chunk.encode!(internal_encoding)        if internal_encoding
+          yield(chunk)
+        end
       else
         lzma_code(io, stream){|chunk| res << chunk}
+        res.force_encoding(external_encoding) if external_encoding
+        res.encode!(internal_encoding)        if internal_encoding
       end
 
-      LibLZMA.lzma_end(stream.pointer)
+      LibLZMA.lzma_end(stream.to_ptr)
 
-      block_given? ? stream[:total_out] : res
+      block_given? ? stream.total_out : res
     end
     alias decode_stream decompress_stream
 
     # call-seq:
-    #   compress_stream(io [, compression_level [, check [, extreme ] ] ] ) → a_string
-    #   compress_stream(io [, compression_level [, check [, extreme ] ] ] ){|chunk| ... } → an_integer
-    #   encode_stream(io [, compression_level [, check [, extreme ] ] ] ) → a_string
-    #   encode_stream(io [, compression_level [, check [, extreme ] ] ] ){|chunk| ... } → an_integer
+    #   compress_stream(io [, kw ] ) → a_string
+    #   compress_stream(io [, kw ] ){|chunk| ... } → an_integer
+    #   encode_stream(io [, kw ] ) → a_string
+    #   encode_stream(io [, kw ] ){|chunk| ... } → an_integer
     #
     # Compresses a stream of data into XZ-compressed data.
     #
     # === Parameters
+    # ==== Positional arguments
     #
     # [io]
     #   The IO to read the data from. Must be opened for
     #   reading.
+    # [chunk (Block argument)]
+    #   One piece of compressed data. This is always tagged
+    #   as a BINARY string, since it's compressed binary data.
     #
-    # [compression_level (6)]
+    # ==== Keyword arguments
+    # All keyword arguments are optional.
+    #
+    # [level (6)]
     #   Compression strength. Higher values indicate a
     #   smaller result, but longer compression time. Maximum
     #   is 9.
@@ -187,9 +262,6 @@ module XZ
     #   compression. This may succeed, but you can end
     #   up with *very* long computation times.
     #
-    # [chunk (Block argument)]
-    #   One piece of compressed data.
-    #
     # === Return value
     #
     # If a block was given, returns the number of bytes
@@ -204,7 +276,9 @@ module XZ
     #   i.rewind
     #   str = ""
     #
-    #   XZ.compress_stream(i, 4, :sha256){|c| str << c} #=> 123
+    #   XZ.compress_stream(i, level: 4, check: :sha256) do |c|
+    #     str << c
+    #   end #=> 123
     #   str #=> Some binary blob
     #
     # === Remarks
@@ -214,16 +288,23 @@ module XZ
     # know how big your data gets or if you want to compress much
     # data, use the block form. Of course you shouldn't store the data
     # your read in RAM then as in the example above.
-    def compress_stream(io, compression_level = 6, check = :crc64, extreme = false, &block)
-      raise(ArgumentError, "Invalid compression level!") unless (0..9).include?(compression_level)
+    #
+    # For the +io+ object passed Ruby's normal external and internal
+    # encoding rules apply while it is read from by this method. These
+    # encodings are not changed on +io+ by this method. The data you
+    # receive in the block (+chunk+) above is binary data (compressed
+    # data) and as such encoded as BINARY.
+    def compress_stream(io, level: 6, check: :crc64, extreme: false, &block)
+      raise(ArgumentError, "Invalid compression level!") unless (0..9).include?(level)
       raise(ArgumentError, "Invalid checksum specified!") unless [:none, :crc32, :crc64, :sha256].include?(check)
 
-      compression_level |= LibLZMA::LZMA_PRESET_EXTREME if extreme
+      level |= LibLZMA::LZMA_PRESET_EXTREME if extreme
 
-      stream = LZMAStream.new
-      res = LibLZMA.lzma_easy_encoder(stream.pointer,
-                                      compression_level,
-                                      LibLZMA::LZMA_CHECK[:"lzma_check_#{check}"])
+      stream = LibLZMA::LZMAStream.malloc
+      LibLZMA::LZMA_STREAM_INIT(stream)
+      res = LibLZMA.lzma_easy_encoder(stream.to_ptr,
+                                      level,
+                                      LibLZMA.const_get(:"LZMA_CHECK_#{check.upcase}"))
 
       LZMAError.raise_if_necessary(res)
 
@@ -235,9 +316,9 @@ module XZ
         lzma_code(io, stream){|chunk| res << chunk}
       end
 
-      LibLZMA.lzma_end(stream.pointer)
+      LibLZMA.lzma_end(stream.to_ptr)
 
-      block_given? ? stream[:total_out] : res
+      block_given? ? stream.total_out : res
     end
     alias encode_stream compress_stream
 
@@ -251,7 +332,7 @@ module XZ
     #   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 keyword parameters, see the ::compress_stream method.
     #
     # === Return value
     #
@@ -259,17 +340,17 @@ module XZ
     #
     # === Example
     #
-    #   XZ.compress("myfile.txt", "myfile.txt.xz")
-    #   XZ.compress("myarchive.tar", "myarchive.tar.xz")
+    #   XZ.compress_file("myfile.txt", "myfile.txt.xz")
+    #   XZ.compress_file("myarchive.tar", "myarchive.tar.xz")
     #
     # === Remarks
     #
     # This method is safe to use with big files, because files are not
     # loaded into memory completely at once.
-    def compress_file(in_file, out_file, compression_level = 6, check = :crc64, extreme = false)
+    def compress_file(in_file, out_file, **args)
       File.open(in_file, "rb") do |i_file|
         File.open(out_file, "wb") do |o_file|
-          compress_stream(i_file, compression_level, check, extreme) do |chunk|
+          compress_stream(i_file, **args) do |chunk|
             o_file.write(chunk)
           end
         end
@@ -282,7 +363,7 @@ module XZ
     #
     # [str] The data to compress.
     #
-    # For the other parameters, see the compress_stream method.
+    # For the keyword parameters, see the #compress_stream method.
     #
     # === Return value
     #
@@ -297,10 +378,9 @@ module XZ
     #
     # Don't use this method for big amounts of data--you may run out
     # of memory. Use compress_file or compress_stream instead.
-    def compress(str, compression_level = 6, check = :crc64, extreme = false)
-      raise(NotImplementedError, "StringIO isn't available!") unless defined? StringIO
+    def compress(str, **args)
       s = StringIO.new(str)
-      compress_stream(s, compression_level, check, extreme)
+      compress_stream(s, **args)
     end
 
     # Decompresses data in XZ format.
@@ -309,7 +389,7 @@ module XZ
     #
     # [str] The data to decompress.
     #
-    # For the other parameters, see the decompress_stream method.
+    # For the keyword parameters, see the decompress_stream method.
     #
     # === Return value
     #
@@ -324,10 +404,12 @@ module XZ
     #
     # Don't use this method for big amounts of data--you may run out
     # of memory. Use decompress_file or decompress_stream instead.
-    def decompress(str, memory_limit = LibLZMA::UINT64_MAX, flags = [:tell_unsupported_check])
-      raise(NotImplementedError, "StringIO isn't available!") unless defined? StringIO
+    #
+    # Read #decompress_stream's Remarks section for notes on the
+    # return value's encoding.
+    def decompress(str, **args)
       s = StringIO.new(str)
-      decompress_stream(s, memory_limit, flags)
+      decompress_stream(s, **args)
     end
 
     # Decompresses +in_file+ and writes the result to +out_file+.
@@ -340,7 +422,7 @@ module XZ
     #   The path of the file to write to. If it exists, it will
     #   be overwritten.
     #
-    # For the other parameters, see the decompress_stream method.
+    # For the keyword parameters, see the decompress_stream method.
     #
     # === Return value
     #
@@ -349,17 +431,17 @@ module XZ
     #
     # === Example
     #
-    #   XZ.decompres("myfile.txt.xz", "myfile.txt")
-    #   XZ.decompress("myarchive.tar.xz", "myarchive.tar")
+    #   XZ.decompress_file("myfile.txt.xz", "myfile.txt")
+    #   XZ.decompress_file("myarchive.tar.xz", "myarchive.tar")
     #
     # === Remarks
     #
     # This method is safe to use with big files, because files are not
     # loaded into memory completely at once.
-    def decompress_file(in_file, out_file, memory_limit = LibLZMA::UINT64_MAX, flags = [:tell_unsupported_check])
+    def decompress_file(in_file, out_file, **args)
       File.open(in_file, "rb") do |i_file|
         File.open(out_file, "wb") do |o_file|
-          decompress_stream(i_file, memory_limit, flags) do |chunk|
+          decompress_stream(i_file, internal_encoding: nil, external_encoding: Encoding::BINARY, **args) do |chunk|
             o_file.write(chunk)
           end
         end
@@ -368,30 +450,23 @@ module XZ
 
     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.
-      str.dup.force_encoding(Encoding::BINARY).size
-    end
-
     # This method does the heavy work of (de-)compressing a stream. It
     # takes an IO object to read data from (that means the IO must be
-    # opened for reading) and a XZ::LZMAStream object that is used to
+    # opened for reading) and a XZ::LibLZMA::LZMAStream object that is used to
     # (de-)compress the data. Furthermore this method takes a block
     # which gets passed the (de-)compressed data in chunks one at a
     # time--this is needed to allow (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)
-      output_buffer_p = FFI::MemoryPointer.new(CHUNK_SIZE)
+      input_buffer_p  = Fiddle::Pointer.malloc(CHUNK_SIZE) # automatically freed by fiddle on GC
+      output_buffer_p = Fiddle::Pointer.malloc(CHUNK_SIZE) # automatically freed by fiddle on GC
 
       while str = io.read(CHUNK_SIZE)
-        input_buffer_p.write_string(str)
+        input_buffer_p[0, str.bytesize] = str
 
         # Set the data for compressing
-        stream[:next_in]  = input_buffer_p
-        stream[:avail_in] = binary_size(str)
+        stream.next_in  = input_buffer_p
+        stream.avail_in = str.bytesize
 
         # Now loop until we gathered all the data in
         # stream[:next_out]. Depending on the amount of data, this may
@@ -405,25 +480,26 @@ module XZ
         # the amount of data to compress is small).
         loop do
           # Prepare for getting the compressed_data
-          stream[:next_out]  = output_buffer_p
-          stream[:avail_out] = CHUNK_SIZE
+          stream.next_out  = output_buffer_p
+          stream.avail_out = CHUNK_SIZE
 
           # Compress the data
           res = if io.eof?
-            LibLZMA.lzma_code(stream.pointer, LibLZMA::LZMA_ACTION[:lzma_finish])
+            LibLZMA.lzma_code(stream.to_ptr, LibLZMA::LZMA_FINISH)
           else
-            LibLZMA.lzma_code(stream.pointer, LibLZMA::LZMA_ACTION[:lzma_run])
+            LibLZMA.lzma_code(stream.to_ptr, LibLZMA::LZMA_RUN)
           end
           check_lzma_code_retval(res)
 
           # Write the compressed data
-          data = output_buffer_p.read_string(CHUNK_SIZE - stream[:avail_out])
+          # Note: avail_out gives how much space is left after the new data
+          data = output_buffer_p[0, CHUNK_SIZE - stream.avail_out]
           yield(data)
 
           # If the buffer is completely filled, it's likely that there
           # is more data liblzma wants to hand to us. Start a new
           # iteration, but don't provide new input data.
-          break unless stream[:avail_out] == 0
+          break unless stream.avail_out == 0
         end #loop
       end #while
     end #lzma_code
@@ -432,11 +508,10 @@ module XZ
     # return value of the lzma_code() function and shows them if
     # necessary.
     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 no 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 LibLZMA::LZMA_NO_CHECK then warn("Couldn't verify archive integrity--archive has no integrity checksum.")
+      when LibLZMA::LZMA_UNSUPPORTED_CHECK then warn("Couldn't verify archive integrity--archive has an unsupported integrity checksum.")
+      when LibLZMA::LZMA_GET_CHECK then nil # This isn't useful. It indicates that the checksum type is now known.
       else
         LZMAError.raise_if_necessary(code)
       end
@@ -447,6 +522,7 @@ module XZ
 end
 
 require_relative "xz/version"
+require_relative "xz/fiddle_helper"
 require_relative "xz/lib_lzma"
 require_relative "xz/stream"
 require_relative "xz/stream_writer"