omnizip 0.3.36 → 0.3.38

data/lib/omnizip/archive_handlers/cpio_handler.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+
+module Omnizip
+  module ArchiveHandlers
+    # Read-only adapter for the CPIO format (initramfs images, RPM
+    # payloads). Extraction and listing are supported; CPIO writing
+    # exists at the format level but is not exposed through the
+    # convenience archive API.
+    class CpioHandler
+      def create(_path, **_options)
+        raise Omnizip::UnsupportedFormatError,
+              "cpio archives cannot be created through the convenience " \
+              "API; use Omnizip::Formats::Cpio.create directly"
+      end
+
+      def extract_to(path, output_dir, **_)
+        Omnizip::Formats::Cpio.extract(path, output_dir)
+      end
+
+      def list(path, details: false, **_)
+        entries = Omnizip::Formats::Cpio.list(path)
+        if details
+          entries.map do |e|
+            { name: e.name, size: e.data.bytesize,
+              directory: e.name.end_with?("/"), mtime: nil }
+          end
+        else
+          entries.map(&:name)
+        end
+      end
+
+      def read_entry(path, entry_name, **_)
+        entry = Omnizip::Formats::Cpio.list(path)
+          .find { |e| e.name == entry_name }
+        unless entry
+          raise Errno::ENOENT, "Entry not found: #{entry_name}"
+        end
+
+        entry.data
+      end
+    end
+  end
+end
+
+Omnizip::ArchiveHandler.register(:cpio, Omnizip::ArchiveHandlers::CpioHandler.new)

data/lib/omnizip/archive_handlers/iso_handler.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+
+module Omnizip
+  module ArchiveHandlers
+    # Read-only adapter for the ISO 9660 format (disk images).
+    # Extraction and listing are supported; ISO writing exists at the
+    # format level but is not exposed through the convenience archive
+    # API.
+    class IsoHandler
+      def create(_path, **_options)
+        raise Omnizip::UnsupportedFormatError,
+              "iso images cannot be created through the convenience " \
+              "API; use Omnizip::Formats::Iso.create directly"
+      end
+
+      def extract_to(path, output_dir, **_)
+        Omnizip::Formats::Iso.extract(path, output_dir)
+      end
+
+      def list(path, details: false, **_)
+        entries = Omnizip::Formats::Iso.list(path)
+        if details
+          entries.map do |e|
+            { name: e.full_path, size: e.size, directory: e.directory?,
+              mtime: e.recording_date }
+          end
+        else
+          entries.map(&:full_path)
+        end
+      end
+
+      def read_entry(path, entry_name, **_)
+        entry = Omnizip::Formats::Iso.list(path)
+          .find { |e| e.full_path == entry_name }
+        unless entry
+          raise Errno::ENOENT, "Entry not found: #{entry_name}"
+        end
+        raise Errno::EISDIR, "Entry is a directory: #{entry_name}" if entry.directory?
+
+        Dir.mktmpdir("omnizip-iso-entry") do |dir|
+          dest = File.join(dir, "entry")
+          Omnizip::Formats::Iso.open(path) do |iso|
+            iso.extract_entry(entry_name, dest)
+          end
+          File.binread(dest)
+        end
+      end
+    end
+  end
+end
+
+Omnizip::ArchiveHandler.register(:iso, Omnizip::ArchiveHandlers::IsoHandler.new)

data/lib/omnizip/archive_handlers/rar_handler.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+
+module Omnizip
+  module ArchiveHandlers
+    # Read-only adapter for the RAR format. RAR compression is
+    # patented software (see link:README[RAR write support]); this
+    # handler exposes extraction/listing/reading only, so the
+    # convenience API and the Archive facade can operate on existing
+    # archives truthfully instead of raising on every operation.
+    class RarHandler
+      def create(_path, **_options)
+        raise Omnizip::UnsupportedFormatError,
+              "RAR archives cannot be created (patented format); " \
+              "Omnizip reads RAR archives only"
+      end
+
+      def extract_to(path, output_dir, password: nil, **_)
+        Omnizip::Formats::Rar::Decompressor.extract(path, output_dir,
+                                                    password: password)
+      end
+
+      def list(path, details: false, **_)
+        reader = Omnizip::Formats::Rar::Reader.new(path).open
+        entries = reader.list_files
+        if details
+          entries.map do |e|
+            { name: e.name, size: e.size, directory: e.is_dir,
+              mtime: e.mtime }
+          end
+        else
+          entries.map(&:name)
+        end
+      end
+
+      def read_entry(path, entry_name, password: nil, **_)
+        Dir.mktmpdir("omnizip-rar-entry") do |dir|
+          dest = File.join(dir, "entry")
+          Omnizip::Formats::Rar::Decompressor.extract_entry(
+            path, entry_name, dest, password: password
+          )
+          File.binread(dest)
+        end
+      end
+    end
+  end
+end
+
+Omnizip::ArchiveHandler.register(:rar, Omnizip::ArchiveHandlers::RarHandler.new)

