minitar 0.8 → 0.12

data/lib/archive/tar/minitar/writer.rb

@@ -30,8 +30,8 @@ module Archive::Tar::Minitar
       def self.const_missing(c)
         case c
         when :FileOverflow
-          warn 'Writer::BoundedWriteStream::FileOverflow has been renamed ' \
-            'to Writer::WriteBoundaryOverflow'
+          warn "Writer::BoundedWriteStream::FileOverflow has been renamed " \
+            "to Writer::WriteBoundaryOverflow"
           const_set :FileOverflow,
             Archive::Tar::Minitar::Writer::WriteBoundaryOverflow
         else
@@ -46,9 +46,9 @@ module Archive::Tar::Minitar
       attr_reader :written
 
       def initialize(io, limit)
-        @io       = io
-        @limit    = limit
-        @written  = 0
+        @io = io
+        @limit = limit
+        @written = 0
       end
 
       def write(data)
@@ -65,7 +65,7 @@ module Archive::Tar::Minitar
     def self.const_missing(c)
       case c
       when :BoundedStream
-        warn 'BoundedStream has been renamed to BoundedWriteStream'
+        warn "BoundedStream has been renamed to BoundedWriteStream"
         const_set(:BoundedStream, BoundedWriteStream)
       else
         super
@@ -101,7 +101,7 @@ module Archive::Tar::Minitar
 
     # Creates and returns a new Writer object.
     def initialize(io)
-      @io     = io
+      @io = io
       @closed = false
     end
 
@@ -139,10 +139,10 @@ module Archive::Tar::Minitar
       raise ClosedStream if @closed
 
       header = {
-        :mode   => opts.fetch(:mode, 0o644),
-        :mtime  => opts.fetch(:mtime, nil),
-        :gid    => opts.fetch(:gid, nil),
-        :uid    => opts.fetch(:uid, nil)
+        :mode => opts.fetch(:mode, 0o644),
+        :mtime => opts.fetch(:mtime, nil),
+        :gid => opts.fetch(:gid, nil),
+        :uid => opts.fetch(:uid, nil)
       }
 
       data = opts.fetch(:data, nil)
@@ -151,12 +151,12 @@ module Archive::Tar::Minitar
       if block_given?
         if data
           raise ArgumentError,
-            'Too much data (opts[:data] and block_given?).'
+            "Too much data (opts[:data] and block_given?)."
         end
 
-        raise ArgumentError, 'No size provided' unless size
+        raise ArgumentError, "No size provided" unless size
       else
-        raise ArgumentError, 'No data provided' unless data
+        raise ArgumentError, "No data provided" unless data
 
         bytes = bytesize(data)
         size = bytes if size.nil? || size < bytes
@@ -164,7 +164,8 @@ module Archive::Tar::Minitar
 
       header[:size] = size
 
-      write_header(name, header)
+      short_name, prefix, needs_long_name = split_name(name)
+      write_header(header, name, short_name, prefix, needs_long_name)
 
       os = BoundedWriteStream.new(@io, size)
       if block_given?
@@ -211,12 +212,15 @@ module Archive::Tar::Minitar
         raise Archive::Tar::Minitar::NonSeekableStream
       end
 
+      short_name, prefix, needs_long_name = split_name(name)
+
+      data_offset = needs_long_name ? 3 * 512 : 512
       init_pos = @io.pos
-      @io.write("\0" * 512) # placeholder for the header
+      @io.write("\0" * data_offset) # placeholder for the header
 
       yield WriteOnlyStream.new(@io), opts
 
-      size      = @io.pos - (init_pos + 512)
+      size = @io.pos - (init_pos + data_offset)
       remainder = (512 - (size % 512)) % 512
       @io.write("\0" * remainder)
 
@@ -227,9 +231,11 @@ module Archive::Tar::Minitar
         :mtime => opts[:mtime],
         :size => size,
         :gid => opts[:gid],
-        :uid => opts[:uid],
+        :uid => opts[:uid]
       }
-      write_header(name, header)
+
+      write_header(header, name, short_name, prefix, needs_long_name)
+
       @io.pos = final_pos
     end
 
@@ -239,13 +245,38 @@ module Archive::Tar::Minitar
 
       header = {
         :mode => opts[:mode],
-        :typeflag => '5',
+        :typeflag => "5",
+        :size => 0,
+        :gid => opts[:gid],
+        :uid => opts[:uid],
+        :mtime => opts[:mtime]
+      }
+
+      short_name, prefix, needs_long_name = split_name(name)
+      write_header(header, name, short_name, prefix, needs_long_name)
+
+      nil
+    end
+
+    # Creates a symbolic link entry in the tar.
+    def symlink(name, link_target, opts = {})
+      raise ClosedStream if @closed
+
+      raise FileNameTooLong if link_target.size > 100
+
+      name, prefix = split_name(name)
+      header = {
+        :name => name,
+        :mode => opts[:mode],
+        :typeflag => "2",
         :size => 0,
+        :linkname => link_target,
         :gid => opts[:gid],
         :uid => opts[:uid],
         :mtime => opts[:mtime],
+        :prefix => prefix
       }
