gel 0.2.0

data/lib/gel/support/tar/tar_reader.rb

@@ -0,0 +1,123 @@
+# -*- coding: utf-8 -*-
+# frozen_string_literal: true
+#--
+# Copyright (C) 2004 Mauricio Julio Fernández Pradier
+# Redistributed under the terms of the MIT license.
+#++
+
+##
+# TarReader reads tar files and allows iteration over their items
+
+class Gel::Support::Tar::TarReader
+
+  include Enumerable
+
+  ##
+  # Raised if the tar IO is not seekable
+
+  class UnexpectedEOF < StandardError; end
+
+  ##
+  # 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? do
+      header = Gel::Support::Tar::TarHeader.from @io
+      return if header.empty?
+
+      entry = Gel::Support::Tar::TarReader::Entry.new header, @io
+      size = entry.header.size
+
+      yield entry
+
+      skip = (512 - (size % 512)) % 512
+      pending = size - entry.bytes_read
+
+      begin
+        # avoid reading...
+        @io.seek pending, IO::SEEK_CUR
+        pending = 0
+      rescue Errno::EINVAL, NameError
+        while pending > 0 do
+          bytes_read = @io.read([pending, 4096].min).size
+          raise UnexpectedEOF if @io.eof?
+          pending -= bytes_read
+        end
+      end
+
+      @io.read skip # discard trailing zeros
+
+      # 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 == 0 then
+      raise Gel::Support::Tar::NonSeekableIO unless @io.respond_to? :rewind
+      @io.rewind
+    else
+      raise Gel::Support::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 # :yields: entry
+    found = find do |entry|
+      entry.full_name == name
+    end
+
+    return unless found
+
+    return yield found
+  ensure
+    rewind
+  end
+
+end
+
+require_relative "tar_reader/entry"

data/lib/gel/support/tar/tar_reader/entry.rb

@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+# frozen_string_literal: true
+#++
+# Copyright (C) 2004 Mauricio Julio Fernández Pradier
+# Redistributed under the terms of the MIT license.
+#--
+
+##
+# Class for reading entries out of a tar file
+
+class Gel::Support::Tar::TarReader::Entry
+
+  ##
+  # Header for this 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 != "" then
+      File.join @header.prefix, @header.name
+    else
+      @header.name
+    end
+  rescue ArgumentError => e
+    raise unless e.message == 'string contains null byte'
+    raise Gel::Support::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 Gel::Support::Tar::NonSeekableIO unless @io.respond_to? :pos=
+
+    @io.pos = @orig_pos
+    @read = 0
+  end
+
+end

data/lib/gel/support/tar/tar_writer.rb