data/lib/omnizip/archive_handlers/seven_zip_handler.rb

@@ -8,8 +8,8 @@ module Omnizip
       # Creates a .7z archive. The yielded proxy only supports
       # +add(name, source_path)+ for files — directory entries are not
       # part of the single-file convenience flow.
-      def create(path, &block)
-        Omnizip::Formats::SevenZip.create(path) do |writer|
+      def create(path, **options, &block)
+        Omnizip::Formats::SevenZip.create(path, options) do |writer|
           block&.call(FileProxy.new(writer))
         end
       end
@@ -73,6 +73,10 @@ module Omnizip
 
           @writer.add_file(source_path, name)
         end
+
+        def add_data(name, data)
+          @writer.add_data(name, data)
+        end
       end
     end
   end

data/lib/omnizip/archive_handlers/tar_handler.rb

@@ -50,6 +50,10 @@ module Omnizip
 
           @writer.add(name, source_path)
         end
+
+        def add_data(name, data)
+          @writer.add_data(name, data)
+        end
       end
 
       def read_entry(path, entry_name)

data/lib/omnizip/archive_handlers/zip_handler.rb

@@ -5,8 +5,13 @@ module Omnizip
     # Adapter that exposes the canonical +create+/+open+/+extract_to+
     # /+list+ interface for the ZIP format. Wraps +Omnizip::Zip::File+.
     class ZipHandler
-      def create(path, &block)
-        Omnizip::Zip::File.create(path, &block)
+      # Zip::File has no archive-level compression options (method and
+      # level are per-entry in Zip::OutputStream), so extra keywords —
+      # e.g. profile-injected ones — are absorbed here.
+      def create(path, **_options, &block)
+        Omnizip::Zip::File.create(path) do |file|
+          block&.call(FileProxy.new(file))
+        end
       end
 
       def open(path, &block)
@@ -66,6 +71,24 @@ module Omnizip
       def remove_entry(path, entry_name)
         Omnizip::Zip::File.open(path) { |zip| zip.remove(entry_name) }
       end
+
+      # Translates the generic +add(name, source_path)+ and
+      # +add_data(name, data)+ interface. +Zip::File#add_data+ is
+      # private, so in-memory content goes through the public block
+      # form +add(name) { data }+.
+      class FileProxy
+        def initialize(file)
+          @file = file
+        end
+
+        def add(name, source_path = nil)
+          @file.add(name, source_path)
+        end
+
+        def add_data(name, data)
+          @file.add(name) { data }
+        end
+      end
     end
   end
 end

data/lib/omnizip/archive_handlers.rb

@@ -8,5 +8,8 @@ module Omnizip
     autoload :ZipHandler, "omnizip/archive_handlers/zip_handler"
     autoload :TarHandler, "omnizip/archive_handlers/tar_handler"
     autoload :SevenZipHandler, "omnizip/archive_handlers/seven_zip_handler"
+    autoload :RarHandler, "omnizip/archive_handlers/rar_handler"
+    autoload :CpioHandler, "omnizip/archive_handlers/cpio_handler"
+    autoload :IsoHandler, "omnizip/archive_handlers/iso_handler"
   end
 end

data/lib/omnizip/cli.rb

@@ -25,6 +25,28 @@ module Omnizip
   # under Omnizip::Cli would re-trigger this file's autoload
   # mid-load.
   module Shared
