lg_pod_plugin 1.0.8 → 1.0.10

data/lib/zip/entry_set.rb

@@ -1,88 +0,0 @@
-module Zip
-  class EntrySet #:nodoc:all
-    include Enumerable
-    attr_accessor :entry_set, :entry_order
-
-    def initialize(an_enumerable = [])
-      super()
-      @entry_set = {}
-      an_enumerable.each { |o| push(o) }
-    end
-
-    def include?(entry)
-      @entry_set.include?(to_key(entry))
-    end
-
-    def find_entry(entry)
-      @entry_set[to_key(entry)]
-    end
-
-    def <<(entry)
-      @entry_set[to_key(entry)] = entry if entry
-    end
-
-    alias push <<
-
-    def size
-      @entry_set.size
-    end
-
-    alias length size
-
-    def delete(entry)
-      entry if @entry_set.delete(to_key(entry))
-    end
-
-    def each
-      @entry_set = sorted_entries.dup.each do |_, value|
-        yield(value)
-      end
-    end
-
-    def entries
-      sorted_entries.values
-    end
-
-    # deep clone
-    def dup
-      EntrySet.new(@entry_set.values.map(&:dup))
-    end
-
-    def ==(other)
-      return false unless other.kind_of?(EntrySet)
-
-      @entry_set.values == other.entry_set.values
-    end
-
-    def parent(entry)
-      @entry_set[to_key(entry.parent_as_string)]
-    end
-
-    def glob(pattern, flags = ::File::FNM_PATHNAME | ::File::FNM_DOTMATCH | ::File::FNM_EXTGLOB)
-      entries.map do |entry|
-        next nil unless ::File.fnmatch(pattern, entry.name.chomp('/'), flags)
-
-        yield(entry) if block_given?
-        entry
-      end.compact
-    end
-
-    protected
-
-    def sorted_entries
-      ::Zip.sort_entries ? Hash[@entry_set.sort] : @entry_set
-    end
-
-    private
-
-    def to_key(entry)
-      k = entry.to_s.chomp('/')
-      k.downcase! if ::Zip.case_insensitive_match
-      k
-    end
-  end
-end
-
-# Copyright (C) 2002, 2003 Thomas Sondergaard
-# rubyzip is free software; you can redistribute it and/or
-# modify it under the terms of the ruby license.

data/lib/zip/errors.rb

@@ -1,19 +0,0 @@
-module Zip
-  class Error < StandardError; end
-  class EntryExistsError < Error; end
-  class DestinationFileExistsError < Error; end
-  class CompressionMethodError < Error; end
-  class EntryNameError < Error; end
-  class EntrySizeError < Error; end
-  class InternalError < Error; end
-  class GPFBit3Error < Error; end
-  class DecompressionError < Error; end
-
-  # Backwards compatibility with v1 (delete in v2)
-  ZipError = Error
-  ZipEntryExistsError = EntryExistsError
-  ZipDestinationFileExistsError = DestinationFileExistsError
-  ZipCompressionMethodError = CompressionMethodError
-  ZipEntryNameError = EntryNameError
-  ZipInternalError = InternalError
-end

data/lib/zip/extra_field/generic.rb

@@ -1,44 +0,0 @@
-module Zip
-  class ExtraField::Generic
-    def self.register_map
-      return unless const_defined?(:HEADER_ID)
-
-      ::Zip::ExtraField::ID_MAP[const_get(:HEADER_ID)] = self
-    end
-
-    def self.name
-      @name ||= to_s.split('::')[-1]
-    end
-
-    # return field [size, content] or false
-    def initial_parse(binstr)
-      return false unless binstr
-
-      if binstr[0, 2] != self.class.const_get(:HEADER_ID)
-        warn 'WARNING: weird extra field header ID. Skip parsing it.'
-        return false
-      end
-
-      [binstr[2, 2].unpack1('v'), binstr[4..-1]]
-    end
-
-    def ==(other)
-      return false if self.class != other.class
-
-      each do |k, v|
-        return false if v != other[k]
-      end
-      true
-    end
-
-    def to_local_bin
-      s = pack_for_local
-      self.class.const_get(:HEADER_ID) + [s.bytesize].pack('v') << s
-    end
-
-    def to_c_dir_bin
-      s = pack_for_c_dir
-      self.class.const_get(:HEADER_ID) + [s.bytesize].pack('v') << s
-    end
-  end
-end

data/lib/zip/extra_field/ntfs.rb

