ruby-xz 0.2.2 → 1.0.2

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.
@@ -48,17 +41,6 @@ module XZ
 
   class << self
 
-    # :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,
@@ -69,18 +51,34 @@ module XZ
       @disable_deprecation_notices = bool
     end
 
+    # Output a deprecation notice.
+    def deprecate(msg) # :nodoc:
+      @disable_deprecation_notices ||= false
+
+      unless @disable_deprecation_notices
+        $stderr.puts("DEPRECATION NOTICE: #{msg}\n#{caller.drop(1).join("\n\t")}")
+      end
+    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
@@ -98,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
     #
@@ -108,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}
@@ -127,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|
@@ -136,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)
 
@@ -146,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.
+    #
+    # ==== Keyword arguments
+    # All keyword arguments are optional.
     #
-    # [compression_level (6)]
+    # [level (6)]
     #   Compression strength. Higher values indicate a
     #   smaller result, but longer compression time. Maximum
     #   is 9.
@@ -189,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
@@ -206,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
@@ -216,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)
 
@@ -237,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
 
@@ -253,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
     #
@@ -261,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
@@ -284,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
     #
@@ -299,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.
@@ -311,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
     #
@@ -326,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+.
@@ -342,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
     #
@@ -351,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
@@ -370,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
@@ -407,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
@@ -434,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
@@ -449,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"

metadata

@@ -1,87 +1,96 @@
 --- !ruby/object:Gem::Specification
 name: ruby-xz
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 1.0.2
 platform: ruby
 authors:
 - Marvin Gülker
-autorequire: 
+- Alex Gittemeier
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-12-27 00:00:00.000000000 Z
+date: 2021-11-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: ffi
+  name: minitar
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.9'
-  type: :runtime
+        version: '0.6'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.9'
+        version: '0.6'
 - !ruby/object:Gem::Dependency
-  name: io-like
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
-  type: :runtime
+        version: '5.14'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: '5.14'
 - !ruby/object:Gem::Dependency
-  name: archive-tar-minitar
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.5'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.5'
+        version: '13.0'
 description: |
   These are simple Ruby bindings for the liblzma library
   (http://tukaani.org/xz/), which is best known for the
   extreme compression ratio its native XZ format achieves.
-  Since FFI is used to implement the bindings, no compilation
-  is needed and they should work with JRuby as well.
-email: quintus@quintilianus.eu
+  Since fiddle is used to implement the bindings, no compilation
+  is needed.
+email: me@a.lexg.dev
 executables: []
 extensions: []
 extra_rdoc_files:
 - README.md
 - HISTORY.rdoc
-- COPYING
+- LICENSE
 - AUTHORS
 files:
 - AUTHORS
-- COPYING
 - HISTORY.rdoc
+- LICENSE
 - README.md
 - lib/xz.rb
+- lib/xz/fiddle_helper.rb
 - lib/xz/lib_lzma.rb
 - lib/xz/stream.rb
 - lib/xz/stream_reader.rb
 - lib/xz/stream_writer.rb
 - lib/xz/version.rb
-homepage: http://quintus.github.io/ruby-xz
+homepage: https://github.com/win93/ruby-xz
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+metadata:
+  homepage_uri: https://github.com/win93/ruby-xz
+  source_code_uri: https://github.com/win93/ruby-xz/tree/stable
+  documentation_uri: https://www.rubydoc.info/gems/ruby-xz
+  bug_tracker_uri: https://github.com/win93/ruby-xz/issues
+  changelog_uri: https://github.com/win93/ruby-xz/blob/stable/HISTORY.rdoc
+  rubygems_mfa_required: 'true'
+post_install_message: Version 1.0.0 of ruby-xz breaks the API. Read HISTORY.rdoc and
+  adapt your code to the new API.
 rdoc_options:
 - "-t"
 - ruby-xz RDocs
@@ -93,16 +102,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.9.3
+      version: 2.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.5.1
-signing_key: 
+rubygems_version: 3.2.22
+signing_key:
 specification_version: 4
-summary: XZ compression via liblzma for Ruby, using ffi.
+summary: XZ compression via liblzma for Ruby, using fiddle.
 test_files: []

data/COPYING

@@ -1,26 +0,0 @@
-(The MIT License)
-
-Basic liblzma-bindings for Ruby.
-
-Copyright © 2011-2014 Marvin Gülker et al.
-
-See the file `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.