+    # Thor 1.x does not treat --help/-h on subcommands as a request
+    # for help: the flag reaches the command as a positional argument
+    # and arity checking fails. Classes extending this module route
+    # those flags to the standard help output instead.
+    module HelpDispatch
+      def dispatch(meth, given_args, given_opts, config)
+        wants_help = [Array(given_args), Array(given_opts)].any? do |list|
+          list.include?("--help") || list.include?("-h")
+        end
+        if wants_help
+          name = meth || Array(given_args).grep_v(/\A-/).first
+          # Subcommand groups intercept their own --help (e.g.
+          # "archive create --help" must show the create usage).
+          return super if subcommands.include?(name)
+
+          return start(["help", name].compact, config)
+        end
+
+        super
+      end
+    end
+
     # Print a formatted error message and exit nonzero.
     #
     # @param error [StandardError] the error to display
@@ -51,6 +73,7 @@ module Omnizip
   # Profile commands subcommand group
   class ProfileCommands < Thor
     include Shared
+    extend Shared::HelpDispatch
 
     class << self
       def exit_on_failure?
@@ -99,6 +122,7 @@ module Omnizip
   # Archive commands subcommand group
   class ArchiveCommands < Thor
     include Shared
+    extend Shared::HelpDispatch
 
     class << self
       def exit_on_failure?
@@ -328,6 +352,7 @@ module Omnizip
   # files using various compression algorithms.
   class Cli < Thor
     include Shared
+    extend Shared::HelpDispatch
 
     class << self
       def exit_on_failure?

data/lib/omnizip/convenience.rb

@@ -40,13 +40,50 @@ module Omnizip
         return output_path
       end
 
-      Omnizip::ArchiveHandler.for(resolve_archive_format(output_path, format)).create(output_path) do |archive|
+      Omnizip::ArchiveHandler.for(resolve_archive_format(output_path, format)).create(output_path, **options) do |archive|
         archive.add(::File.basename(input_path), input_path)
       end
 
       output_path
     end
 
+    # Decompress a single-file compressed stream (the counterpart of
+    # #compress_file). The format is resolved from the input
+    # extension: .gz, .bz2, .xz, .lzma, .lz.
+    #
+    # @param compressed_path [String] Path to the compressed file
+    # @param output_path [String] Path to write the decompressed data
+    # @return [String] +output_path+
+    def decompress_file(compressed_path, output_path)
+      require_archive!(compressed_path)
+
+      format_class = DECOMPRESSORS[::File.extname(compressed_path).downcase]
+      unless format_class
+        raise Omnizip::UnsupportedFormatError,
+              "decompress_file supports #{DECOMPRESSORS.keys.join(', ')}; " \
+              "use extract_archive for archive formats"
+      end
+
+      case format_class
+      when :xz
+        ::File.binwrite(output_path, Formats::Xz.decompress(compressed_path))
+      when :zstandard
+        zstd = Algorithms::Zstandard.new
+        ::File.open(compressed_path, "rb") do |input_io|
+          ::File.open(output_path, "wb") do |output_io|
+            zstd.decompress(input_io, output_io)
+          end
+        end
+      else
+        ::File.open(compressed_path, "rb") do |input_io|
+          ::File.open(output_path, "wb") do |output_io|
+            format_class.decompress_stream(input_io, output_io)
+          end
+        end
+      end
+      output_path
+    end
+
     # Compress a directory into an archive.
     #
     # @param input_dir [String] Path to input directory
@@ -64,12 +101,23 @@ module Omnizip
         raise ArgumentError, "Input is not a directory: #{input_dir}"
       end
 
+      # A directory cannot be written through a single-file stream
+      # format; routing it to the default would silently produce a
+      # ZIP under a foreign extension.
+      if format == DEFAULT_FORMAT && single_file_handler(output_path)
+        raise Omnizip::UnsupportedFormatError,
+              "#{::File.extname(output_path).downcase} is a single-file " \
+              "stream format and cannot contain a directory; use an " \
+              "archive format (.zip/.tar/.7z) or compress entries " \
+              "individually"
+      end
+
       if options[:profile]
         first_file = find_first_file(input_dir)
         apply_profile(first_file, options)
       end
 
-      Omnizip::ArchiveHandler.for(resolve_archive_format(output_path, format)).create(output_path) do |archive|
+      Omnizip::ArchiveHandler.for(resolve_archive_format(output_path, format)).create(output_path, **options) do |archive|
         add_directory_contents(archive, input_dir, "", recursive: recursive)
       end
 