@@ -1,94 +0,0 @@
-module Zip
-  # PKWARE NTFS Extra Field (0x000a)
-  # Only Tag 0x0001 is supported
-  class ExtraField::NTFS < ExtraField::Generic
-    HEADER_ID = [0x000A].pack('v')
-    register_map
-
-    WINDOWS_TICK = 10_000_000.0
-    SEC_TO_UNIX_EPOCH = 11_644_473_600
-
-    def initialize(binstr = nil)
-      @ctime = nil
-      @mtime = nil
-      @atime = nil
-      binstr && merge(binstr)
-    end
-
-    attr_accessor :atime, :ctime, :mtime
-
-    def merge(binstr)
-      return if binstr.empty?
-
-      size, content = initial_parse(binstr)
-      (size && content) || return
-
-      content = content[4..-1]
-      tags = parse_tags(content)
-
-      tag1 = tags[1]
-      return unless tag1
-
-      ntfs_mtime, ntfs_atime, ntfs_ctime = tag1.unpack('Q<Q<Q<')
-      ntfs_mtime && @mtime ||= from_ntfs_time(ntfs_mtime)
-      ntfs_atime && @atime ||= from_ntfs_time(ntfs_atime)
-      ntfs_ctime && @ctime ||= from_ntfs_time(ntfs_ctime)
-    end
-
-    def ==(other)
-      @mtime == other.mtime &&
-        @atime == other.atime &&
-        @ctime == other.ctime
-    end
-
-    # Info-ZIP note states this extra field is stored at local header
-    def pack_for_local
-      pack_for_c_dir
-    end
-
-    # But 7-zip for Windows only stores at central dir
-    def pack_for_c_dir
-      # reserved 0 and tag 1
-      s = [0, 1].pack('Vv')
-
-      tag1 = ''.force_encoding(Encoding::BINARY)
-      if @mtime
-        tag1 << [to_ntfs_time(@mtime)].pack('Q<')
-        if @atime
-          tag1 << [to_ntfs_time(@atime)].pack('Q<')
-          tag1 << [to_ntfs_time(@ctime)].pack('Q<') if @ctime
-        end
-      end
-      s << [tag1.bytesize].pack('v') << tag1
-      s
-    end
-
-    private
-
-    def parse_tags(content)
-      return {} if content.nil?
-
-      tags = {}
-      i = 0
-      while i < content.bytesize
-        tag, size = content[i, 4].unpack('vv')
-        i += 4
-        break unless tag && size
-
-        value = content[i, size]
-        i += size
-        tags[tag] = value
-      end
-
-      tags
-    end
-
-    def from_ntfs_time(ntfs_time)
-      ::Zip::DOSTime.at(ntfs_time / WINDOWS_TICK - SEC_TO_UNIX_EPOCH)
-    end
-
-    def to_ntfs_time(time)
-      ((time.to_f + SEC_TO_UNIX_EPOCH) * WINDOWS_TICK).to_i
-    end
-  end
-end

data/lib/zip/extra_field/old_unix.rb

@@ -1,46 +0,0 @@
-module Zip
-  # Olf Info-ZIP Extra for UNIX uid/gid and file timestampes
-  class ExtraField::OldUnix < ExtraField::Generic
-    HEADER_ID = 'UX'
-    register_map
-
-    def initialize(binstr = nil)
-      @uid = 0
-      @gid = 0
-      @atime = nil
-      @mtime = nil
-      binstr && merge(binstr)
-    end
-
-    attr_accessor :uid, :gid, :atime, :mtime
-
-    def merge(binstr)
-      return if binstr.empty?
-
-      size, content = initial_parse(binstr)
-      # size: 0 for central directory. 4 for local header
-      return if !size || size == 0
-
-      atime, mtime, uid, gid = content.unpack('VVvv')
-      @uid ||= uid
-      @gid ||= gid
-      @atime ||= atime
-      @mtime ||= mtime # rubocop:disable Naming/MemoizedInstanceVariableName
-    end
-
-    def ==(other)
-      @uid == other.uid &&
-        @gid == other.gid &&
-        @atime == other.atime &&
-        @mtime == other.mtime
-    end
-
-    def pack_for_local
-      [@atime, @mtime, @uid, @gid].pack('VVvv')
-    end
-
-    def pack_for_c_dir
-      [@atime, @mtime].pack('VV')
-    end
-  end
-end

data/lib/zip/extra_field/universal_time.rb

