ruby-xz 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8c1956c341bfbdbb6a5b002b47f8c418fafe3c8c
-  data.tar.gz: 8af67a57895f50f871a4509fc94f57932be150a4
+  metadata.gz: 28c451853871a094353485f28db08d64c5a5effa
+  data.tar.gz: 93ef5cba40e6a6330364206caf86dbcca6f95a7e
 SHA512:
-  metadata.gz: 2c04ff79076e081427e827e87fe489a882bf8b22674ebb3e0c3c8af26877c54b9b2140da1d61527da305bbcf062d4d5e687ce011a702a8300ce68a426bdba127
-  data.tar.gz: faac093525a0ab41c0fd35a2b3e39a95c70ca70c312dc6accf051343c17f770d2ed396b9266f93c7a67ff887bf450b9cc2b649cb69df7c074c03cc980054d455
+  metadata.gz: 75552a3ee976a8441ff397953bd608a8e9e6e5508b9c7cae73eb05278f509475c00fcea7ade557f758520c5b06b42711d96c162e9e5f2f5cc7ebed05e810a99f
+  data.tar.gz: 11b58af7569d56fe0c7486945a9e5ef87bfb0bf9579d29a82c3f7f21f8aa9ae2d03e118927bdc295585e857b82d5d536ddb9012393646591dc4a58585462587e

data/AUTHORS

@@ -0,0 +1,8 @@
+= List of contributors
+
+All the people who worked on this project, in alphabetical order.
+
+* Lars Christensen (larsch)
+* Marvin Gülker (Quintus) <quintus ät quintilianus döt eu>
+* Christoph Plank (chrisistuff)
+* Nana Sakisaka (saki7)

data/COPYING

@@ -2,7 +2,7 @@
 
 Basic liblzma-bindings for Ruby.
 
