logstash-filter-delta 1.0.0

data/vendor/bundle/jruby/2.2.0/gems/rubyzip-1.1.7/lib/zip/entry_set.rb

@@ -0,0 +1,86 @@
+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
+    end
+
+    alias :push :<<
+
+    def size
+      @entry_set.size
+    end
+
+    alias :length :size
+
+    def delete(entry)
+      if @entry_set.delete(to_key(entry))
+        entry
+      else
+        nil
+      end
+    end
+
+    def each(&block)
+      @entry_set = sorted_entries.dup.each do |_, value|
+        block.call(value)
+      end
+    end
+
+    def entries
+      sorted_entries.values
+    end
+
+    # deep clone
+    def dup
+      EntrySet.new(@entry_set.map { |key, value| value.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)
+      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)
+      entry.to_s.chomp('/')
+    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/vendor/bundle/jruby/2.2.0/gems/rubyzip-1.1.7/lib/zip/errors.rb

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

data/vendor/bundle/jruby/2.2.0/gems/rubyzip-1.1.7/lib/zip/extra_field/generic.rb

@@ -0,0 +1,43 @@
+module Zip
+  class ExtraField::Generic
+    def self.register_map
+      if self.const_defined?(:HEADER_ID)
+        ::Zip::ExtraField::ID_MAP[self.const_get(:HEADER_ID)] = self
+      end
+    end
+
+    def self.name
+      @name ||= self.to_s.split("::")[-1]
+    end
+
+    # return field [size, content] or false
+    def initial_parse(binstr)
+      if !binstr
+        # If nil, start with empty.
+        return false
+      elsif binstr[0, 2] != self.class.const_get(:HEADER_ID)
+        $stderr.puts "Warning: weired extra feild header ID. skip parsing"
+        return false
+      end
+      [binstr[2, 2].unpack("v")[0], binstr[4..-1]]
+    end
+
+    def ==(other)
+      return false if self.class != other.class
+      each do |k, v|
+        v != other[k] and return false
+      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/vendor/bundle/jruby/2.2.0/gems/rubyzip-1.1.7/lib/zip/extra_field/ntfs.rb

@@ -0,0 +1,92 @@
+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 = 10000000.0
+    SEC_TO_UNIX_EPOCH = 11644473600
+
+    def initialize(binstr = nil)
+      @ctime = nil
+      @mtime = nil
+      @atime = nil
+      binstr and merge(binstr)
+    end
+
+    attr_accessor :atime, :ctime, :mtime
+
+    def merge(binstr)
+      return if binstr.empty?
+      size, content = initial_parse(binstr)
+      (size && content) or return
+
+      content = content[4..-1]
+      tags = parse_tags(content)
+
+      tag1 = tags[1]
+      if tag1
+        ntfs_mtime, ntfs_atime, ntfs_ctime = tag1.unpack("Q<Q<Q<")
+        ntfs_mtime and @mtime ||= from_ntfs_time(ntfs_mtime)
+        ntfs_atime and @atime ||= from_ntfs_time(ntfs_atime)
+        ntfs_ctime and @ctime ||= from_ntfs_time(ntfs_ctime)
+      end
+    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<')
+          if @ctime
+            tag1 << [to_ntfs_time(@ctime)].pack('Q<')
+          end
+        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 do
+        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/vendor/bundle/jruby/2.2.0/gems/rubyzip-1.1.7/lib/zip/extra_field/old_unix.rb

@@ -0,0 +1,45 @@
+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 and 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
+    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/vendor/bundle/jruby/2.2.0/gems/rubyzip-1.1.7/lib/zip/extra_field/universal_time.rb

@@ -0,0 +1,47 @@
+module Zip
+  # Info-ZIP Additional timestamp field
+  class ExtraField::UniversalTime < ExtraField::Generic
+    HEADER_ID = "UT"
+    register_map
+
+    def initialize(binstr = nil)
+      @ctime = nil
+      @mtime = nil
+      @atime = nil
+      @flag  = nil
+      binstr and merge(binstr)
+    end
+
+    attr_accessor :atime, :ctime, :mtime, :flag
+
+    def merge(binstr)
+      return if binstr.empty?
+      size, content = initial_parse(binstr)
+      size or return
+      @flag, mtime, atime, ctime = content.unpack("CVVV")
+      mtime and @mtime ||= ::Zip::DOSTime.at(mtime)
+      atime and @atime ||= ::Zip::DOSTime.at(atime)
+      ctime and @ctime ||= ::Zip::DOSTime.at(ctime)
+    end
+
+    def ==(other)
+      @mtime == other.mtime &&
+        @atime == other.atime &&
+        @ctime == other.ctime
+    end
+
+    def pack_for_local
+      s = [@flag].pack("C")
+      @flag & 1 != 0 and s << [@mtime.to_i].pack("V")
+      @flag & 2 != 0 and s << [@atime.to_i].pack("V")
+      @flag & 4 != 0 and s << [@ctime.to_i].pack("V")
+      s
+    end
+
+    def pack_for_c_dir
+      s = [@flag].pack("C")
+      @flag & 1 == 1 and s << [@mtime.to_i].pack("V")
+      s
+    end
+  end
+end

data/vendor/bundle/jruby/2.2.0/gems/rubyzip-1.1.7/lib/zip/extra_field/unix.rb

@@ -0,0 +1,38 @@
+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 and 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
+    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/vendor/bundle/jruby/2.2.0/gems/rubyzip-1.1.7/lib/zip/extra_field/zip64.rb

@@ -0,0 +1,67 @@
+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)
+      @content = 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
+      @original_size          = nil
+      @compressed_size        = nil
+      @relative_header_offset = nil
+      @disk_start_number      = nil
+      binstr and 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).unpack(format)[0]
+    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/vendor/bundle/jruby/2.2.0/gems/rubyzip-1.1.7/lib/zip/extra_field/zip64_placeholder.rb

@@ -0,0 +1,16 @@
+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/vendor/bundle/jruby/2.2.0/gems/rubyzip-1.1.7/lib/zip/extra_field.rb

@@ -0,0 +1,101 @@
+module Zip
+  class ExtraField < Hash
+    ID_MAP = {}
+
+    def initialize(binstr = nil)
+      binstr and merge(binstr)
+    end
+
+    def extra_field_type_exist(binstr, id, len, i)
+      field_name = ID_MAP[id].name
+      if self.member?(field_name)
+        self[field_name].merge(binstr[i, len + 4])
+      else
+        field_obj        = ID_MAP[id].new(binstr[i, len + 4])
+        self[field_name] = field_obj
+      end
+    end
+
+    def extra_field_type_unknown(binstr, len, i)
+      create_unknown_item unless self['Unknown']
+      if !len || len + 4 > binstr[i..-1].bytesize
+        self['Unknown'] << binstr[i..-1]
+        return
+      end
+      self['Unknown'] << binstr[i, 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.unpack('v').first
+        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 = []
+      self.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.