gzipped_tar 0.0.4 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: c9020c4f3848255eb93c6dd596cfa4216346253e
-  data.tar.gz: 41c20c89d72237fec73913c44810769ea61a7e6d
+SHA256:
+  metadata.gz: ca76d13e235befa915315db06a2cf6e319686dc848c6bfbbd627d87c9021c90c
+  data.tar.gz: 35e618c62c9c440b74b17b6fcd0c1157f0898ae4ec428156b0273f3a4ff11cee
 SHA512:
-  metadata.gz: cea6867c8e703e071716760e0d7c9f00239fbe6fca68b9a53325ee4b0d5c0fe98a0b75a29e66afb549f401573e6da1eb153005edc9e2016e79c9e6b2cb9caa7c
-  data.tar.gz: 7f2a741f3c222085ac7b33112e5c0caa09270827971344e781d9476de92dd7e3b9462c6a9134a3ab4723df21ac12dd104e11003f79a0b58f3904054978b9a1d9
+  metadata.gz: bea79c295ca72b0c62d7bdb63a295c37e415135397d0f133ec9d639164219fd2d5f750c158f3975289dad08c8b75e388bca396dfecc1c627b6ad33628713d570
+  data.tar.gz: 1afb1ce58a5ecb2a3181788cb13375ae171d6890600b92ae71d7e456ad9fa05b8f78bd51afbac76a888f5b0e38015e7b49b7a0d279c67ecfac8554a4bff41b71

data/.rubocop.yml

@@ -4,6 +4,12 @@ inherit_from:
 AllCops:
   TargetRubyVersion: 2.1
 
+Performance/RedundantBlockCall:
+  Enabled: false
+
+Style/AsciiComments:
+  Enabled: false
+
 Style/Documentation:
   Enabled: false
 

data/.travis.yml

@@ -5,7 +5,8 @@ rvm:
 - 1.9.3
 - 2.0
 - 2.1.10
-- 2.2.8
-- 2.3.5
-- 2.4.2
+- 2.2.9
+- 2.3.6
+- 2.4.3
+- 2.5.0
 - jruby-9.1.14.0

data/README.md

@@ -5,7 +5,7 @@ A simple interface for reading and writing gzipped tar files (.tar.gz) in memory
 ## Installation
 
 ```ruby
-gem "gzipped_tar", "~> 0.0.4"
+gem "gzipped_tar", "~> 0.1.0"
 ```
 
 ## Usage

data/gzipped_tar.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |spec|
   spec.name          = "gzipped_tar"
-  spec.version       = "0.0.4"
+  spec.version       = "0.1.0"
   spec.authors       = ["Pat Allan"]
   spec.email         = ["pat@freelancing-gods.com"]
 

data/lib/gzipped_tar.rb

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
+require "digest"
+
 module GZippedTar
   #
 end
 
+require "gzipped_tar/tar"
 require "gzipped_tar/reader"
 require "gzipped_tar/writer"

data/lib/gzipped_tar/reader.rb

@@ -20,7 +20,7 @@ module GZippedTar
     attr_reader :raw
 
     def reader
-      Gem::Package::TarReader.new unzipped
+      GZippedTar::Tar::Reader.new unzipped
     end
 
     def unzipped

data/lib/gzipped_tar/tar.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module GZippedTar
+  module Tar
+    ROW_WIDTH = 512
+    EMPTY_ROW = "\0" * ROW_WIDTH
+
+    Error = Class.new StandardError
+
+    FileOverflow    = Class.new Error
+    NonSeekableIO   = Class.new Error
+    TarInvalidError = Class.new Error
+    TooLongFileName = Class.new Error
+    UnexpectedEOF   = Class.new Error
+  end
+end
+
+require "gzipped_tar/tar/bounded_stream"
+require "gzipped_tar/tar/digest_io"
+require "gzipped_tar/tar/entry"
+require "gzipped_tar/tar/field"
+require "gzipped_tar/tar/checksum_field"
+require "gzipped_tar/tar/header"
+require "gzipped_tar/tar/reader"
+require "gzipped_tar/tar/restricted_stream"
+require "gzipped_tar/tar/split_name"
+require "gzipped_tar/tar/writer"
+require "gzipped_tar/tar/write_file"
+require "gzipped_tar/tar/write_signed_file"

