hotplate 0.1.1 → 1.0.0

data/lib/hotplate/gems/rubyzip-1.1.7/lib/zip/entry_set.rb

@@ -1,86 +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
-    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/lib/hotplate/gems/rubyzip-1.1.7/lib/zip/errors.rb

@@ -1,16 +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 InternalError < Error; end
-
-  # Backwards compatibility with v1 (delete in v2)
-  ZipError = Error
-  ZipEntryExistsError = EntryExistsError
-  ZipDestinationFileExistsError = DestinationFileExistsError
-  ZipCompressionMethodError = CompressionMethodError
-  ZipEntryNameError = EntryNameError
-  ZipInternalError = InternalError
-end

data/lib/hotplate/gems/rubyzip-1.1.7/lib/zip/extra_field/generic.rb

@@ -1,43 +0,0 @@
-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/lib/hotplate/gems/rubyzip-1.1.7/lib/zip/extra_field/ntfs.rb

@@ -1,92 +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 = 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/lib/hotplate/gems/rubyzip-1.1.7/lib/zip/extra_field/old_unix.rb

@@ -1,45 +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 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/lib/hotplate/gems/rubyzip-1.1.7/lib/zip/extra_field/universal_time.rb

@@ -1,47 +0,0 @@
-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/lib/hotplate/gems/rubyzip-1.1.7/lib/zip/extra_field/unix.rb

@@ -1,38 +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 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/lib/hotplate/gems/rubyzip-1.1.7/lib/zip/extra_field/zip64.rb

@@ -1,67 +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)
-      @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/lib/hotplate/gems/rubyzip-1.1.7/lib/zip/extra_field/zip64_placeholder.rb

@@ -1,16 +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/hotplate/gems/rubyzip-1.1.7/lib/zip/extra_field.rb

@@ -1,101 +0,0 @@
-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.