mini_tarball 0.2.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bb6115ef818ae567ea4efad8646977a26cbb62f5164e656bd8d403dd1775ff38
-  data.tar.gz: 5364a6eece1aa623c4bb900eaf50de383017dcd4b9285f5f7b3b52423638d9b2
+  metadata.gz: 313b7544e163106d7c251eb36ace29a96c22dfe43bc198310966155c18417260
+  data.tar.gz: fe252395b2daa1b7a8843ff27a0f6b87d96dff09031c485c42c217ad39b9ba52
 SHA512:
-  metadata.gz: d8978adda8f400f47d37d037fc439d6d803538910aaa97a78cee3ec111b34616c0b3acd298a6a5b406a02a8e0d698e25743a5a4ff32a2e1b827835892621d186
-  data.tar.gz: 543abee46d1e1bd3df2abdd0b0164f2e72363d65ec63a7ac8c120302c94a0fc247315fcb7c4541774ab08ef00178e4de1df355cb2699e0056f0d984e53f532bc
+  metadata.gz: acf0381c3b1dfc12c7d3e2da19f3bf3747f3c60e4af2939718d0095fe6dbff6554bf359beaf8e2a74b2a6f44b317620eb85977360a6bce0cae88c638442b5e86
+  data.tar.gz: f86d7def07d9c89a5375f2428324c1b9e8f7ec2e35c57d473c35a79e42207929685410900e2e76e1e19969ac2051f3f34e9f8f2669de792c2a522a6da78e1c56

data/lib/mini_tarball/header.rb

@@ -8,7 +8,7 @@ module MiniTarball
     TYPE_REGULAR = "0"
     TYPE_LONG_LINK = "L"
 
-    # rubocop:disable Layout/HashAlignment
+    # stree-ignore
     FIELDS = {
       name:     { length: 100, type: :chars },
       mode:     { length:   8, type: :mode },
@@ -27,9 +27,33 @@ module MiniTarball
       devminor: { length:   8, type: :number },
       prefix:   { length: 155, type: :chars }
     }
-    # rubocop:enable Layout/HashAlignment
 
-    def initialize(name:, mode: 0, uid: nil, gid: nil, size: 0, mtime: 0, typeflag: TYPE_REGULAR, linkname: "", uname: nil, gname: nil)
+    def self.long_link_header(name)
+      Header.new(
+        name: "././@LongLink",
+        mode: 0644,
+        uid: 0,
+        gid: 0,
+        size: name.bytesize + 1,
+        typeflag: TYPE_LONG_LINK,
+        uname: "root",
+        gname: "root",
+      )
+    end
+
+    # :reek:LongParameterList
+    def initialize(
+      name:,
+      mode: 0,
+      uid: nil,
+      gid: nil,
+      size: 0,
+      mtime: 0,
+      typeflag: TYPE_REGULAR,
+      linkname: "",
+      uname: nil,
+      gname: nil
+    )
       @values = {
         name: name,
         mode: mode,
@@ -46,12 +70,21 @@ module MiniTarball
         gname: gname,
         devmajor: nil,
         devminor: nil,
-        prefix: ""
+        prefix: "",
       }
     end
 
     def value_of(key)
       @values[key]
     end
+
+    def to_binary
+      fields = HeaderFields.new(self)
+      fields.to_binary
+    end
+
+    def has_long_name?
+      value_of(:name).bytesize > FIELDS[:name][:length]
+    end
   end
 end

