class Zip::File

# File lib/zip/file.rb, line 170
def count_entries(path_or_io)
  cdir = ::Zip::CentralDirectory.new

  if path_or_io.kind_of?(String)
    ::File.open(path_or_io, 'rb') do |f|
      cdir.count_entries(f)
    end
  else
    cdir.count_entries(path_or_io)
  end
end

# File lib/zip/file.rb, line 162
def foreach(zip_file_name, &block)
  ::Zip::File.open(zip_file_name) do |zip_file|
    zip_file.each(&block)
  end
end

# File lib/zip/file.rb, line 75
def initialize(path_or_io, create: false, buffer: false,
               restore_ownership: DEFAULT_RESTORE_OPTIONS[:restore_ownership],
               restore_permissions: DEFAULT_RESTORE_OPTIONS[:restore_permissions],
               restore_times: DEFAULT_RESTORE_OPTIONS[:restore_times],
               compression_level: ::Zip.default_compression,
               suppress_extra_fields: false)
  super()

  @name    = path_or_io.respond_to?(:path) ? path_or_io.path : path_or_io
  @create  = create ? true : false # allow any truthy value to mean true

  initialize_cdir(path_or_io, buffer: buffer)

  @restore_ownership     = restore_ownership
  @restore_permissions   = restore_permissions
  @restore_times         = restore_times
  @compression_level     = compression_level
  @suppress_extra_fields = suppress_extra_fields
end

# File lib/zip/file.rb, line 99
def open(file_name, create: false,
         restore_ownership: DEFAULT_RESTORE_OPTIONS[:restore_ownership],
         restore_permissions: DEFAULT_RESTORE_OPTIONS[:restore_permissions],
         restore_times: DEFAULT_RESTORE_OPTIONS[:restore_times],
         compression_level: ::Zip.default_compression,
         suppress_extra_fields: false)
  zf = ::Zip::File.new(file_name, create:                create,
                                  restore_ownership:     restore_ownership,
                                  restore_permissions:   restore_permissions,
                                  restore_times:         restore_times,
                                  compression_level:     compression_level,
                                  suppress_extra_fields: suppress_extra_fields)

  return zf unless block_given?

  begin
    yield zf
  ensure
    zf.close
  end
end

# File lib/zip/file.rb, line 125
def open_buffer(io = ::StringIO.new, create: false,
                restore_ownership: DEFAULT_RESTORE_OPTIONS[:restore_ownership],
                restore_permissions: DEFAULT_RESTORE_OPTIONS[:restore_permissions],
                restore_times: DEFAULT_RESTORE_OPTIONS[:restore_times],
                compression_level: ::Zip.default_compression,
                suppress_extra_fields: false)
  unless IO_METHODS.map { |method| io.respond_to?(method) }.all? || io.kind_of?(String)
    raise 'Zip::File.open_buffer expects a String or IO-like argument' \
          "(responds to #{IO_METHODS.join(', ')}). Found: #{io.class}"
  end

  io = ::StringIO.new(io) if io.kind_of?(::String)

  zf = ::Zip::File.new(io, create: create, buffer: true,
                           restore_ownership:     restore_ownership,
                           restore_permissions:   restore_permissions,
                           restore_times:         restore_times,
                           compression_level:     compression_level,
                           suppress_extra_fields: suppress_extra_fields)

  return zf unless block_given?

  yield zf

  begin
    zf.write_buffer(io)
  rescue IOError => e
    raise unless e.message == 'not opened for writing'
  end
end

# File lib/zip/file.rb, line 231
def add(entry, src_path, &continue_on_exists_proc)
  continue_on_exists_proc ||= proc { ::Zip.continue_on_exists_proc }
  check_entry_exists(entry, continue_on_exists_proc, 'add')
  new_entry = if entry.kind_of?(::Zip::Entry)
                entry
              else
                ::Zip::Entry.new(
                  @name, entry.to_s,
                  compression_level: @compression_level
                )
              end
  new_entry.gather_fileinfo_from_srcpath(src_path)
  @cdir << new_entry
end

# File lib/zip/file.rb, line 248
def add_stored(entry, src_path, &continue_on_exists_proc)
  entry = ::Zip::Entry.new(
    @name, entry.to_s, compression_method: ::Zip::Entry::STORED
  )
  add(entry, src_path, &continue_on_exists_proc)
end

# File lib/zip/file.rb, line 318
def close
  commit
end

# File lib/zip/file.rb, line 291
def commit
  return if name.kind_of?(StringIO) || !commit_required?

  on_success_replace do |tmp_file|
    ::Zip::OutputStream.open(tmp_file, suppress_extra_fields: @suppress_extra_fields) do |zos|
      @cdir.each do |e|
        e.write_to_zip_output_stream(zos)
        e.clean_up
      end
      zos.comment = comment
    end
    true
  end
  initialize_cdir(@name)
end

# File lib/zip/file.rb, line 324
def commit_required?
  return true if @create || @cdir.dirty?

  @cdir.each do |e|
    return true if e.dirty?
  end

  false
end

# File lib/zip/file.rb, line 282
def extract(entry, entry_path = nil, destination_directory: '.', &block)
  block ||= proc { ::Zip.on_exists_proc }
  found_entry = get_entry(entry)
  entry_path ||= found_entry.name
  found_entry.extract(entry_path, destination_directory: destination_directory, &block)