@@ -1,77 +0,0 @@
-module Zip
-  # Info-ZIP Additional timestamp field
-  class ExtraField::UniversalTime < ExtraField::Generic
-    HEADER_ID = 'UT'
-    register_map
-
-    ATIME_MASK = 0b010
-    CTIME_MASK = 0b100
-    MTIME_MASK = 0b001
-
-    def initialize(binstr = nil)
-      @ctime = nil
-      @mtime = nil
-      @atime = nil
-      @flag  = 0
-
-      merge(binstr) unless binstr.nil?
-    end
-
-    attr_reader :atime, :ctime, :mtime, :flag
-
-    def atime=(time)
-      @flag = time.nil? ? @flag & ~ATIME_MASK : @flag | ATIME_MASK
-      @atime = time
-    end
-
-    def ctime=(time)
-      @flag = time.nil? ? @flag & ~CTIME_MASK : @flag | CTIME_MASK
-      @ctime = time
-    end
-
-    def mtime=(time)
-      @flag = time.nil? ? @flag & ~MTIME_MASK : @flag | MTIME_MASK
-      @mtime = time
-    end
-
-    def merge(binstr)
-      return if binstr.empty?
-
-      size, content = initial_parse(binstr)
-      return if !size || size <= 0
-
-      @flag, *times = content.unpack('Cl<l<l<')
-
-      # Parse the timestamps, in order, based on which flags are set.
-      return if times[0].nil?
-
-      @mtime ||= ::Zip::DOSTime.at(times.shift) unless @flag & MTIME_MASK == 0
-      return if times[0].nil?
-
-      @atime ||= ::Zip::DOSTime.at(times.shift) unless @flag & ATIME_MASK == 0
-      return if times[0].nil?
-
-      @ctime ||= ::Zip::DOSTime.at(times.shift) unless @flag & CTIME_MASK == 0
-    end
-
-    def ==(other)
-      @mtime == other.mtime &&
-        @atime == other.atime &&
-        @ctime == other.ctime
-    end
-
-    def pack_for_local
-      s = [@flag].pack('C')
-      s << [@mtime.to_i].pack('l<') unless @flag & MTIME_MASK == 0
-      s << [@atime.to_i].pack('l<') unless @flag & ATIME_MASK == 0
-      s << [@ctime.to_i].pack('l<') unless @flag & CTIME_MASK == 0
-      s
-    end
-
-    def pack_for_c_dir
-      s = [@flag].pack('C')
-      s << [@mtime.to_i].pack('l<') unless @flag & MTIME_MASK == 0
-      s
-    end
-  end
-end

data/lib/zip/extra_field/unix.rb

@@ -1,39 +0,0 @@
-module Zip
-  # Info-ZIP Extra for UNIX uid/gid
-  class ExtraField::IUnix < ExtraField::Generic
-    HEADER_ID = 'Ux'
-    register_map
-
-    def initialize(binstr = nil)
-      @uid = 0
-      @gid = 0
-      binstr && merge(binstr)
-    end
-
-    attr_accessor :uid, :gid
-
-    def merge(binstr)
-      return if binstr.empty?
-
-      size, content = initial_parse(binstr)
-      # size: 0 for central directory. 4 for local header
-      return if !size || size == 0
-
-      uid, gid = content.unpack('vv')
-      @uid ||= uid
-      @gid ||= gid # rubocop:disable Naming/MemoizedInstanceVariableName
-    end
-
-    def ==(other)
-      @uid == other.uid && @gid == other.gid
-    end
-
-    def pack_for_local
-      [@uid, @gid].pack('vv')
-    end
-
-    def pack_for_c_dir
-      ''
-    end
-  end
-end

data/lib/zip/extra_field/zip64.rb

@@ -1,70 +0,0 @@
-module Zip
-  # Info-ZIP Extra for Zip64 size
-  class ExtraField::Zip64 < ExtraField::Generic
-    attr_accessor :original_size, :compressed_size, :relative_header_offset, :disk_start_number
-    HEADER_ID = ['0100'].pack('H*')
-    register_map
-
-    def initialize(binstr = nil)
-      # unparsed binary; we don't actually know what this contains
-      # without looking for FFs in the associated file header
-      # call parse after initializing with a binary string
-      @content                = nil
-      @original_size          = nil
-      @compressed_size        = nil
-      @relative_header_offset = nil
-      @disk_start_number      = nil
-      binstr && merge(binstr)
-    end
-
-    def ==(other)
-      other.original_size == @original_size &&
-        other.compressed_size == @compressed_size &&
-        other.relative_header_offset == @relative_header_offset &&
-        other.disk_start_number == @disk_start_number
-    end
-
-    def merge(binstr)
-      return if binstr.empty?
-
-      _, @content = initial_parse(binstr)
-    end
-
-    # pass the values from the base entry (if applicable)
-    # wider values are only present in the extra field for base values set to all FFs
-    # returns the final values for the four attributes (from the base or zip64 extra record)
-    def parse(original_size, compressed_size, relative_header_offset = nil, disk_start_number = nil)
-      @original_size = extract(8, 'Q<') if original_size == 0xFFFFFFFF
-      @compressed_size = extract(8, 'Q<') if compressed_size == 0xFFFFFFFF
-      @relative_header_offset = extract(8, 'Q<') if relative_header_offset && relative_header_offset == 0xFFFFFFFF
-      @disk_start_number = extract(4, 'V') if disk_start_number && disk_start_number == 0xFFFF
-      @content = nil
-      [@original_size || original_size,
-       @compressed_size || compressed_size,
-       @relative_header_offset || relative_header_offset,
-       @disk_start_number || disk_start_number]
-    end
-
-    def extract(size, format)
-      @content.slice!(0, size).unpack1(format)
-    end
-    private :extract
-
-    def pack_for_local
-      # local header entries must contain original size and compressed size; other fields do not apply
-      return '' unless @original_size && @compressed_size
-
-      [@original_size, @compressed_size].pack('Q<Q<')
-    end
-
-    def pack_for_c_dir
-      # central directory entries contain only fields that didn't fit in the main entry part
-      packed = ''.force_encoding('BINARY')
-      packed << [@original_size].pack('Q<') if @original_size
-      packed << [@compressed_size].pack('Q<') if @compressed_size
-      packed << [@relative_header_offset].pack('Q<') if @relative_header_offset
-      packed << [@disk_start_number].pack('V') if @disk_start_number
-      packed
-    end
-  end
-end