data/lib/mini_tarball/header_fields.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module MiniTarball
+  class HeaderFields
+    def self.pack_format
+      @pack_format ||= Header::FIELDS.values.map { |field| "a#{field[:length]}" }.join("")
+    end
+
+    def initialize(header)
+      @header = header
+      @values_by_field = {}
+    end
+
+    def to_binary
+      Header::FIELDS.each_key do |name|
+        value = @header.value_of(name)
+        set_value(name, value)
+      end
+
+      update_checksum
+      HeaderFormatter.zero_pad(encode_fields)
+    end
+
+    # :reek:DuplicateMethodCall
+    def set_value(name, value)
+      field = Header::FIELDS[name]
+
+      case field[:type]
+      when :number
+        @values_by_field[name] = HeaderFormatter.format_number(value, field[:length])
+      when :mode
+        @values_by_field[name] = HeaderFormatter.format_permissions(value, field[:length])
+      when :checksum
+        @values_by_field[name] = HeaderFormatter.format_checksum(value)
+      else
+        @values_by_field[name] = value
+      end
+    end
+
+    def update_checksum
+      checksum = encode_fields.unpack("C*").sum
+      set_value(:checksum, checksum)
+    end
+
+    private def encode_fields
+      values = @values_by_field.values
+      values.pack(HeaderFields.pack_format)
+    end
+  end
+end

data/lib/mini_tarball/header_formatter.rb

@@ -3,30 +3,50 @@
 module MiniTarball
   ValueTooLargeError = Class.new(StandardError)
 
-  class HeaderFormatter
+  module HeaderFormatter
     PERMISSION_BITMASK = 0007777
 
     # @param value [Integer]
     # @param length [Integer]
     def self.format_number(value, length)
-      return nil if value.nil?
+      return nil if !value
       raise NotImplementedError.new("Negative numbers are not supported") if value.negative?
 
+      fits_into_octal?(value, length) ? to_octal(value, length) : to_base256(value, length)
+    end
+
+    # Removes file type bitfields and returns file permissions as formatted number
+    # @param value [Integer]
+    # @param length [Integer]
+    def self.format_permissions(value, length)
+      format_number(value & PERMISSION_BITMASK, length)
+    end
+
+    def self.format_checksum(checksum)
+      length = Header::FIELDS[:checksum][:length]
+
+      checksum ? format_number(checksum, length - 1) << "\0 " : " " * length
+    end
+
+    def self.zero_pad(binary)
+      padding_length = (Header::BLOCK_SIZE - binary.length) % Header::BLOCK_SIZE
+      binary << "\0" * padding_length
+    end
+
+    private_class_method def self.fits_into_octal?(value, length)
       octal_length = length - 1
       max_octal_value = ("0" + "7" * octal_length).to_i(8)
-
-      if (value <= max_octal_value)
-        to_octal(value, octal_length)
-      else
-        to_base256(value, length)
-      end
+      value <= max_octal_value
     end
 
-    def self.to_octal(value, length)
-      "%0#{length}o" % value
+    private_class_method def self.to_octal(value, length)
+      octal_length = length - 1
+      "%0#{octal_length}o" % value
     end
 
-    def self.to_base256(value, length)
+    # :reek:TooManyStatements { max_statements: 8}
+    # :reek:UncommunicativeMethodName
+    private_class_method def self.to_base256(value, length)
       encoded = Array.new(length, 0)
       encoded[0] = 0x80
       index = length - 1
@@ -40,12 +60,5 @@ module MiniTarball
 
       encoded.pack("C#{length}")
     end
-
-    # Removes file type bitfields and returns file permissions as formatted number
-    # @param value [Integer]
-    # @param length [Integer]
-    def self.format_permissions(value, length)
-      format_number(value & PERMISSION_BITMASK, length)
-    end
   end
 end

data/lib/mini_tarball/header_writer.rb

@@ -7,79 +7,17 @@ module MiniTarball
     end
 
     def write(header)
-      write_long_name_header(header) if has_long_name?(header)
-      @io.write(to_binary(header))
+      write_long_name_header(header) if header.has_long_name?
+      @io.write(header.to_binary)
     end
 