end

# File lib/zip/file.rb, line 336
def find_entry(entry_name)
  selected_entry = @cdir.find_entry(entry_name)
  return if selected_entry.nil?

  selected_entry.restore_ownership   = @restore_ownership
  selected_entry.restore_permissions = @restore_permissions
  selected_entry.restore_times       = @restore_times
  selected_entry
end

# File lib/zip/file.rb, line 348
def get_entry(entry)
  selected_entry = find_entry(entry)
  raise Errno::ENOENT, entry if selected_entry.nil?

  selected_entry
end

# File lib/zip/file.rb, line 186
def get_input_stream(entry, &a_proc)
  get_entry(entry).get_input_stream(&a_proc)
end

# File lib/zip/file.rb, line 195
def get_output_stream(entry, permissions: nil, comment: nil,
                      extra: nil, compressed_size: nil, crc: nil,
                      compression_method: nil, compression_level: nil,
                      size: nil, time: nil, &a_proc)
  new_entry =
    if entry.kind_of?(Entry)
      entry
    else
      Entry.new(
        @name, entry.to_s, comment: comment, extra: extra,
        compressed_size: compressed_size, crc: crc, size: size,
        compression_method: compression_method,
        compression_level: compression_level, time: time
      )
    end
  if new_entry.directory?
    raise ArgumentError,
          "cannot open stream to directory entry - '#{new_entry}'"
  end
  new_entry.unix_perms = permissions
  zip_streamable_entry = StreamableStream.new(new_entry)
  @cdir << zip_streamable_entry
  zip_streamable_entry.get_output_stream(&a_proc)
end

# File lib/zip/file.rb, line 356
def mkdir(entry_name, permission = 0o755)
  raise Errno::EEXIST, "File exists - #{entry_name}" if find_entry(entry_name)

  entry_name = entry_name.dup.to_s
  entry_name << '/' unless entry_name.end_with?('/')
  @cdir << ::Zip::StreamableDirectory.new(@name, entry_name, nil, permission)
end

# File lib/zip/file.rb, line 226
def read(entry)
  get_input_stream(entry, &:read)
end

# File lib/zip/file.rb, line 256
def remove(entry)
  @cdir.delete(get_entry(entry))
end

# File lib/zip/file.rb, line 261
def rename(entry, new_name, &continue_on_exists_proc)
  found_entry = get_entry(entry)
  check_entry_exists(new_name, continue_on_exists_proc, 'rename')
  @cdir.delete(found_entry)
  found_entry.name = new_name
  @cdir << found_entry
end

# File lib/zip/file.rb, line 271
def replace(entry, src_path)
  check_file(src_path)
  remove(entry)
  add(entry, src_path)
end

# File lib/zip/file.rb, line 221
def to_s
  @name
end

# File lib/zip/file.rb, line 308
def write_buffer(io = ::StringIO.new)
  return io unless commit_required?

  ::Zip::OutputStream.write_buffer(io, suppress_extra_fields: @suppress_extra_fields) do |zos|
    @cdir.each { |e| e.write_to_zip_output_stream(zos) }
    zos.comment = comment
  end
end

# File lib/zip/file.rb, line 398
def check_entry_exists(entry_name, continue_on_exists_proc, proc_name)
  return unless @cdir.include?(entry_name)

  continue_on_exists_proc ||= proc { Zip.continue_on_exists_proc }
  raise ::Zip::EntryExistsError.new proc_name, entry_name unless continue_on_exists_proc.call

  remove get_entry(entry_name)
end

# File lib/zip/file.rb, line 407
def check_file(path)
  raise Errno::ENOENT, path unless ::File.readable?(path)
end

# File lib/zip/file.rb, line 366
def initialize_cdir(path_or_io, buffer: false)
  @cdir = ::Zip::CentralDirectory.new

  if ::File.size?(@name.to_s)
    # There is a file, which exists, that is associated with this zip.
    @create = false
    @file_permissions = ::File.stat(@name).mode

    if buffer
      # https://github.com/rubyzip/rubyzip/issues/119
      path_or_io.binmode if path_or_io.respond_to?(:binmode)
      @cdir.read_from_stream(path_or_io)
    else
      ::File.open(@name, 'rb') do |f|
        @cdir.read_from_stream(f)
      end
    end
  elsif buffer && path_or_io.size > 0
    # This zip is probably a non-empty StringIO.
    @create = false
    @cdir.read_from_stream(path_or_io)
  elsif !@create && ::File.empty?(@name)
    # A file exists, but it is empty, and we've said we're
    # NOT creating a new zip.
    raise Error, "File #{@name} has zero size. Did you mean to pass the create flag?"
  elsif !@create
    # If we get here, and we're not creating a new zip, then
    # everything is wrong.
    raise Error, "File #{@name} not found"
  end
end

# File lib/zip/file.rb, line 411
def on_success_replace
  dirname, basename = ::File.split(name)
  ::Dir::Tmpname.create(basename, dirname) do |tmp_filename|
    if yield tmp_filename
      ::File.rename(tmp_filename, name)
      ::File.chmod(@file_permissions, name) unless @create
    end
  ensure
    FileUtils.rm_f(tmp_filename)
  end
end