data/lib/gzipped_tar/tar/bounded_stream.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+#--
+# Original source is copyright (C) 2004 Mauricio Julio Fernández Pradier
+# This file has been copied and adapted to avoid reliance on differing
+# behaviour across versions of rubygems, and to handle nil header values at
+# the end of a file.
+#++
+
+class GZippedTar::Tar::BoundedStream
+  # Maximum number of bytes that can be written
+  attr_reader :limit
+
+  # Number of bytes written
+  attr_reader :written
+
+  # Wraps +io+ and allows up to +limit+ bytes to be written
+  def initialize(io, limit)
+    @io = io
+    @limit = limit
+    @written = 0
+  end
+
+  # Writes +data+ onto the IO, raising a FileOverflow exception if the
+  # number of bytes will be more than #limit
+  def write(data)
+    if data.bytesize + @written > @limit
+      raise GZippedTar::Tar::FileOverflow,
+        "You tried to feed more data than fits in the file."
+    end
+    @io.write data
+    @written += data.bytesize
+    data.bytesize
+  end
+end

data/lib/gzipped_tar/tar/checksum_field.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class GZippedTar::Tar::ChecksumField < GZippedTar::Tar::Field
+  EMPTY_VALUE = [" " * 8, " "].freeze
+
+  def pack
+    "a7a"
+  end
+
+  def unpack
+    "A8"
+  end
+
+  def to_s(value)
+    return EMPTY_VALUE if value.nil?
+
+    [format("%06o", value), " "]
+  end
+end

data/lib/gzipped_tar/tar/digest_io.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+#--
+# Original source is from Rubygems.
+# This file has been copied and adapted to avoid reliance on differing
+# behaviour across versions of rubygems, and to handle nil header values at
+# the end of a file.
+#++
+
+# IO wrapper that creates digests of contents written to the IO it wraps.
+class GZippedTar::Tar::DigestIO
+  # Collected digests for wrapped writes.
+  #
+  #   {
+  #     'SHA1'   => #<OpenSSL::Digest: [...]>,
+  #     'SHA512' => #<OpenSSL::Digest: [...]>,
+  #   }
+  attr_reader :digests
+
+  # Wraps +io+ and updates digest for each of the digest algorithms in
+  # the +digests+ Hash.  Returns the digests hash.  Example:
+  #
+  #   io = StringIO.new
+  #   digests = {
+  #     'SHA1'   => OpenSSL::Digest.new('SHA1'),
+  #     'SHA512' => OpenSSL::Digest.new('SHA512'),
+  #   }
+  #
+  #   GZippedTar::Tar::DigestIO.wrap io, digests do |digest_io|
+  #     digest_io.write "hello"
+  #   end
+  #
+  #   digests['SHA1'].hexdigest   #=> "aaf4c61d[...]"
+  #   digests['SHA512'].hexdigest #=> "9b71d224[...]"
+  def self.wrap(io, digests)
+    digest_io = new io, digests
+
+    yield digest_io
+
+    digests
+  end
+
+  # Creates a new DigestIO instance.  Using ::wrap is recommended, see the
+  # ::wrap documentation for documentation of +io+ and +digests+.
+  def initialize(io, digests)
+    @io = io
+    @digests = digests
+  end
+
+  # Writes +data+ to the underlying IO and updates the digests
+  def write(data)
+    result = @io.write data
+
+    @digests.each_value do |digest|
+      digest << data
+    end
+
+    result
+  end
+end