-    private
-
-    def to_binary(header)
-      values_by_field = {}
-
-      Header::FIELDS.each do |name, field|
-        value = values_by_field[name] = header.value_of(name)
-
-        case field[:type]
-        when :number
-          values_by_field[name] = HeaderFormatter.format_number(value, field[:length])
-        when :mode
-          values_by_field[name] = HeaderFormatter.format_permissions(value, field[:length])
-        when :checksum
-          values_by_field[name] = " " * field[:length]
-        end
-      end
-
-      update_checksum(values_by_field)
-      add_padding(encode(values_by_field.values))
-    end
-
-    def update_checksum(values_by_field)
-      checksum = encode(values_by_field.values).unpack("C*").sum
-      values_by_field[:checksum] = format_checksum(checksum)
-    end
-
-    def format_checksum(checksum)
-      length = Header::FIELDS[:checksum][:length] - 1
-      HeaderFormatter.format_number(checksum, length) << "\0 "
-    end
-
-    def encode(values)
-      @pack_format ||= Header::FIELDS.values
-        .map { |field| "a#{field[:length]}" }
-        .join("")
-
-      values.pack(@pack_format)
-    end
-
-    def add_padding(binary)
-      padding_length = (Header::BLOCK_SIZE - binary.length) % Header::BLOCK_SIZE
-      binary << "\0" * padding_length
-    end
-
-    def has_long_name?(header)
-      header.value_of(:name).bytesize > Header::FIELDS[:name][:length]
-    end
-
-    def write_long_name_header(header)
+    private def write_long_name_header(header)
       name = header.value_of(:name)
-      private_header = long_link_header(name, Header::TYPE_LONG_LINK)
-      data = [header.value_of(:name)].pack("Z*")
-
-      @io.write(to_binary(private_header))
-      @io.write(add_padding(data))
-    end
+      private_header = Header.long_link_header(name)
+      binary_data = [name].pack("Z*")
 
-    def long_link_header(name, type)
-      Header.new(
-        name: "././@LongLink",
-        mode: 0644,
-        uid: 0,
-        gid: 0,
-        size: name.bytesize + 1,
-        typeflag: type,
-        uname: "root",
-        gname: "root"
-      )
+      @io.write(private_header.to_binary)
+      @io.write(HeaderFormatter.zero_pad(binary_data))
     end
   end
 end

data/lib/mini_tarball/streams/limited_size_stream.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module MiniTarball
+  class WriteOutOfRangeError < StandardError
+  end
+
+  class LimitedSizeStream
+    attr_reader :start_position, :end_position
+    attr_reader :io
+    private :io # TODO change to `private attr_reader :io` after dropping support for Ruby 2.7
+
+    def initialize(io, start_position:, max_file_size:)
+      @io = io
+      @start_position = start_position
+      @end_position = start_position + max_file_size
+    end
+
+    def write(data)
+      current_position = io.pos
+
+      if current_position < start_position || current_position + data.bytesize > end_position
+        raise WriteOutOfRangeError.new("Writing outside of limits not allowed")
+      end
+
+      io.write(data)
+    end
+  end
+end

data/lib/mini_tarball/streams/placeholder_stream.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module MiniTarball
+  class PlaceholderStream < LimitedSizeStream
+    def initialize(io, start_position:, file_size:)
+      super(io, start_position: start_position, max_file_size: file_size)
+    end
+
+    def write(data)
+      super(data)
+
+      if (current_position = io.pos) <= end_position
+        io.write("\0" * (end_position - current_position))
+      end
+    end
+  end
+end

data/lib/mini_tarball/{write_only_stream.rb → streams/write_only_stream.rb}

@@ -7,7 +7,7 @@ module MiniTarball
     end
 
     def write(data)
-      @io.write (data)
+      @io.write(data)
     end
   end
 end

data/lib/mini_tarball/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MiniTarball
-  VERSION = "0.2.0"
+  VERSION = "0.3.1"
 end

data/lib/mini_tarball/writer.rb

@@ -1,17 +1,20 @@
 # frozen_string_literal: true
 
-require 'etc'
+require "etc"
 
 module MiniTarball
+  class NoIOLikeObjectError < StandardError
+  end
+
   class Writer
     END_OF_TAR_BLOCK_SIZE = 1024
 
     # @param [String] filename
     # @yieldparam [Writer]
+    #
+    # :reek:NestedIterators
     def self.create(filename)