-Copyright © 2011-2013 Marvin Gülker et al.
+Copyright © 2011-2014 Marvin Gülker et al.
 
 See the file `AUTHORS' for the full list of contributors.
 

data/HISTORY.rdoc

@@ -1,16 +1,36 @@
-== 0.2.1
+= Version history
+
+== 0.2.2 (unreleased)
+
+* *Add* XZ.disable_deprecation_notes
+* *Deprecate* use of XZ::StreamReader.open with an IO argument
+* *Deprecate* use of XZ::StreamReader.new with a filename argument
+* *Deprecate* use of XZ::StreamWriter.open with an IO argument
+* *Deprecate* use of XZ::StreamWriter.new with a filename argument
+* *Deprecate* nonautomatic IO close in XZ::StreamReader#close
+* *Deprecate* nonautomatic IO close in XZ::StreamWriter#close
+* *Fix* incompatibility with Resolv.getaddress() in Ruby 2.2 (Ticket #13
+  by Ken Simon)
+* Goal of these deprecations is to sync the API with Ruby’s own
+  Zlib::GzipWriter and Zlib::GzipReader mostly.
+* Add required versions to gemspec.
+* Comment format cleanup, results in better docs.
+* Internal code cleanup
+* Add more tests.
+
+== 0.2.1 (2014-02-08)
 
 * Build the gem properly on Ruby 2.0+ (PR #8 by Nana Sakisaka (saki7))
 * Release the GIL when interfacing with liblzma (PR #7 by Lars Christensen (larsch))
 
-== 0.2.0
+== 0.2.0 (2013-06-23)
 
 * Fix #6 (errors on JRuby) by Ben Nagy
 * <b>Remove 1.8 compatibility</b>
 
-== 0.1.0
+== 0.1.0 (2013-02-17)
 
 * <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.
+* We now have proper unit tests.

data/{README.rdoc → README.md}

@@ -1,11 +1,12 @@
-= ruby-xz
+ruby-xz
+=======
 
-<b>ruby-xz</b> is a basic binding to the famous
-{liblzma library}[http://tukaani.org/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[https://github.com/ffi/ffi].
+**ruby-xz** is a basic binding to the famous [liblzma library][1],
+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].
 
 ruby-xz supports both "intuitive" (de)compression by providing methods to
 directly operate on strings and files, but also allows you to operate
@@ -14,59 +15,82 @@ 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
+Installation
+------------
 
 Install it the way you install all your gems.
 
-  # gem install ruby-xz
+```
+$ gem install ruby-xz
+```
 
-Ruby 1.9+ is required.
+Alternatively, you can clone the repository and build the most recent
+code yourself:
 
-== Usage
+```
+$ git clone git://github.com/Quintus/ruby-xz.git
+$ cd ruby-xz
+$ rake gem
+$ gem install pkg/ruby-xz-*.gem
+```
+
+Usage
+-----
 
 The documentation of the XZ module is well and you should be able to find
 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 online at
-http://quintus.github.io/ruby-xz/.
+You can read the documentation on your local gemserver, or browse it [online][3].
 
-=== First step
+### First step ###
 
 You have to require ruby-xz. Note the file you have to require is named
 "xz.rb", so do
 
-  require "xz"
-  
+``` ruby
+require "xz"
+```
+
 to get it.
 
-=== Examples
-
-  #Compress a TAR archive
-  XZ.compress_file("myfile.tar", "myfile.tar.xz")
-  #Decompress it
-  XZ.decompress_file("myfile.tar.xz", "myfile.tar")
-  
-  #Compress everything you get from a socket (note that there HAS to be a EOF
-  #sometime, otherwise this will run infinitely)
-  XZ.compress_stream(socket){|chunk| opened_file.write(chunk)}
-  
-  #Compress a string
-  comp = XZ.compress("Mydata")
-  #Decompress it
-  data = XZ.decompress(comp)
+### Examples ###
+
+``` ruby
+# Compress a TAR archive
+XZ.compress_file("myfile.tar", "myfile.tar.xz")
+# Decompress it
+XZ.decompress_file("myfile.tar.xz", "myfile.tar")
+
+# Compress everything you get from a socket (note that there HAS to be a EOF
+# sometime, otherwise this will run infinitely)
+XZ.compress_stream(socket){|chunk| opened_file.write(chunk)}
+
+# Compress a string
+comp = XZ.compress("Mydata")
+# Decompress it
+data = XZ.decompress(comp)
+```
 
 Have a look at the XZ module's documentation for an in-depth description of
 what is possible.
 
-=== License
+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
+
+License
+-------
 
 (The MIT License)
 
 Basic liblzma-bindings for Ruby.
 
-Copyright © 2011-2013 Marvin Gülker et al.
+Copyright © 2011-2015 Marvin Gülker et al.
 
 See AUTHORS for the full list of contributors.
 
@@ -87,3 +111,7 @@ 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.
+
+[1]: http://tukaani.org/xz/
+[2]: https://github.com/ffi/ffi
+[3]: http://quintus.github.io/ruby-xz

data/lib/xz.rb

@@ -1,9 +1,10 @@
 # -*- coding: utf-8 -*-
+#--
 # (The MIT License)
 #
 # Basic liblzma-bindings for Ruby.
 #
-# Copyright © 2011,2012 Marvin Gülker
+# Copyright © 2011,2012,2015 Marvin Gülker
 # Copyright © 2011 Christoph Plank
 #
 # Permission is hereby granted, free of charge, to any person obtaining a
@@ -23,79 +24,122 @@
 # 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.
+#++
 
 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.
+# 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.
+# 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
-  #The version of this library.
-  VERSION = "0.2.1"
 
-  #Number of bytes read in one chunk.
+  # Number of bytes read in one chunk.
   CHUNK_SIZE = 4096
 
   class << self
 
-    #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
-    #
-    #Decompresses a stream containing XZ-compressed data.
-    #===Parameters
-    #[io]           The IO to read from. It must be opened for reading.
-    #[memory_limit] (+UINT64_MAX+) If not XZ::LibLZMA::UINT64_MAX, makes liblzma
-    #               use no more memory than +memory_limit+ bytes.
-    #[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
-    #                                integrity checksum.
-    #               [:tell_unsupported_check] Spit out a warning if the archive
-    #                                         has an unsupported checksum type.
-    #               [:concatenated] Decompress concatenated archives.
-    #[chunk]        (Block argument) One piece of decompressed data.
-    #===Return value
-    #If a block was given, returns the number of bytes written. Otherwise,
-    #returns the decompressed data as a BINARY-encoded string.
-    #===Example
-    #  data = File.open("archive.xz", "rb"){|f| f.read}
-    #  io = StringIO.new(data)
-    #  XZ.decompress_stream(io) #=> "I AM THE DATA"
-    #  io.rewind
-    #  str = ""
-    #  XZ.decompress_stream(io, XZ::LibLZMA::UINT64_MAX, [:tell_no_check]){|c| str << c} #=> 13
-    #  str #=> "I AM THE DATA"
-    #===Remarks
-    #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 you read in RAM then as in the
-    #example above.
+    # :nodoc:
+    #
+    # Output a deprecation notice.
+    def deprecate(msg)
+      @disable_deprecation_notices ||= false
+
+      unless @disable_deprecation_notices
+        $stderr.puts("DEPRECATION NOTICE: #{msg}\n#{caller.drop(1).join("\n\t")}")
+      end
+    end
+
+    # Force ruby-xz to be silent about deprecations. Using this is
+    # discouraged so that you are aware of upcoming changes to the
+    # API. However, if your standard error stream is closed,
+    # outputting the deprecation notices might result in an exception,
+    # so this method allows you to surpress these notices. Ensure you
+    # read the HISTORY.rdoc file carefully instead.
+    def disable_deprecation_notices=(bool)
+      @disable_deprecation_notices = bool
+    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
+    #
+    # Decompresses a stream containing XZ-compressed data.
+    #
+    # === Parameters
+    #
+    # [io]
+    #   The IO to read from. It must be opened for reading.
+    #
+    # [memory_limit (+UINT64_MAX+)]
+    #   If not XZ::LibLZMA::UINT64_MAX, makes liblzma
+    #   use no more memory than +memory_limit+ bytes.
+    #
+    # [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
+    #     integrity checksum.
+    #   [:tell_unsupported_check]
+    #     Spit out a warning if the archive
+    #     has an unsupported checksum type.
+    #   [:concatenated]
+    #     Decompress concatenated archives.
+    #
+    # [chunk (Block argument)]
+    #   One piece of decompressed data.
+    #
+    # === Return value
+    #
+    # If a block was given, returns the number of bytes
+    # written. Otherwise, returns the decompressed data as a
+    # BINARY-encoded string.
+    #
+    # === Example
+    #
+    #   data = File.open("archive.xz", "rb"){|f| f.read}
+    #   io = StringIO.new(data)
+    #
+    #   XZ.decompress_stream(io) #=> "I AM THE DATA"
+    #   io.rewind
+    #
+    #   str = ""
+    #   XZ.decompress_stream(io, XZ::LibLZMA::UINT64_MAX, [:tell_no_check]){|c| str << c} #=> 13
+    #   str #=> "I AM THE DATA"
+    #
+    # === Remarks
+    #
+    # 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
+    # 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)
-      flags.each do |flag|
-        raise(ArgumentError, "Unknown flag #{flag}!") unless [:tell_no_check, :tell_unsupported_check, :tell_any_check, :concatenated].include?(flag)
+      raise(ArgumentError, "Invalid memory limit set!") unless memory_limit > 0 && memory_limit <= LibLZMA::UINT64_MAX
+
+      # bit-or all flags
+      allflags = flags.inject(0) do |val, flag|
+        flag = LibLZMA::LZMA_DECODE_FLAGS[flag] || raise(ArgumentError, "Unknown flag #{flag}!")
+        val | flag
       end
 
       stream = LZMAStream.new
-      res = LibLZMA.lzma_stream_decoder(
-        stream.pointer,
-        memory_limit,
-        flags.inject(0){|val, flag| val | LibLZMA.const_get(:"LZMA_#{flag.to_s.upcase}")}
-      )
+      res = LibLZMA.lzma_stream_decoder(stream.pointer,
+                                        memory_limit,
+                                        allflags)
 
       LZMAError.raise_if_necessary(res)
 
@@ -113,53 +157,74 @@ module XZ
     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
-    #
-    #Compresses a stream of data into XZ-compressed data.
-    #===Parameters
-    #[io]                The IO to read the data from. Must be opened for
-    #                    reading.
-    #[compression_level] (6) Compression strength. Higher values indicate a
-    #                    smaller result, but longer compression time. Maximum
-    #                    is 9.
-    #[check]             (:crc64) The checksum algorithm to use for verifying
-    #                    the data inside the archive. Possible values are:
-    #                    * :none
-    #                    * :crc32
-    #                    * :crc64
-    #                    * :sha256
-    #[extreme]           (false) Tries to get the last bit out of the
-    #                    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 written. Otherwise,
-    #returns the compressed data as a BINARY-encoded string.
-    #===Example
-    #  data = File.read("file.txt")
-    #  i = StringIO.new(data)
-    #  XZ.compress_stream(i) #=> Some binary blob
-    #  i.rewind
-    #  str = ""
-    #  XZ.compress_stream(i, 4, :sha256){|c| str << c} #=> 123
-    #  str #=> Some binary blob
-    #===Remarks
-    #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 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.
+    # 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
+    #
+    # Compresses a stream of data into XZ-compressed data.
+    #
+    # === Parameters
+    #
+    # [io]
+    #   The IO to read the data from. Must be opened for
+    #   reading.
+    #
+    # [compression_level (6)]
+    #   Compression strength. Higher values indicate a
+    #   smaller result, but longer compression time. Maximum
+    #   is 9.
+    #
+    # [check (:crc64)]
+    #   The checksum algorithm to use for verifying
+    #   the data inside the archive. Possible values are:
+    #   * :none
+    #   * :crc32
+    #   * :crc64
+    #   * :sha256
+    #
+    # [extreme (false)]
+    #   Tries to get the last bit out of the
+    #   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
+    # written. Otherwise, returns the compressed data as a
+    # BINARY-encoded string.
+    #
+    # === Example
+    #   data = File.read("file.txt")
+    #   i = StringIO.new(data)
+    #   XZ.compress_stream(i) #=> Some binary blob
+    #
+    #   i.rewind
+    #   str = ""
+    #
+    #   XZ.compress_stream(i, 4, :sha256){|c| str << c} #=> 123
+    #   str #=> Some binary blob
+    #
+    # === Remarks
+    #
+    # 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 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)
       raise(ArgumentError, "Invalid checksum specified!") unless [:none, :crc32, :crc64, :sha256].include?(check)
 
+      compression_level |= LibLZMA::LZMA_PRESET_EXTREME if extreme
+
       stream = LZMAStream.new
       res = LibLZMA.lzma_easy_encoder(stream.pointer,
-                                      compression_level | (extreme ? LibLZMA::LZMA_PRESET_EXTREME : 0),
+                                      compression_level,
                                       LibLZMA::LZMA_CHECK[:"lzma_check_#{check}"])
 
       LZMAError.raise_if_necessary(res)
@@ -178,20 +243,31 @@ module XZ
     end
     alias encode_stream compress_stream
 
-    #Compresses +in_file+ and writes the result to +out_file+.
-    #===Parameters
-    #[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.
-    #===Return value
-    #The number of bytes written, i.e. the size of the archive.
-    #===Example
-    #  XZ.compress("myfile.txt", "myfile.txt.xz")
-    #  XZ.compress("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.
+    # Compresses +in_file+ and writes the result to +out_file+.
+    #
+    # === Parameters
+    #
+    # [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.
+    #
+    # === Return value
+    #
+    # The number of bytes written, i.e. the size of the archive.
+    #
+    # === Example
+    #
+    #   XZ.compress("myfile.txt", "myfile.txt.xz")
+    #   XZ.compress("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)
       File.open(in_file, "rb") do |i_file|
         File.open(out_file, "wb") do |o_file|
@@ -202,56 +278,86 @@ module XZ
       end
     end
 
-    #Compresses arbitrary data using the XZ algorithm.
-    #===Parameters
-    #[str] The data to compress.
-    #For the other parameters, see the compress_stream method.
-    #===Return value
-    #The compressed data as a BINARY-encoded string.
-    #===Example
-    #  data = "I love Ruby"
-    #  comp = XZ.compress(data) #=> binary blob
-    #===Remarks
-    #Don't use this method for big amounts of data--you may run out of
-    #memory. Use compress_file or compress_stream instead.
+    # Compresses arbitrary data using the XZ algorithm.
+    #
+    # === Parameters
+    #
+    # [str] The data to compress.
+    #
+    # For the other parameters, see the compress_stream method.
+    #
+    # === Return value
+    #
+    # The compressed data as a BINARY-encoded string.
+    #
+    # === Example
+    #
+    #   data = "I love Ruby"
+    #   comp = XZ.compress(data) #=> binary blob
+    #
+    # === Remarks
+    #
+    # 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
       s = StringIO.new(str)
       compress_stream(s, compression_level, check, extreme)
     end
 
-    #Decompresses data in XZ format.
-    #===Parameters
-    #[str] The data to decompress.
-    #For the other parameters, see the decompress_stream method.
-    #===Return value
-    #The decompressed data as a BINARY-encoded string.
-    #===Example
-    #  comp = File.open("data.xz", "rb"){|f| f.read}
-    #  data = XZ.decompress(comp) #=> "I love Ruby"
-    #===Remarks
-    #Don't use this method for big amounts of data--you may run out of
-    #memory. Use decompress_file or decompress_stream instead.
+    # Decompresses data in XZ format.
+    #
+    # === Parameters
+    #
+    # [str] The data to decompress.
+    #
+    # For the other parameters, see the decompress_stream method.
+    #
+    # === Return value
+    #
+    # The decompressed data as a BINARY-encoded string.
+    #
+    # === Example
+    #
+    #   comp = File.open("data.xz", "rb"){|f| f.read}
+    #   data = XZ.decompress(comp) #=> "I love Ruby"
+    #
+    # === Remarks
+    #
+    # 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
       s = StringIO.new(str)
       decompress_stream(s, memory_limit, flags)
     end
 
-    #Decompresses +in_file+ and writes the result to +out_file+.
-    #===Parameters
-    #[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 decompress_stream method.
-    #===Return value
-    #The number of bytes written, i.e. the size of the uncompressed data.
-    #===Example
-    #  XZ.decompres("myfile.txt.xz", "myfile.txt")
-    #  XZ.decompress("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.
+    # Decompresses +in_file+ and writes the result to +out_file+.
+    #
+    # ===Parameters
+    #
+    # [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 decompress_stream method.
+    #
+    # === Return value
+    #
+    # The number of bytes written, i.e. the size of the uncompressed
+    # data.
+    #
+    # === Example
+    #
+    #   XZ.decompres("myfile.txt.xz", "myfile.txt")
+    #   XZ.decompress("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])
       File.open(in_file, "rb") do |i_file|
         File.open(out_file, "wb") do |o_file|
@@ -264,24 +370,20 @@ module XZ
 
     private
 
-    #This method returns the size of +str+ in bytes.
+    # 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
-      else
-        str.bytes.to_a.size
-      end
+      # 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 (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.
+    # 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
+    # (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)
@@ -289,24 +391,26 @@ module XZ
       while str = io.read(CHUNK_SIZE)
         input_buffer_p.write_string(str)
 
-        #Set the data for compressing
+        # Set the data for compressing
         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
-        #liblzma already set stream[:avail_in] to 0 in the first iteration, the extra call to the
-        #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).
+        # 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
+        # liblzma already set stream[:avail_in] to 0 in the first
+        # iteration, the extra call to the 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).
         loop do
-          #Prepare for getting the compressed_data
+          # Prepare for getting the compressed_data
           stream[:next_out]  = output_buffer_p
           stream[:avail_out] = CHUNK_SIZE
 
-          #Compress the data
+          # Compress the data
           res = if io.eof?
             LibLZMA.lzma_code(stream.pointer, LibLZMA::LZMA_ACTION[:lzma_finish])
           else
@@ -314,26 +418,27 @@ module XZ
           end
           check_lzma_code_retval(res)
 
-          #Write the compressed data
+          # Write the compressed data
           data = output_buffer_p.read_string(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.
+          # 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
         end #loop
       end #while
     end #lzma_code
 
-    #Checks for errors and warnings that can be derived from the return
-    #value of the lzma_code() function and shows them if necessary.
+    # Checks for errors and warnings that can be derived from the
+    # 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 not integrity checksum.")
+      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 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
@@ -343,6 +448,7 @@ module XZ
 
 end
 
+require_relative "xz/version"
 require_relative "xz/lib_lzma"
 require_relative "xz/stream"
 require_relative "xz/stream_writer"