@@ -87,7 +135,7 @@ module Omnizip
     def extract_archive(archive_path, output_dir, format: DEFAULT_FORMAT,
                         overwrite: false, **options)
       require_archive!(archive_path)
-      Omnizip::ArchiveHandler.for(resolve_archive_format(archive_path, format))
+      Omnizip::ArchiveHandler.for(resolve_archive_format(archive_path, format, writing: false))
         .extract_to(archive_path, output_dir,
                     overwrite: overwrite, **options)
     end
@@ -102,7 +150,7 @@ module Omnizip
     def list_archive(archive_path, format: DEFAULT_FORMAT, details: false,
                      **options)
       require_archive!(archive_path)
-      Omnizip::ArchiveHandler.for(resolve_archive_format(archive_path, format))
+      Omnizip::ArchiveHandler.for(resolve_archive_format(archive_path, format, writing: false))
         .list(archive_path, details: details, **options)
     end
 
@@ -114,7 +162,7 @@ module Omnizip
     # @return [String] Entry contents
     def read_from_archive(archive_path, entry_name, format: DEFAULT_FORMAT)
       require_archive!(archive_path)
-      Omnizip::ArchiveHandler.for(resolve_archive_format(archive_path, format)).read_entry(archive_path, entry_name)
+      Omnizip::ArchiveHandler.for(resolve_archive_format(archive_path, format, writing: false)).read_entry(archive_path, entry_name)
     end
 
     # Add a file to an existing archive.
@@ -182,12 +230,34 @@ module Omnizip
       ".7z" => :seven_zip,
     }.freeze
 
-    # Extensions naming real formats this gem can READ but not write
-    # through the convenience API. Writing them a ZIP under a foreign
-    # name was silent corruption; failing truthfully is the only
-    # honest behavior.
+    # Extensions naming formats with read-only convenience routing.
+    # Writing them a ZIP under a foreign name was silent corruption;
+    # creation raises truthfully instead (the format-level writers
+    # exist for RAR/CPIO/ISO but are not part of the archive API).
     READ_ONLY_FORMAT_EXTENSIONS = [".rar", ".iso", ".cpio"].freeze
 
+    # Extensions whose format has a READ-ONLY handler: extraction and
+    # listing route to it, while creation keeps raising.
+    READ_ARCHIVE_FORMAT_EXTENSIONS = {
+      ".rar" => :rar,
+      ".cpio" => :cpio,
+      ".iso" => :iso,
+    }.freeze
+
+    # Extension -> single-file decompressor (stream interface).
+    # The Gzip/Bzip2File/Xz classes take path or stream; use the
+    # ones exposing decompress_stream for symmetry.
+    # Xz exposes a path-based decompress rather than a stream one,
+    # so it is marked specially here.
+    DECOMPRESSORS = {
+      ".gz" => Formats::Gzip,
+      ".bz2" => Formats::Bzip2File,
+      ".xz" => :xz,
+      ".lzma" => Formats::LzmaAlone,
+      ".lz" => Formats::Lzip,
+      ".zst" => :zstandard,
+    }.freeze
+
     SINGLE_FILE_COMPRESSORS = {
       ".gz" => lambda do |input, output, options|
         Omnizip::Formats::Gzip.compress(input, output, options)
@@ -214,6 +284,14 @@ module Omnizip
           end
         end
       end,
+      ".zst" => lambda do |input, output, options|
+        ::File.open(input, "rb") do |input_io|
+          ::File.open(output, "wb") do |output_io|
+            Omnizip::Algorithms::Zstandard.new.compress(input_io, output_io,
+                                                        options)
+          end
+        end
+      end,
     }.freeze
 
     # The single-file compressor matching the output extension, or nil.
@@ -225,12 +303,14 @@ module Omnizip
     # Archive format for a path: an explicit +format+ wins unless it
     # is the default; otherwise the extension routes. Known-but-
     # unwritable extensions raise instead of receiving a mislabeled