-      write_header(name, header)
+      @io.write(PosixHeader.new(header))
       nil
     end
 
@@ -271,47 +302,45 @@ module Archive::Tar::Minitar
 
     private
 
-    def write_header(long_name, header)
-      short_name, prefix, needs_long_name = split_name(long_name)
-
+    def write_header(header, long_name, short_name, prefix, needs_long_name)
       if needs_long_name
         long_name_header = {
-          :prefix => '',
+          :prefix => "",
           :name => PosixHeader::GNU_EXT_LONG_LINK,
-          :typeflag => 'L',
-          :size => long_name.length,
-          :mode => 0,
+          :typeflag => "L",
+          :size => long_name.length + 1,
+          :mode => 0
         }
         @io.write(PosixHeader.new(long_name_header))
         @io.write(long_name)
         @io.write("\0" * (512 - (long_name.length % 512)))
       end
 
-      new_header = header.merge({ :name => short_name, :prefix => prefix })
+      new_header = header.merge({:name => short_name, :prefix => prefix})
       @io.write(PosixHeader.new(new_header))
     end
 
     def split_name(name)
       if bytesize(name) <= 100
-        prefix = ''
+        prefix = ""
       else
-        parts = name.split(/\//)
+        parts = name.split("/")
         newname = parts.pop
 
-        nxt = ''
+        nxt = ""
 
         loop do
-          nxt = parts.pop || ''
+          nxt = parts.pop || ""
           break if bytesize(newname) + 1 + bytesize(nxt) >= 100
           newname = "#{nxt}/#{newname}"
         end
 
-        prefix = (parts + [nxt]).join('/')
+        prefix = (parts + [nxt]).join("/")
 
         name = newname
       end
 
-      [ name, prefix, (bytesize(name) > 100 || bytesize(prefix) > 155) ]
+      [name, prefix, bytesize(name) > 100 || bytesize(prefix) > 155]
     end
   end
 end

data/lib/archive/tar/minitar.rb

@@ -2,18 +2,19 @@
 
 ##
 module Archive; end
+
 ##
 module Archive::Tar; end
 
-require 'fileutils'
-require 'rbconfig'
+require "fileutils"
+require "rbconfig"
 
-class << Archive::Tar #:nodoc:
-  def const_missing(const) #:nodoc:
+class << Archive::Tar # :nodoc:
+  def const_missing(const) # :nodoc:
     case const
     when :PosixHeader
-      warn 'Archive::Tar::PosixHeader has been renamed to ' \
-        'Archive::Tar::Minitar::PosixHeader'
+      warn "Archive::Tar::PosixHeader has been renamed to " \
+        "Archive::Tar::Minitar::PosixHeader"
       const_set :PosixHeader, Archive::Tar::Minitar::PosixHeader
     else
       super
@@ -29,7 +30,7 @@ class << Archive::Tar #:nodoc:
   end
 
   def modules
-    require 'set'
+    require "set"
     @modules ||= Set.new
   end
 end
@@ -73,7 +74,7 @@ end
 #       tar.close
 #     end
 module Archive::Tar::Minitar
-  VERSION = '0.8'.freeze # :nodoc:
+  VERSION = "0.12".freeze # :nodoc:
 
   # The base class for any minitar error.
   Error = Class.new(::StandardError)
@@ -99,36 +100,36 @@ module Archive::Tar::Minitar
     # corrupted <tt>stat()</tt> call on Windows.
     def dir?(path)
       # rubocop:disable Style/CharacterLiteral
-      File.directory?(path[-1] == ?/ ? path : "#{path}/")
+      File.directory?((path[-1] == ?/) ? path : "#{path}/")
       # rubocop:enable Style/CharacterLiteral
     end
 
     # A convenience method for wrapping Archive::Tar::Minitar::Input.open
     # (mode +r+) and Archive::Tar::Minitar::Output.open (mode +w+). No other
     # modes are currently supported.
-    def open(dest, mode = 'r', &block)
+    def open(dest, mode = "r", &block)
       case mode
-      when 'r'
+      when "r"
         Input.open(dest, &block)
-      when 'w'
+      when "w"
         Output.open(dest, &block)
       else
-        raise 'Unknown open mode for Archive::Tar::Minitar.open.'
+        raise "Unknown open mode for Archive::Tar::Minitar.open."
       end
     end
 
-    def const_missing(c) #:nodoc:
+    def const_missing(c) # :nodoc:
       case c
       when :BlockRequired
-        warn 'This constant has been removed.'
+        warn "This constant has been removed."
         const_set(:BlockRequired, Class.new(StandardError))
       else
         super
       end
     end
 
-    def windows? #:nodoc:
-      RbConfig::CONFIG['host_os'] =~ /^(mswin|mingw|cygwin)/
+    def windows? # :nodoc:
+      RbConfig::CONFIG["host_os"] =~ /^(mswin|mingw|cygwin)/
     end
 
     # A convenience method to pack the file provided. +entry+ may either be a
@@ -165,39 +166,39 @@ module Archive::Tar::Minitar
     # <tt>:uid</tt>::     The user owner of the file. (+nil+ on Windows.)
     # <tt>:gid</tt>::     The group owner of the file. (+nil+ on Windows.)
     # <tt>:mtime</tt>::   The modification Time of the file.
-    def pack_file(entry, outputter) #:yields action, name, stats:
-      if outputter.kind_of?(Archive::Tar::Minitar::Output)
+    def pack_file(entry, outputter) # :yields action, name, stats:
+      if outputter.is_a?(Archive::Tar::Minitar::Output)
         outputter = outputter.tar
       end
 
       stats = {}
 
-      if entry.kind_of?(Hash)
+      if entry.is_a?(Hash)
         name = entry[:name]
         entry.each { |kk, vv| stats[kk] = vv unless vv.nil? }
       else
         name = entry
       end
 
-      name = name.sub(%r{\./}, '')
+      name = name.sub(%r{\./}, "")
       stat = File.stat(name)
-      stats[:mode]   ||= stat.mode
-      stats[:mtime]  ||= stat.mtime
+      stats[:mode] ||= stat.mode
+      stats[:mtime] ||= stat.mtime
       stats[:size] = stat.size
 
       if windows?
-        stats[:uid]  = nil
-        stats[:gid]  = nil
+        stats[:uid] = nil
+        stats[:gid] = nil
       else
-        stats[:uid]  ||= stat.uid
-        stats[:gid]  ||= stat.gid
+        stats[:uid] ||= stat.uid
+        stats[:gid] ||= stat.gid
       end
 
       if File.file?(name)
         outputter.add_file_simple(name, stats) do |os|
           stats[:current] = 0
           yield :file_start, name, stats if block_given?
-          File.open(name, 'rb') do |ff|
+          File.open(name, "rb") do |ff|
             until ff.eof?
               stats[:currinc] = os.write(ff.read(4096))
               stats[:current] += stats[:currinc]
@@ -210,7 +211,7 @@ module Archive::Tar::Minitar
         yield :dir, name, stats if block_given?
         outputter.mkdir(name, stats)
       else
-        raise %q(Don't yet know how to pack this type of file.)
+        raise "Don't yet know how to pack this type of file."
       end
     end
 
@@ -219,14 +220,14 @@ module Archive::Tar::Minitar
     # the resulting Archive::Tar::Minitar::Output stream; if +recurse_dirs+ is
     # true, then directories will be recursed.
     #
-    # If +src+ is an Array, it will be treated as the result of Find.find; all
-    # files matching will be packed.
+    # If +src+ is not an Array, it will be treated as the result of Find.find;
+    # all files matching will be packed.
     def pack(src, dest, recurse_dirs = true, &block)
-      require 'find'
+      require "find"
       Output.open(dest) do |outp|
-        if src.kind_of?(Array)
+        if src.is_a?(Array)
           src.each do |entry|
-            if dir?(entry) and recurse_dirs
+            if dir?(entry) && recurse_dirs
               Find.find(entry) do |ee|
                 pack_file(ee, outp, &block)
               end
@@ -245,17 +246,17 @@ module Archive::Tar::Minitar
     # A convenience method to unpack files from +src+ into the directory
     # specified by +dest+. Only those files named explicitly in +files+
     # will be extracted.
-    def unpack(src, dest, files = [], &block)
+    def unpack(src, dest, files = [], options = {}, &block)
       Input.open(src) do |inp|
-        if File.exist?(dest) and !dir?(dest)
-          raise %q(Can't unpack to a non-directory.)
+        if File.exist?(dest) && !dir?(dest)
+          raise "Can't unpack to a non-directory."
         end
 
         FileUtils.mkdir_p(dest) unless File.exist?(dest)
 
         inp.each do |entry|
-          if files.empty? or files.include?(entry.full_name)
-            inp.extract_entry(dest, entry, &block)
+          if files.empty? || files.include?(entry.full_name)
+            inp.extract_entry(dest, entry, options, &block)
           end
         end
       end
@@ -269,8 +270,8 @@ module Archive::Tar::Minitar
         io.stat.file?
       else
         # Duck-type the rest of this.
-        methods ||= [ :pos, :pos=, :seek, :rewind ]
-        methods = [ methods ] unless methods.kind_of?(Array)
+        methods ||= [:pos, :pos=, :seek, :rewind]
+        methods = [methods] unless methods.is_a?(Array)
         methods.all? { |m| io.respond_to?(m) }
       end
     end
@@ -284,7 +285,7 @@ module Archive::Tar::Minitar
     end
 
     def modules
-      require 'set'
+      require "set"
       @modules ||= Set.new
     end
   end
@@ -293,7 +294,7 @@ module Archive::Tar::Minitar
   module ByteSize # :nodoc:
     private
 
-    if ''.respond_to?(:bytesize)
+    if "".respond_to?(:bytesize)
       def bytesize(item)
         item.bytesize
       end
@@ -305,6 +306,6 @@ module Archive::Tar::Minitar
   end
 end
 
-require 'archive/tar/minitar/posix_header'
-require 'archive/tar/minitar/input'
-require 'archive/tar/minitar/output'
+require "archive/tar/minitar/posix_header"
+require "archive/tar/minitar/input"
+require "archive/tar/minitar/output"

data/lib/archive-tar-minitar.rb

@@ -1,3 +1,3 @@
 # coding: utf-8
 
-require 'archive/tar/minitar'
+require "archive/tar/minitar"

data/lib/minitar.rb

@@ -1,6 +1,6 @@
 # coding: utf-8
 
-require 'archive/tar/minitar'
+require "archive/tar/minitar"
 
 if defined?(::Minitar) && ::Minitar != Archive::Tar::Minitar
   warn <<-EOS

data/support/hoe/deprecated_gem.rb

@@ -0,0 +1,64 @@
+# A Hoe plug-in to provide a second, linked gemspec, for a gem that has been
+# deprecated in favour of a modern name. (The name is an artifact of Hoe's
+# plugin loading.)
+module Hoe::Deprecated_Gem # standard:disable Naming/ClassAndModuleCamelCase
+  def linked_spec(spec)
+    permitted_classes = %w[
+      Symbol Time Date Gem::Dependency Gem::Platform Gem::Requirement
+      Gem::Specification Gem::Version Gem::Version::Requirement
+      YAML::Syck::DefaultKey Syck::DefaultKey
+    ]
+    permitted_symbols = %w[development runtime]
+    atm = begin
+      YAML.safe_load(
+        YAML.dump(spec),
+        :permitted_classes => permitted_classes,
+        :permitted_symbols => permitted_symbols,
+        :aliases => true
+      )
+    rescue
+      YAML.safe_load(
+        YAML.dump(spec), permitted_classes, permitted_symbols, true
+      )
+    end
+    atm.name = "archive-tar-minitar"
+    d = %('#{atm.name}' has been deprecated; just install '#{spec.name}'.)
+    atm.description = "#{d} #{spec.description}"
+    atm.summary = atm.post_install_message = d
+    atm.files.delete_if do |f|
+      f !~ %r{lib/archive-tar-minitar\.rb}
+    end
+    atm.extra_rdoc_files.clear
+    atm.rdoc_options.clear
+    atm.dependencies.clear
+
+    version = Gem::Version.new(spec.version.segments.first(2).join("."))
+
+    atm.add_dependency(spec.name, "~> #{version}")
+    atm.add_dependency(%(#{spec.name}-cli), "~> #{version}")
+
+    unless @include_all
+      [:signing_key, :cert_chain].each { |name|
+        atm.send(:"#{name}=", atm.default_value(name))
+      }
+    end
+
+    atm
+  end
+
+  def define_deprecated_gem_tasks
+    gemspec = spec.name + ".gemspec"
+    atmspec = "archive-tar-minitar.gemspec"
+
+    file atmspec => gemspec do
+      File.open(atmspec, "w") { |f| f.write(linked_spec(spec).to_ruby) }
+    end
+
+    task :gemspec => atmspec
+
+    Gem::PackageTask.new linked_spec(spec) do |pkg|
+      pkg.need_tar = @need_tar
+      pkg.need_zip = @need_zip
+    end
+  end
+end

data/test/minitest_helper.rb

@@ -1,11 +1,12 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
-require 'fileutils'
-require 'minitar'
+require "fileutils"
+require "minitar"
 
-gem 'minitest'
-require 'minitest/autorun'
+gem "minitest"
+require "minitest/autorun"
+require "minitest/focus"
 
-Dir.glob(File.join(File.dirname(__FILE__), 'support/*.rb')).each do |support|
+Dir.glob(File.join(File.dirname(__FILE__), "support/*.rb")).sort.each do |support|
   require support
 end