data/lib/gzipped_tar/tar/entry.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+#++
+# Original source is copyright (C) 2004 Mauricio Julio Fernández Pradier
+# This file has been copied and adapted to avoid reliance on differing
+# behaviour across versions of rubygems, and to handle nil header values at
+# the end of a file.
+#--
+
+class GZippedTar::Tar::Entry
+  attr_reader :header
+
+  # Creates a new tar entry for +header+ that will be read from +io+
+  def initialize(header, io)
+    @closed = false
+    @header = header
+    @io = io
+    @orig_pos = @io.pos
+    @read = 0
+  end
+
+  def check_closed # :nodoc:
+    raise IOError, "closed #{self.class}" if closed?
+  end
+
+  # Number of bytes read out of the tar entry
+  def bytes_read
+    @read
+  end
+
+  # Closes the tar entry
+  def close
+    @closed = true
+  end
+
+  # Is the tar entry closed?
+  def closed?
+    @closed
+  end
+
+  # Are we at the end of the tar entry?
+  def eof?
+    check_closed
+
+    @read >= @header.size
+  end
+
+  # Full name of the tar entry
+  def full_name
+    if @header.prefix != ""
+      File.join @header.prefix, @header.name
+    else
+      @header.name
+    end
+  rescue ArgumentError => e
+    raise unless e.message == "string contains null byte"
+    raise GZippedTar::Tar::TarInvalidError,
+      "tar is corrupt, name contains null byte"
+  end
+
+  # Read one byte from the tar entry
+  def getc
+    check_closed
+
+    return nil if @read >= @header.size
+
+    ret = @io.getc
+    @read += 1 if ret
+
+    ret
+  end
+
+  # Is this tar entry a directory?
+  def directory?
+    @header.typeflag == "5"
+  end
+
+  # Is this tar entry a file?
+  def file?
+    @header.typeflag == "0"
+  end
+
+  # Is this tar entry a symlink?
+  def symlink?
+    @header.typeflag == "2"
+  end
+
+  # The position in the tar entry
+  def pos
+    check_closed
+
+    bytes_read
+  end
+
+  # Reads +len+ bytes from the tar file entry, or the rest of the entry if
+  # nil
+  def read(len = nil)
+    check_closed
+
+    return nil if @read >= @header.size
+
+    len ||= @header.size - @read
+    max_read = [len, @header.size - @read].min
+
+    ret = @io.read max_read
+    @read += ret.size
+
+    ret
+  end
+
+  alias readpartial read # :nodoc:
+
+  # Rewinds to the beginning of the tar file entry
+  def rewind
+    check_closed
+
+    raise GZippedTar::Tar::NonSeekableIO unless @io.respond_to? :pos=
+
+    @io.pos = @orig_pos
+    @read = 0
+  end
+end

data/lib/gzipped_tar/tar/field.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+class GZippedTar::Tar::Field
+  attr_reader :name, :length, :octal, :required, :default
+
+  def initialize(name, length, options = {})
+    @name     = name
+    @length   = length
+    @octal    = options[:octal]
+    @required = options[:required]
+    @default  = options[:default]
+  end
+
+  def octal?
+    octal
+  end
+
+  def pack
+    return "a" if length == 1
+
+    "a#{length}"
+  end
+
+  def required?
+    required
+  end
+
+  def to_s(value)
+    return value unless octal?
+
+    if length == 2
+      format "%0#{length}o", value
+    else
+      format "%0#{length - 1}o", value
+    end
+  end
+
+  def translate(value)
+    value ||= default
+
+    return value unless octal? && value.is_a?(String)
+    return value.oct if value[/\A[0-7]*\z/]
+
+    raise ArgumentError, "#{value.inspect} is not an octal string"
+  end
+
+  def unpack
+    return "A" if length == 1
+
+    "A#{length}"
+  end
+end