-    # ZIP.
-    def resolve_archive_format(path, format)
+    # ZIP. +writing:+ false (read operations) additionally routes
+    # extensions with read-only handlers.
+    def resolve_archive_format(path, format, writing: true)
       return format unless format == DEFAULT_FORMAT
 
       ext = ::File.extname(path).downcase
       routed = ARCHIVE_FORMAT_EXTENSIONS[ext]
+      routed ||= READ_ARCHIVE_FORMAT_EXTENSIONS[ext] unless writing
       return routed if routed
 
       if READ_ONLY_FORMAT_EXTENSIONS.include?(ext)

data/lib/omnizip/formats/iso/directory_builder.rb

@@ -43,6 +43,12 @@ module Omnizip
           # Allocate sectors for directories and files
           allocate_sectors(tree)
 
+          # Tree nodes are separate hashes from @files entries; copy
+          # the allocated file locations onto the tree so directory
+          # records reference the real extents (otherwise every
+          # record points at sector 0).
+          assign_file_locations(tree)
+
           # Build path table
           path_table = build_path_table(tree)
 
@@ -143,6 +149,24 @@ module Omnizip
           allocate_file_sectors
         end
 
+        # Copy allocated file locations onto the matching tree nodes
+        #
+        # @param tree [Hash] Directory tree root
+        def assign_file_locations(tree)
+          walk = lambda do |node|
+            (node[:children] || []).each do |child|
+              if child[:directory]
+                walk.call(child)
+              else
+                match = @files.find { |f| f[:iso_path] == child[:iso_path] }
+                child[:location] = match[:location] if match
+                child[:size] = match[:size] if match
+              end
+            end
+          end
+          walk.call(tree)
+        end
+
         # Allocate sectors for a directory
         #
         # @param dir_node [Hash] Directory node

data/lib/omnizip/formats/iso/reader.rb

@@ -90,8 +90,8 @@ module Omnizip
           @entries.each do |entry|
             next if entry.current_directory? || entry.parent_directory?
 
-            output_path = File.join(output_dir, entry.name)
-            extract_entry(entry.name, output_path)
+            output_path = File.join(output_dir, entry.full_path)
+            extract_entry(entry.full_path, output_path)
           end
         end
 

data/lib/omnizip/formats/iso/writer.rb

@@ -178,8 +178,13 @@ module Omnizip
             preparer: "OMNIZIP #{Omnizip::VERSION}",
             application: "OMNIZIP",
             level: 2,
-            rock_ridge: true,
-            joliet: true,
+            # Rock Ridge System Use fields and Joliet UCS-2 directory
+            # trees are not implemented; advertising either extension
+            # makes readers misparse the image (e.g. 7-Zip reads the
+            # ASCII names as UCS-2 via the cloned SVD), so both stay
+            # off until real implementations land.
+            rock_ridge: false,
+            joliet: false,
           }
         end
 
@@ -193,6 +198,7 @@ module Omnizip
             source: File.expand_path(dir_path),
             iso_path: iso_path,
             stat: File.stat(dir_path),
+            directory: true,
           }
 
           # Add all contents
@@ -219,6 +225,7 @@ module Omnizip
             source: File.expand_path(dir_path),
             iso_path: iso_path,
             stat: File.stat(dir_path),
+            directory: true,
           }
 
           Dir.foreach(dir_path) do |entry|
@@ -283,13 +290,22 @@ module Omnizip
         # @param builder [VolumeBuilder] Volume builder
         # @param dir_structure [Hash] Directory structure
         def write_volume_descriptors(io, builder, dir_structure)
+          # Fixed layout: 16 PVD, 17 terminator, 18 path table (L),
+          # 19 path table (BE), directory data from sector 22.
+          root = dir_structure[:root].merge(
+            total_sectors: dir_structure[:total_sectors],
+            path_table_size: dir_structure[:path_table_size],
+            path_table_location: 18,
+            path_table_location_be: 19,
+          )
+
           # Write primary volume descriptor
-          pvd = builder.build_primary(dir_structure[:root])
+          pvd = builder.build_primary(root)
           io.write(pvd)
 
           # Write Joliet supplementary descriptor if enabled
           if @joliet
-            svd = builder.build_joliet(dir_structure[:root])
+            svd = builder.build_joliet(root)
             io.write(svd)
           end
 

data/lib/omnizip/formats/iso.rb