-      File.open(filename, "wb") do |file|
-        use(file) { |writer| yield(writer) }
-      end
+      File.open(filename, "wb") { |file| use(file) { |writer| yield(writer) } }
     end
 
     # @param [IO] io
@@ -29,38 +32,68 @@ module MiniTarball
     end
 
     def initialize(io)
-      ensure_valid_io!(io)
+      ensure_valid_io(io)
 
       @io = io
       @write_only_io = WriteOnlyStream.new(@io)
       @header_writer = HeaderWriter.new(@write_only_io)
       @closed = false
+      @placeholders = []
     end
 
-    def add_file(name:, source_file_path:, mode: nil, uname: nil, gname: nil, uid: nil, gid: nil, mtime: nil)
-      ensure_not_closed!
+    # :reek:ControlParameter
+    # :reek:DuplicateMethodCall { allow_calls: ['stat.uid', 'stat.gid'] }
+    # :reek:FeatureEnvy
+    # :reek:LongParameterList
+    # :reek:TooManyStatements
+    def add_file(
+      name:,
+      source_file_path:,
+      mode: nil,
+      uname: nil,
+      gname: nil,
+      uid: nil,
+      gid: nil,
+      mtime: nil
+    )
+      ensure_not_closed
 
-      file = File.open(source_file_path, "rb")
       stat = File.stat(source_file_path)
 
-      @header_writer.write(Header.new(
-        name: name,
-        size: stat.size,
-        mode: mode || stat.mode,
-        uid: uid || stat.uid,
-        gid: gid || stat.gid,
-        uname: uname || Etc.getpwuid(stat.uid).name,
-        gname: gname || Etc.getgrgid(stat.gid).name,
-        mtime: mtime || stat.mtime
-      ))
-
-      IO.copy_stream(file, @write_only_io)
+      @header_writer.write(
+        Header.new(
+          name: name,
+          size: stat.size,
+          mode: mode || stat.mode,
+          uid: uid || stat.uid,
+          gid: gid || stat.gid,
+          uname: uname || Etc.getpwuid(stat.uid).name,
+          gname: gname || Etc.getgrgid(stat.gid).name,
+          mtime: mtime || stat.mtime,
+        ),
+      )
+
+      File.open(source_file_path, "rb") { |file| IO.copy_stream(file, @write_only_io) }
+
       write_padding
       nil
     end
 
-    def add_file_from_stream(name:, mode: 0644, uname: "nobody", gname: "nogroup", uid: nil, gid: nil, mtime: nil)
-      ensure_not_closed!
+    # :reek:ControlParameter
+    # :reek:DuplicateMethodCall { allow_calls: ['@io.pos'] }
+    # :reek:LongParameterList
+    # :reek:TooManyStatements
+    def add_file_from_stream(
+      name:,
+      mode: 0644,
+      uname: "nobody",
+      gname: "nogroup",
+      uid: nil,
+      gid: nil,
+      mtime: nil
+    )
+      ensure_not_closed
+      ensure_seekable_io
 
       header_start_position = @io.pos
       @header_writer.write(Header.new(name: name))
@@ -71,18 +104,63 @@ module MiniTarball
       write_padding
 
       @io.seek(header_start_position)
-      @header_writer.write(Header.new(
-        name: name,
-        size: file_size,
-        mode: mode,
-        uid: uid,
-        gid: gid,
-        uname: uname,
-        gname: gname,
-        mtime: mtime || Time.now.utc
-      ))
+      @header_writer.write(
+        Header.new(
+          name: name,
+          size: file_size,
+          mode: mode,
+          uid: uid,
+          gid: gid,
+          uname: uname,
+          gname: gname,
+          mtime: mtime || Time.now.utc,
+        ),
+      )
+
+      @io.seek(0, IO::SEEK_END)
+      nil
+    end
+
+    # :reek:DuplicateMethodCall { allow_calls: ['@io.pos'] }
+    # :reek:TooManyStatements
+    def add_file_placeholder(name:, file_size:)
+      ensure_not_closed
+
+      placeholder = {}
+      placeholder[:header_start_position] = @io.pos
+      @header_writer.write(Header.new(name: name, size: file_size))
+
+      placeholder[:file_start_position] = @io.pos
+      @io.write("\0" * file_size)
+      placeholder[:file_size] = file_size
 