data/lib/gzipped_tar/tar/header.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+#++
+# Original source is copyright (C) 2004 Mauricio Julio Fernández Pradier
+# This file has been copied and adapted to avoid reliance on differing
+# behaviour across versions of rubygems, and to handle nil header values at
+# the end of a file.
+#--
+
+##
+#--
+# struct tarfile_entry_posix {
+#   char name[100];     # ASCII + (Z unless filled)
+#   char mode[8];       # 0 padded, octal, null
+#   char uid[8];        # ditto
+#   char gid[8];        # ditto
+#   char size[12];      # 0 padded, octal, null
+#   char mtime[12];     # 0 padded, octal, null
+#   char checksum[8];   # 0 padded, octal, null, space
+#   char typeflag[1];   # file: "0"  dir: "5"
+#   char linkname[100]; # ASCII + (Z unless filled)
+#   char magic[6];      # "ustar\0"
+#   char version[2];    # "00"
+#   char uname[32];     # ASCIIZ
+#   char gname[32];     # ASCIIZ
+#   char devmajor[8];   # 0 padded, octal, null
+#   char devminor[8];   # o padded, octal, null
+#   char prefix[155];   # ASCII + (Z unless filled)
+# };
+#++
+# A header for a tar file
+
+class GZippedTar::Tar::Header
+  Field         = GZippedTar::Tar::Field
+  ChecksumField = GZippedTar::Tar::ChecksumField
+
+  # rubocop:disable Layout/ExtraSpacing
+  FIELDS = [
+    Field.new(:name,     100, :required => true),
+    Field.new(:mode,      8, :required => true, :octal => true),
+    Field.new(:uid,       8, :default => 0, :octal => true),
+    Field.new(:gid,       8, :default => 0, :octal => true),
+    Field.new(:size,     12, :required => true, :octal => true),
+    Field.new(:mtime,    12, :default => 0, :octal => true),
+    # Custom behaviour for the checksum:
+    ChecksumField.new(:checksum, 8, :octal => true),
+    # And back to normal:
+    Field.new(:typeflag,   1, :default => "0"),
+    Field.new(:linkname, 100),
+    Field.new(:magic,      6, :default => "ustar"),
+    Field.new(:version,    2, :default => "00", :octal => true),
+    Field.new(:uname,     32, :default => "wheel"),
+    Field.new(:gname,     32, :default => "wheel"),
+    Field.new(:devmajor,   8, :default => 0, :octal => true),
+    Field.new(:devminor,   8, :default => 0, :octal => true),
+    Field.new(:prefix,   155, :required => true)
+  ].freeze
+  # rubocop:enable Layout/ExtraSpacing
+
+  PACK_FORMAT    = FIELDS.collect(&:pack).join("")
+  UNPACK_FORMAT  = FIELDS.collect(&:unpack).join("")
+  HEADER_LENGTH  = 512
+  BLANK          = {
+    :name   => "",
+    :size   => "0",
+    :prefix => "",
+    :mode   => "644",
+    :empty  => true
+  }.freeze
+
+  # Creates a tar header from IO +stream+
+  def self.from(stream)
+    header = stream.read HEADER_LENGTH
+    return new(BLANK) if header.nil?
+
+    empty = (header == "\0" * HEADER_LENGTH)
+
+    new values_from_array(header.unpack(UNPACK_FORMAT)).merge(:empty => empty)
+  end
+
+  def self.values_from_array(values)
+    hash = {}
+
+    FIELDS.each_with_index do |field, index|
+      hash[field.name] = field.translate values[index]
+    end
+
+    hash
+  end
+
+  def initialize(values)
+    validate values
+
+    @empty  = values.delete :empty
+    @values = FIELDS.inject({}) do |hash, field|
+      hash[field.name] = field.translate values[field.name]
+      hash
+    end
+
+    @values[:typeflag] = "0" if @values[:typeflag].empty?
+  end
+
+  def ==(other) # :nodoc:
+    other.is_a?(self.class) &&
+      FIELDS.all? { |field| values[field.name] == other.values[field.name] }
+  end
+
+  def empty?
+    @empty
+  end
+
+  def name
+    @values[:name]
+  end
+
+  def prefix
+    @values[:prefix]
+  end
+
+  def size
+    values[:size]
+  end
+
+  def to_s # :nodoc:
+    update_checksum
+    build_header
+  end
+
+  protected
+
+  attr_reader :values
+
+  private
+
+  def calculate_checksum(header)
+    header.unpack("C*").inject { |a, b| a + b }
+  end
+
+  def build_header
+    header = header_values.pack PACK_FORMAT
+
+    header + ("\0" * ((HEADER_LENGTH - header.size) % HEADER_LENGTH))
+  end
+
+  def header_values
+    FIELDS.collect { |field| field.to_s values[field.name] }.flatten
+  end
+
+  def update_checksum
+    values[:checksum] = nil
+    values[:checksum] = calculate_checksum(build_header)
+  end
+
+  def validate(values)
+    FIELDS.select(&:required?).each do |field|
+      next if values[field.name]
+
+      raise ArgumentError, ":name, :size, :prefix and :mode required"
+    end
+  end
+end