@@ -69,7 +69,9 @@ module Omnizip
       # @param path [String] Path to ISO file
       # @return [Array<DirectoryRecord>] Directory entries
       def self.list(path)
-        open(path, &:entries)
+        entries = nil
+        open(path) { |iso| entries = iso.entries }
+        entries
       end
 
       # Extract ISO contents

data/lib/omnizip/formats/rar/block_parser.rb

@@ -121,6 +121,10 @@ module Omnizip
 
           header_flags = read_vint(io)
 
+          # Optional ExtraAreaSize / DataSize precede the file fields
+          extra_size = header_flags.anybits?(RAR5_FLAG_EXTRA_AREA) ? read_vint(io) : 0
+          data_size = header_flags.anybits?(RAR5_FLAG_DATA_AREA) ? read_vint(io) : 0
+
           # Read file header
           file_flags = read_vint(io)
           unpack_size = read_vint(io)
@@ -145,7 +149,7 @@ module Omnizip
 
           # Set entry properties
           entry.size = unpack_size
-          entry.compressed_size = 0 # Not directly available in header
+          entry.compressed_size = data_size
           entry.crc = crc
           entry.host_os = host_os
           entry.flags = file_flags
@@ -154,17 +158,9 @@ module Omnizip
           entry.is_dir = file_flags.anybits?(RAR5_FLAG_IS_DIR)
           entry.version = 5
 
-          # Read extra area if present
-          if header_flags.anybits?(RAR5_FLAG_EXTRA_AREA)
-            extra_size = read_vint(io)
-            io.read(extra_size) if extra_size.positive?
-          end
-
-          # Read data area if present
-          if header_flags.anybits?(RAR5_FLAG_DATA_AREA)
-            data_size = read_vint(io)
-            io.read(data_size) if data_size.positive?
-          end
+          # Skip extra area, then compressed data
+          io.read(extra_size) if extra_size.positive?
+          io.read(data_size) if data_size.positive?
 
           entry
         end

data/lib/omnizip/formats/rar/constants.rb

@@ -58,7 +58,9 @@ module Omnizip
         RAR5_FLAG_UNKNOWN_BLOCKS = 0x0004
         RAR5_FLAG_DATA_INHERITED = 0x0008
         RAR5_FLAG_CHILD_BLOCKS = 0x0010
-        RAR5_FLAG_IS_DIR = 0x0020
+        # File-header-specific flags (FileFlags field): the directory
+        # bit is 0x0001 per the RAR5 spec.
+        RAR5_FLAG_IS_DIR = 0x0001
         RAR5_FLAG_MULTI_VOLUME = 0x0001
 
         # Compression methods

data/lib/omnizip/formats/rar/header.rb

@@ -122,9 +122,11 @@ module Omnizip
         #
         # @param io [IO] Input stream
         def parse_rar5_header(io)
-          # RAR5 uses variable-length integer encoding
+          # RAR5 uses variable-length integer encoding. Layout per the
+          # RAR 5.0 format: HeaderCRC32(4), Header size(vint), Header
+          # type(vint), Header flags(vint), then type-specific fields.
           read_uint32(io)
-          read_vint(io)
+          read_vint(io) # header size (redundant: areas carry their own)
           header_type = read_vint(io)
           header_flags = read_vint(io)
 
@@ -133,12 +135,20 @@ module Omnizip
           end
 
           @flags = header_flags
-          @is_multi_volume = header_flags.anybits?(RAR5_FLAG_MULTI_VOLUME)
 
-          # Read extra area if present
-          return unless header_flags.anybits?(RAR5_FLAG_EXTRA_AREA)
+          extra_size = 0
+          if header_flags.anybits?(RAR5_FLAG_EXTRA_AREA)
+            extra_size = read_vint(io)
+          end
+
+          # Archive flags: 0x0001 volume, 0x0002 volume number
+          # present, 0x0004 solid, 0x0008 recovery, 0x0010 locked
+          archive_flags = read_vint(io)
+          @is_multi_volume = archive_flags.anybits?(0x0001)
+          @is_solid = archive_flags.anybits?(0x0004)
+          @is_locked = archive_flags.anybits?(0x0010)
+          read_vint(io) if archive_flags.anybits?(0x0002) # volume number
 
-          extra_size = read_vint(io)
           io.read(extra_size) if extra_size.positive?
         end