data/lib/zip/extra_field/zip64_placeholder.rb

@@ -1,15 +0,0 @@
-module Zip
-  # placeholder to reserve space for a Zip64 extra information record, for the
-  # local file header only, that we won't know if we'll need until after
-  # we write the file data
-  class ExtraField::Zip64Placeholder < ExtraField::Generic
-    HEADER_ID = ['9999'].pack('H*') # this ID is used by other libraries such as .NET's Ionic.zip
-    register_map
-
-    def initialize(_binstr = nil); end
-
-    def pack_for_local
-      "\x00" * 16
-    end
-  end
-end

data/lib/zip/extra_field.rb

@@ -1,103 +0,0 @@
-module Zip
-  class ExtraField < Hash
-    ID_MAP = {}
-
-    def initialize(binstr = nil)
-      merge(binstr) if binstr
-    end
-
-    def extra_field_type_exist(binstr, id, len, index)
-      field_name = ID_MAP[id].name
-      if member?(field_name)
-        self[field_name].merge(binstr[index, len + 4])
-      else
-        field_obj        = ID_MAP[id].new(binstr[index, len + 4])
-        self[field_name] = field_obj
-      end
-    end
-
-    def extra_field_type_unknown(binstr, len, index)
-      create_unknown_item unless self['Unknown']
-      if !len || len + 4 > binstr[index..-1].bytesize
-        self['Unknown'] << binstr[index..-1]
-        return
-      end
-      self['Unknown'] << binstr[index, len + 4]
-    end
-
-    def create_unknown_item
-      s = +''
-      class << s
-        alias_method :to_c_dir_bin, :to_s
-        alias_method :to_local_bin, :to_s
-      end
-      self['Unknown'] = s
-    end
-
-    def merge(binstr)
-      return if binstr.empty?
-
-      i = 0
-      while i < binstr.bytesize
-        id  = binstr[i, 2]
-        len = binstr[i + 2, 2].to_s.unpack1('v')
-        if id && ID_MAP.member?(id)
-          extra_field_type_exist(binstr, id, len, i)
-        elsif id
-          create_unknown_item unless self['Unknown']
-          break unless extra_field_type_unknown(binstr, len, i)
-        end
-        i += len + 4
-      end
-    end
-
-    def create(name)
-      unless (field_class = ID_MAP.values.find { |k| k.name == name })
-        raise Error, "Unknown extra field '#{name}'"
-      end
-
-      self[name] = field_class.new
-    end
-
-    # place Unknown last, so "extra" data that is missing the proper signature/size
-    # does not prevent known fields from being read back in
-    def ordered_values
-      result = []
-      each { |k, v| k == 'Unknown' ? result.push(v) : result.unshift(v) }
-      result
-    end
-
-    def to_local_bin
-      ordered_values.map! { |v| v.to_local_bin.force_encoding('BINARY') }.join
-    end
-
-    alias to_s to_local_bin
-
-    def to_c_dir_bin
-      ordered_values.map! { |v| v.to_c_dir_bin.force_encoding('BINARY') }.join
-    end
-
-    def c_dir_size
-      to_c_dir_bin.bytesize
-    end
-
-    def local_size
-      to_local_bin.bytesize
-    end
-
-    alias length local_size
-    alias size local_size
-  end
-end
-
-require 'zip/extra_field/generic'
-require 'zip/extra_field/universal_time'
-require 'zip/extra_field/old_unix'
-require 'zip/extra_field/unix'
-require 'zip/extra_field/zip64'
-require 'zip/extra_field/zip64_placeholder'
-require 'zip/extra_field/ntfs'
-
-# Copyright (C) 2002, 2003 Thomas Sondergaard
-# rubyzip is free software; you can redistribute it and/or
-# modify it under the terms of the ruby license.