data/lib/gzipped_tar/tar/reader.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+#--
+# Original source is copyright (C) 2004 Mauricio Julio Fernández Pradier
+# This file has been copied and adapted to avoid reliance on differing
+# behaviour across versions of rubygems, and to handle nil header values at
+# the end of a file.
+#++
+
+class GZippedTar::Tar::Reader
+  include Enumerable
+
+  ##
+  # Creates a new TarReader on +io+ and yields it to the block, if given.
+
+  def self.new(io)
+    reader = super
+
+    return reader unless block_given?
+
+    begin
+      yield reader
+    ensure
+      reader.close
+    end
+
+    nil
+  end
+
+  # Creates a new tar file reader on +io+ which needs to respond to #pos,
+  # #eof?, #read, #getc and #pos=
+  def initialize(io)
+    @io       = io
+    @init_pos = io.pos
+  end
+
+  # Close the tar file
+  def close; end
+
+  # Iterates over files in the tarball yielding each entry
+  def each
+    return enum_for __method__ unless block_given?
+
+    until @io.eof?
+      header = GZippedTar::Tar::Header.from @io
+      return if header.empty?
+      entry = GZippedTar::Tar::Entry.new header, @io
+
+      yield entry
+
+      skip_past_entry header.size, entry.bytes_read
+      skip_past_trailing header.size
+
+      # make sure nobody can use #read, #getc or #rewind anymore
+      entry.close
+    end
+  end
+
+  alias each_entry each
+
+  # NOTE: Do not call #rewind during #each
+  def rewind
+    if @init_pos.zero?
+      raise GZippedTar::Tar::NonSeekableIO unless @io.respond_to? :rewind
+      @io.rewind
+    else
+      raise GZippedTar::Tar::NonSeekableIO unless @io.respond_to? :pos=
+      @io.pos = @init_pos
+    end
+  end
+
+  # Seeks through the tar file until it finds the +entry+ with +name+ and
+  # yields it.  Rewinds the tar file to the beginning when the block
+  # terminates.
+  def seek(name)
+    found = find do |entry|
+      entry.full_name == name
+    end
+
+    return unless found
+
+    return yield found
+  ensure
+    rewind
+  end
+
+  private
+
+  attr_reader :io
+
+  def skip_past_entry(size, read)
+    # skip over the rest of the entry
+    pending = size - read
+
+    skip_by_seek
+  rescue Errno::EINVAL, NameError
+    skip_by_read pending
+  end
+
+  def skip_by_read(pending)
+    while pending > 0
+      bytes_read = io.read([pending, 4096].min).size
+      pending -= bytes_read
+      raise GZippedTar::Tar::UnexpectedEOF if io.eof? && !pending.zero?
+    end
+  end
+
+  def skip_by_seek
+    # avoid reading...
+    io.seek pending, IO::SEEK_CUR
+  end
+
+  def skip_past_trailing(size)
+    # discard trailing zeros
+    skip = (512 - (size % 512)) % 512
+
+    skip_by_read skip
+  end
+end

data/lib/gzipped_tar/tar/restricted_stream.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+#--
+# Original source is copyright (C) 2004 Mauricio Julio Fernández Pradier
+# This file has been copied and adapted to avoid reliance on differing
+# behaviour across versions of rubygems, and to handle nil header values at
+# the end of a file.
+#++
+
+# IO wrapper that provides only #write
+class GZippedTar::Tar::RestrictedStream
+  # Creates a new RestrictedStream wrapping +io+
+  def initialize(io)
+    @io = io
+  end
+
+  # Writes +data+ onto the IO
+  def write(data)
+    @io.write data
+  end
+end

data/lib/gzipped_tar/tar/split_name.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+class GZippedTar::Tar::SplitName
+  MAXIMUM_LENGTH      = 256
+  MAXIMUM_NAME_LENGTH = 100
+  MAXIMUM_PATH_LENGTH = 155
+
+  def self.call(file)
+    new(file).call
+  end
+
+  def initialize(file)
+    @file = file
+  end
+
+  def call
+    return ["", file] unless split?
+
+    raise_if_too_long file,   MAXIMUM_LENGTH,      "path"
+    raise_if_too_long name,   MAXIMUM_NAME_LENGTH, "name"
+    raise_if_too_long prefix, MAXIMUM_PATH_LENGTH, "base path"
+
+    [prefix, name]
+  end
+
+  private
+
+  attr_reader :file
+
+  def last_prefix_index
+    @last_prefix_index ||= begin
+      index = parts.length - 2
+      index -= 1 while parts[0..index].join("/").bytesize >= MAXIMUM_PATH_LENGTH
+      index
+    end
+  end
+
+  def name
+    parts[(last_prefix_index + 1)..-1].join("/")
+  end
+
+  def parts
+    @parts ||= file.split "/", -1
+  end
+
+  def prefix
+    parts[0..last_prefix_index].join("/")
+  end
+
+  def raise_if_too_long(string, maximum, description)
+    return if string.bytesize <= maximum
+
+    raise GZippedTar::Tar::TooLongFileName,
+      "File \"#{string}\" has a too long #{description} (should be " \
+      "#{maximum} or less)"
+  end
+
+  # If the file is less than MAXIMUM_NAME_LENGTH, it doesn't need to be split,
+  # and the prefix can be blank.
+  def split?
+    file.bytesize > MAXIMUM_NAME_LENGTH
+  end
+
+  def too_long?
+    file.bytesize > 256
+  end
+end