+      write_padding
+
+      @placeholders << placeholder
+      @placeholders.size - 1
+    end
+
+    # :reek:TooManyStatements
+    def with_placeholder(index)
+      ensure_seekable_io
+
+      placeholder = @placeholders[index]
+      raise ArgumentError.new("Placeholder not found") if !placeholder
+
+      @io.seek(placeholder[:header_start_position])
+      old_write_only_io = @write_only_io
+      @write_only_io =
+        PlaceholderStream.new(
+          @io,
+          start_position: placeholder[:file_start_position],
+          file_size: placeholder[:file_size],
+        )
+
+      yield self
+
+      @write_only_io = old_write_only_io
       @io.seek(0, IO::SEEK_END)
+
       nil
     end
 
@@ -91,25 +169,30 @@ module MiniTarball
     end
 
     def close
-      ensure_not_closed!
+      ensure_not_closed
 
       @io.write("\0" * END_OF_TAR_BLOCK_SIZE)
       @io.close
       @closed = true
     end
 
-    private
+    # :reek:FeatureEnvy
+    # :reek:ManualDispatch
+    private def ensure_valid_io(io)
+      unless io.respond_to?(:pos) && io.respond_to?(:write) && io.respond_to?(:close)
+        raise NoIOLikeObjectError.new("No IO object given")
+      end
+    end
 
-    def ensure_valid_io!(io)
-      raise "No IO object given" unless io.respond_to?(:pos) &&
-        io.respond_to?(:write) && io.respond_to?(:close)
+    private def ensure_seekable_io
+      raise NoIOLikeObjectError.new("No seekable IO object given") unless @io.respond_to?(:seek)
     end
 
-    def ensure_not_closed!
+    private def ensure_not_closed
       raise IOError.new("#{self.class} is closed") if closed?
     end
 
-    def write_padding
+    private def write_padding
       padding_length = (Header::BLOCK_SIZE - @io.pos) % Header::BLOCK_SIZE
       @io.write("\0" * padding_length)
     end

data/lib/mini_tarball.rb

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
-require 'mini_tarball/header'
-require 'mini_tarball/header_formatter'
-require 'mini_tarball/header_writer'
-require 'mini_tarball/write_only_stream'
-require 'mini_tarball/writer'
-require 'mini_tarball/version'
+require "mini_tarball/header"
+require "mini_tarball/header_fields"
+require "mini_tarball/header_formatter"
+require "mini_tarball/header_writer"
+require "mini_tarball/streams/limited_size_stream"
+require "mini_tarball/streams/placeholder_stream"
+require "mini_tarball/streams/write_only_stream"
+require "mini_tarball/writer"
+require "mini_tarball/version"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mini_tarball
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.1
 platform: ruby
 authors:
-- Discourse
+- Discourse Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-03-09 00:00:00.000000000 Z
+date: 2022-12-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -67,7 +67,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: super_diff
+  name: rubycritic
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -94,6 +94,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: super_diff
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: syntax_tree
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email: 
 executables: []
@@ -103,10 +131,13 @@ files:
 - LICENSE.txt
 - lib/mini_tarball.rb
 - lib/mini_tarball/header.rb
+- lib/mini_tarball/header_fields.rb
 - lib/mini_tarball/header_formatter.rb
 - lib/mini_tarball/header_writer.rb
+- lib/mini_tarball/streams/limited_size_stream.rb
+- lib/mini_tarball/streams/placeholder_stream.rb
+- lib/mini_tarball/streams/write_only_stream.rb
 - lib/mini_tarball/version.rb
-- lib/mini_tarball/write_only_stream.rb
 - lib/mini_tarball/writer.rb
 homepage: https://github.com/discourse/mini_tarball
 licenses:
@@ -122,14 +153,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: A minimal implementation of the GNU Tar format.