@@ -0,0 +1,339 @@
+# -*- coding: utf-8 -*-
+# frozen_string_literal: true
+#--
+# Copyright (C) 2004 Mauricio Julio Fernández Pradier
+# Redistributed under the terms of the MIT license.
+#++
+
+require 'digest'
+
+##
+# Allows writing of tar files
+
+class Gel::Support::Tar::TarWriter
+
+  class FileOverflow < StandardError; end
+
+  ##
+  # IO wrapper that allows writing a limited amount of data
+
+  class 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 FileOverflow, "You tried to feed more data than fits in the file."
+      end
+      @io.write data
+      @written += data.bytesize
+      data.bytesize
+    end
+
+  end
+
+  ##
+  # IO wrapper that provides only #write
+
+  class 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
+
+  ##
+  # Creates a new TarWriter, yielding it if a block is given
+
+  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)
+    @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) # :yields: io
+    check_closed
+
+    raise Gel::Support::Tar::NonSeekableIO unless @io.respond_to? :pos=
+
+    name, prefix = split_name name
+
+    init_pos = @io.pos
+    @io.write "\0" * 512 # placeholder for the header
+
+    yield RestrictedStream.new(@io) if block_given?
+
+    size = @io.pos - init_pos - 512
+
+    remainder = (512 - (size % 512)) % 512
+    @io.write "\0" * remainder
+
+    final_pos = @io.pos
+    @io.pos = init_pos
+
+    header = Gel::Support::Tar::TarHeader.new :name => name, :mode => mode,
+                                         :size => size, :prefix => prefix,
+                                         :mtime => Time.now
+
+    @io.write header
+    @io.pos = final_pos
+
+    self
+  end
+
+  ##
+  # Adds +name+ with permissions +mode+ to the tar, yielding +io+ for writing
+  # the file.  The +digest_algorithm+ is written to a read-only +name+.sum
+  # file following the given file contents containing the digest name and
+  # hexdigest separated by a tab.
+  #
+  # The created digest object is returned.
+
+  def add_file_digest name, mode, digest_algorithms # :yields: io
+    digests = digest_algorithms.map do |digest_algorithm|
+      digest = digest_algorithm.new
+      digest_name =
+        if digest.respond_to? :name then
+          digest.name
+        else
+          /::([^:]+)$/ =~ digest_algorithm.name
+          $1
+        end
+
+      [digest_name, digest]
+    end
+
+    digests = Hash[*digests.flatten]
+
+    add_file name, mode do |io|
+      Gel::Support::Tar::DigestIO.wrap io, digests do |digest_io|
+        yield digest_io
+      end
+    end
+
+    digests
+  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
+    digest_algorithms = [
+      signer.digest_algorithm,
+      Digest::SHA512,
+    ].compact.uniq
+
+    digests = add_file_digest name, mode, digest_algorithms do |io|
+      yield io
+    end
+
+    signature_digest = digests.values.compact.find do |digest|
+      digest_name =
+        if digest.respond_to? :name then
+          digest.name
+        else
+          /::([^:]+)$/ =~ digest.class.name
+          $1
+        end
+
+      digest_name == signer.digest_name
+    end
+
+    if signer.key then
+      signature = signer.sign signature_digest.digest
+
+      add_file_simple "#{name}.sig", 0444, signature.length do |io|
+        io.write signature
+      end
+    end
+
+    digests
+  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) # :yields: io
+    check_closed
+
+    name, prefix = split_name name
+
+    header = Gel::Support::Tar::TarHeader.new(:name => name, :mode => mode,
+                                         :size => size, :prefix => prefix,
+                                         :mtime => Time.now).to_s
+
+    @io.write header
+    os = BoundedStream.new @io, size
+
+    yield os if block_given?
+
+    min_padding = size - os.written
+    @io.write("\0" * min_padding)
+
+    remainder = (512 - (size % 512)) % 512
+    @io.write("\0" * remainder)
+
+    self
+  end
+
+  ##
+  # Adds symlink +name+ with permissions +mode+, linking to +target+.
+
+  def add_symlink(name, target, mode)
+    check_closed
+
+    name, prefix = split_name name
+
+    header = Gel::Support::Tar::TarHeader.new(:name => name, :mode => mode,
+                                         :size => 0, :typeflag => "2",
+                                         :linkname => target,
+                                         :prefix => prefix,
+                                         :mtime => Time.now).to_s
+
+    @io.write header
+
+    self
+  end
+
+  ##
+  # Raises IOError if the TarWriter is closed
+
+  def check_closed
+    raise IOError, "closed #{self.class}" if closed?
+  end
+
+  ##
+  # Closes the TarWriter
+
+  def close
+    check_closed
+
+    @io.write "\0" * 1024
+    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)
+    check_closed
+
+    name, prefix = split_name(name)
+
+    header = Gel::Support::Tar::TarHeader.new :name => name, :mode => mode,
+                                         :typeflag => "5", :size => 0,
+                                         :prefix => prefix,
+                                         :mtime => Time.now
+
+    @io.write header
+
+    self
+  end
+
+  ##
+  # Splits +name+ into a name and prefix that can fit in the TarHeader
+
+  def split_name(name) # :nodoc:
+    if name.bytesize > 256 then
+      raise Gel::Support::Tar::TooLongFileName.new("File \"#{name}\" has a too long path (should be 256 or less)")
+    end
+
+    prefix = ''
+    if name.bytesize > 100 then
+      parts = name.split('/', -1) # parts are never empty here
+      name = parts.pop            # initially empty for names with a trailing slash ("foo/.../bar/")
+      prefix = parts.join('/')    # if empty, then it's impossible to split (parts is empty too)
+      while !parts.empty? && (prefix.bytesize > 155 || name.empty?)
+        name = parts.pop + '/' + name
+        prefix = parts.join('/')
+      end
+
+      if name.bytesize > 100 or prefix.empty? then
+        raise Gel::Support::Tar::TooLongFileName.new("File \"#{prefix}/#{name}\" has a too long name (should be 100 or less)")
+      end
+
+      if prefix.bytesize > 155 then
+        raise Gel::Support::Tar::TooLongFileName.new("File \"#{prefix}/#{name}\" has a too long base path (should be 155 or less)")
+      end
+    end
+
+    return name, prefix
+  end
+
+end