data/lib/gzipped_tar/tar/write_file.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+class GZippedTar::Tar::WriteFile
+  def self.call(writer, io, name, mode, &block)
+    new(writer, io, name, mode).call(&block)
+  end
+
+  def initialize(writer, io, name, mode)
+    @writer  = writer
+    @io      = io
+    @name    = name
+    @mode    = mode
+    @initial = io.pos
+  end
+
+  def call(&block)
+    # placeholder for the header
+    io.write GZippedTar::Tar::EMPTY_ROW
+
+    block.call GZippedTar::Tar::RestrictedStream.new(io) if block
+
+    writer.pad_rows size
+    overwrite_header
+  end
+
+  private
+
+  attr_reader :writer, :io, :name, :mode, :initial
+
+  def overwrite_header
+    current_position = io.pos
+    io.pos = initial
+
+    writer.write_header name, mode, :size => size
+
+    io.pos = current_position
+  end
+
+  def size
+    @size ||= io.pos - initial - GZippedTar::Tar::ROW_WIDTH
+  end
+end

data/lib/gzipped_tar/tar/write_signed_file.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+class GZippedTar::Tar::WriteSignedFile
+  def self.call(writer, name, mode, signer, &block)
+    new(writer, name, mode, signer).call(&block)
+  end
+
+  def initialize(writer, name, mode, signer)
+    @writer = writer
+    @name   = name
+    @mode   = mode
+    @signer = signer
+  end
+
+  def call(&block)
+    add_file_digest(&block)
+
+    raise "no #{signer.digest_name} in #{digests.values.compact}" unless digest
+
+    write_signature if signer.key
+
+    digests
+  end
+
+  private
+
+  attr_reader :writer, :name, :mode, :signer
+
+  def add_file_digest(&block)
+    writer.add_file name, mode do |io|
+      GZippedTar::Tar::DigestIO.wrap io, digests, &block
+    end
+  end
+
+  def algorithms
+    [
+      signer.digest_algorithm,
+      Digest::SHA512
+    ].compact.uniq
+  end
+
+  def digest
+    @digest ||= digests.values.compact.detect do |digest|
+      digest_name(digest) == signer.digest_name
+    end
+  end
+
+  def digests
+    @digests ||= begin
+      digests = algorithms.collect(&:new).collect do |digest|
+        [digest_name(digest), digest]
+      end
+
+      Hash[*digests.flatten]
+    end
+  end
+
+  def digest_name(instance)
+    if instance.respond_to? :name
+      instance.name
+    else
+      instance.class.name[/::([^:]+)$/, 1]
+    end
+  end
+
+  def write_signature
+    signature = signer.sign digest.digest
+
+    writer.add_file_simple "#{name}.sig", 0o444, signature.length do |io|
+      io.write signature
+    end
+  end
+end

data/lib/gzipped_tar/tar/writer.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+#--
+# Original source is copyright (C) 2004 Mauricio Julio Fernández Pradier
+# This file has been copied and adapted to avoid reliance on differing
+# behaviour across versions of rubygems, and to handle nil header values at
+# the end of a file.
+#++
+
+class GZippedTar::Tar::Writer
+  ROW_WIDTH = GZippedTar::Tar::ROW_WIDTH
+
+  def self.new(io)
+    writer = super
+
+    return writer unless block_given?
+
+    begin
+      yield writer
+    ensure
+      writer.close
+    end
+
+    nil
+  end
+
+  # Creates a new TarWriter that will write to +io+
+  def initialize(io)
+    raise GZippedTar::Tar::NonSeekableIO unless io.respond_to? :pos=
+
+    @io     = io
+    @closed = false
+  end
+
+  # Adds file +name+ with permissions +mode+, and yields an IO for writing the
+  # file to.
+  def add_file(name, mode, &block)
+    check_closed
+
+    GZippedTar::Tar::WriteFile.call self, io, name, mode, &block
+
+    self
+  end
+
+  # Adds +name+ with permissions +mode+ to the tar, yielding +io+ for writing
+  # the file.  The +signer+ is used to add a digest file using its
+  # digest_algorithm per add_file_digest and a cryptographic signature in
+  # +name+.sig.  If the signer has no key only the checksum file is added.
+  #
+  # Returns the digest.
+  def add_file_signed(name, mode, signer, &block)
+    GZippedTar::Tar::WriteSignedFile.call self, name, mode, signer, &block
+  end
+
+  # Add file +name+ with permissions +mode+ +size+ bytes long.  Yields an IO
+  # to write the file to.
+  def add_file_simple(name, mode, size)
+    write_header name, mode, :size => size
+
+    stream = GZippedTar::Tar::BoundedStream.new io, size
+
+    yield stream if block_given?
+
+    min_padding = size - stream.written
+    io.write("\0" * min_padding)
+
+    pad_rows size
+
+    self
+  end
+
+  # Adds symlink +name+ with permissions +mode+, linking to +target+.
+  def add_symlink(name, target, mode)
+    write_header name, mode, :typeflag => "2", :linkname => target
+  end
+
+  # Closes the TarWriter
+  def close
+    check_closed
+
+    io.write GZippedTar::Tar::EMPTY_ROW
+    io.write GZippedTar::Tar::EMPTY_ROW
+    flush
+
+    @closed = true
+  end
+
+  # Is the TarWriter closed?
+  def closed?
+    @closed
+  end
+
+  # Flushes the TarWriter's IO
+  def flush
+    check_closed
+
+    io.flush if io.respond_to? :flush
+  end
+
+  # Creates a new directory in the tar file +name+ with +mode+
+  def mkdir(name, mode)
+    write_header name, mode, :typeflag => "5"
+  end
+
+  def pad_rows(size)
+    remainder = (ROW_WIDTH - (size % ROW_WIDTH)) % ROW_WIDTH
+
+    io.write "\0" * remainder
+  end
+
+  def write_header(name, mode, options = {})
+    check_closed
+
+    prefix, name = GZippedTar::Tar::SplitName.call name
+
+    io.write GZippedTar::Tar::Header.new({
+      :name   => name,
+      :mode   => mode,
+      :prefix => prefix,
+      :size   => 0,
+      :mtime  => Time.now
+    }.merge(options))
+
+    self
+  end
+
+  private
+
+  attr_reader :io
+
+  # Raises IOError if the TarWriter is closed
+  def check_closed
+    raise IOError, "closed #{self.class}" if closed?
+  end
+end

data/lib/gzipped_tar/writer.rb

@@ -32,7 +32,7 @@ module GZippedTar
     end
 
     def writer
-      @writer ||= Gem::Package::TarWriter.new input_io
+      @writer ||= GZippedTar::Tar::Writer.new input_io
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gzipped_tar
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.0
 platform: ruby
 authors:
 - Pat Allan
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-12-14 00:00:00.000000000 Z
+date: 2018-03-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -58,6 +58,19 @@ files:
 - gzipped_tar.gemspec
 - lib/gzipped_tar.rb
 - lib/gzipped_tar/reader.rb
+- lib/gzipped_tar/tar.rb
+- lib/gzipped_tar/tar/bounded_stream.rb
+- lib/gzipped_tar/tar/checksum_field.rb
+- lib/gzipped_tar/tar/digest_io.rb
+- lib/gzipped_tar/tar/entry.rb
+- lib/gzipped_tar/tar/field.rb
+- lib/gzipped_tar/tar/header.rb
+- lib/gzipped_tar/tar/reader.rb
+- lib/gzipped_tar/tar/restricted_stream.rb
+- lib/gzipped_tar/tar/split_name.rb
+- lib/gzipped_tar/tar/write_file.rb
+- lib/gzipped_tar/tar/write_signed_file.rb
+- lib/gzipped_tar/tar/writer.rb
 - lib/gzipped_tar/writer.rb
 homepage: https://github.com/pat/gzipped_tar
 licenses:
@@ -79,7 +92,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: In-memory reading/writing of .tar.gz files