lg_pod_plugin 1.0.4 → 1.0.6

data/lib/rchardet/sbcsgroupprober.rb

@@ -0,0 +1,58 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is Mozilla Universal charset detector code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 2001
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Jeff Hodges - port to Ruby
+#   Mark Pilgrim - port to Python
+#   Shy Shalom - original C code
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+# 
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+# 
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+module CharDet
+  class SBCSGroupProber < CharSetGroupProber
+    def initialize
+      super
+      @probers = [ 
+                    SingleByteCharSetProber.new(Win1251CyrillicModel),
+                    SingleByteCharSetProber.new(Koi8rModel),
+                    SingleByteCharSetProber.new(Latin5CyrillicModel),
+                    SingleByteCharSetProber.new(MacCyrillicModel),
+                    SingleByteCharSetProber.new(Ibm866Model),
+                    SingleByteCharSetProber.new(Ibm855Model),
+                    SingleByteCharSetProber.new(Latin7GreekModel),
+                    SingleByteCharSetProber.new(Win1253GreekModel),
+                    SingleByteCharSetProber.new(Latin5BulgarianModel),
+                    SingleByteCharSetProber.new(Win1251BulgarianModel),
+                    SingleByteCharSetProber.new(Latin2HungarianModel),
+                    SingleByteCharSetProber.new(Win1250HungarianModel),
+                    SingleByteCharSetProber.new(TIS620ThaiModel),
+                   ]
+      hebrewProber = HebrewProber.new()
+      logicalHebrewProber = SingleByteCharSetProber.new(Win1255HebrewModel, false, hebrewProber)
+      visualHebrewProber = SingleByteCharSetProber.new(Win1255HebrewModel, true, hebrewProber)
+      hebrewProber.set_model_probers(logicalHebrewProber, visualHebrewProber)
+      @probers += [hebrewProber, logicalHebrewProber, visualHebrewProber]
+
+      reset()
+    end
+  end
+end

data/lib/rchardet/sjisprober.rb

@@ -0,0 +1,88 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 1998
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Jeff Hodges - port to Ruby
+#   Mark Pilgrim - port to Python
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+# 
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+# 
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+module CharDet
+  class SJISProber < MultiByteCharSetProber
+    def initialize
+      super()
+      @codingSM = CodingStateMachine.new(SJISSMModel)
+      @distributionAnalyzer = SJISDistributionAnalysis.new()
+      @contextAnalyzer = SJISContextAnalysis.new()
+      reset()
+    end
+
+    def reset
+      super()
+      @contextAnalyzer.reset()
+    end
+
+    def get_charset_name
+      return "SHIFT_JIS"
+    end
+
+    def feed(aBuf)
+      aLen = aBuf.length
+      for i in (0...aLen)
+        codingState = @codingSM.next_state(aBuf[i,1])
+        if codingState == EError
+          $stderr << "#{get_charset_name} prober hit error at byte #{i}\n" if $debug
+          @state = ENotMe
+          break
+        elsif codingState == EItsMe
+          @state = EFoundIt
+          break
+        elsif codingState == EStart
+          charLen = @codingSM.get_current_charlen()
+          if i == 0
+            @lastChar[1] = aBuf[0, 1]
+            @contextAnalyzer.feed(@lastChar[2-charLen, 1], charLen)
+            @distributionAnalyzer.feed(@lastChar, charLen)
+          else
+            @contextAnalyzer.feed(aBuf[i+1-charLen, 2], charLen)
+            @distributionAnalyzer.feed(aBuf[i-1, 2], charLen)
+          end
+        end
+      end
+
+      @lastChar[0] = aBuf[aLen-1, 1]
+
+      if get_state() == EDetecting
+        if @contextAnalyzer.got_enough_data() and (get_confidence() > SHORTCUT_THRESHOLD)
+          @state = EFoundIt
+        end
+      end
+
+      return get_state()
+    end
+
+    def get_confidence
+      l = [@contextAnalyzer.get_confidence(), @distributionAnalyzer.get_confidence()]
+      return l.max
+    end
+  end
+end

data/lib/rchardet/universaldetector.rb

@@ -0,0 +1,179 @@
+# encoding: US-ASCII
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is Mozilla Universal charset detector code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 2001
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Jeff Hodges - port to Ruby
+#   Mark Pilgrim - port to Python
+#   Shy Shalom - original C code
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+# 
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+# 
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+module CharDet
+  MINIMUM_DATA_THRESHOLD = 4
+  MINIMUM_THRESHOLD = 0.20
+  EPureAscii = 0
+  EEscAscii = 1
+  EHighbyte = 2
+
+  class UniversalDetector
+    attr_reader :done, :result
+
+    def initialize
+      @highBitDetector = /[\x80-\xFF]/n
+      @escDetector = /(\033|\~\{)/n
+      @escCharSetProber = nil
+      @charSetProbers = []
+      reset()
+    end
+
+    def reset
+      @result = {'encoding' => nil, 'confidence' => 0.0}
+      @done = false
+      @start = true
+      @gotData = false
+      @inputState = EPureAscii
+      @lastChar = ''
+      if @escCharSetProber
+        @escCharSetProber.reset()
+      end
+      for prober in @charSetProbers
+        prober.reset()
+      end
+    end
+
+    def feed(aBuf)
+      return if @done
+
+      aLen = aBuf.length
+      return if aLen == 0
+
+      if !@gotData
+        # If the data starts with BOM, we know it is UTF
+        if aBuf[0, 3] == "\xEF\xBB\xBF"
+          # EF BB BF  UTF-8 with BOM
+          @result = {'encoding' => "UTF-8", 'confidence' => 1.0}
+        elsif aBuf[0, 4] == "\xFF\xFE\x00\x00"
+          # FF FE 00 00  UTF-32, little-endian BOM
+          @result = {'encoding' => "UTF-32LE", 'confidence' => 1.0}
+        elsif aBuf[0, 4] == "\x00\x00\xFE\xFF"
+          # 00 00 FE FF  UTF-32, big-endian BOM
+          @result = {'encoding' => "UTF-32BE", 'confidence' => 1.0}
+        elsif aBuf[0, 4] == "\xFE\xFF\x00\x00"
+          # FE FF 00 00  UCS-4, unusual octet order BOM (3412)
+          @result = {'encoding' => "X-ISO-10646-UCS-4-3412", 'confidence' => 1.0}
+        elsif aBuf[0, 4] == "\x00\x00\xFF\xFE"
+          # 00 00 FF FE  UCS-4, unusual octet order BOM (2143)
+          @result = {'encoding' =>  "X-ISO-10646-UCS-4-2143", 'confidence' =>  1.0}
+        elsif aBuf[0, 2] == "\xFF\xFE"
+          # FF FE  UTF-16, little endian BOM
+          @result = {'encoding' =>  "UTF-16LE", 'confidence' =>  1.0}
+        elsif aBuf[0, 2] == "\xFE\xFF"
+          # FE FF  UTF-16, big endian BOM
+          @result = {'encoding' =>  "UTF-16BE", 'confidence' =>  1.0}
+        elsif aBuf[0, 3] == "\x2B\x2F\x76" && ["\x38", "\x39", "\x2B", "\x2F"].include?(aBuf[3, 1])
+          # NOTE: Ruby only includes "dummy" support for UTF-7.
+          # A Ruby UTF-7 string can't have methods called on it, nor can it be converted to anything else, but "BINARY"/"ASCII-8BIT".
+          # Still, this doesn't make detection useless, as UTF-7 encodings exist in the wild, and the scenario may need to be handled.
+          # 2B 2F 76 38  UTF-7
+          # 2B 2F 76 39  UTF-7
+          # 2B 2F 76 2B  UTF-7
+          # 2B 2F 76 2F  UTF-7
+          # 2B 2F 76 38 2D  UTF-7 with no following character (empty string)
+          @result = {'encoding' =>  "UTF-7", 'confidence' =>  0.99}
+        end
+      end
+
+      @gotData = true
+      if @result['encoding'] and (@result['confidence'] > 0.0)
+        @done = true
+        return
+      end
+      if @inputState == EPureAscii
+        if @highBitDetector =~ (aBuf)
+          @inputState = EHighbyte
+        elsif (@inputState == EPureAscii) and @escDetector =~ (@lastChar + aBuf)
+          @inputState = EEscAscii
+        end
+      end
+
+      @lastChar = aBuf[-1, 1]
+      if @inputState == EEscAscii
+        if !@escCharSetProber
+          @escCharSetProber = EscCharSetProber.new()
+        end
+        if @escCharSetProber.feed(aBuf) == EFoundIt
+          @result = {'encoding' =>  @escCharSetProber.get_charset_name(),
+            'confidence' =>  @escCharSetProber.get_confidence()
+          }
+          @done = true
+        end
+      elsif @inputState == EHighbyte
+        if @charSetProbers.nil? || @charSetProbers.empty?
+          @charSetProbers = [MBCSGroupProber.new(), SBCSGroupProber.new(), Latin1Prober.new()]
+        end
+        for prober in @charSetProbers
+          if prober.feed(aBuf) == EFoundIt
+            @result = {'encoding' =>  prober.get_charset_name(),
+              'confidence' =>  prober.get_confidence()}
+            @done = true
+            break
+          end
+        end
+      end
+
+    end
+
+    def close
+      return if @done
+      if !@gotData
+        $stderr << "no data received!\n" if $debug
+        return
+      end
+      @done = true
+
+      if @inputState == EPureAscii
+        @result = {'encoding' => 'ascii', 'confidence' => 1.0}
+        return @result
+      end
+
+      if @inputState == EHighbyte
+        confidences = {}
+        @charSetProbers.each{ |prober| confidences[prober] = prober.get_confidence }
+        maxProber = @charSetProbers.max{ |a,b| confidences[a] <=> confidences[b] }
+        if maxProber and maxProber.get_confidence > MINIMUM_THRESHOLD
+          @result = {'encoding' =>  maxProber.get_charset_name(),
+            'confidence' =>  maxProber.get_confidence()}
+          return @result
+        end
+      end
+
+      if $debug
+        $stderr << "no probers hit minimum threshhold\n" if $debug
+        for prober in @charSetProbers[0].probers
+          next if !prober
+          $stderr << "#{prober.get_charset_name} confidence = #{prober.get_confidence}\n" if $debug
+        end
+      end
+    end
+  end
+end

data/lib/rchardet/utf8prober.rb

@@ -0,0 +1,87 @@
+######################## BEGIN LICENSE BLOCK ########################
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 1998
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#   Jeff Hodges - port to Ruby
+#   Mark Pilgrim - port to Python
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+# 
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+# 
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+module CharDet
+  ONE_CHAR_PROB = 0.5
+
+  class UTF8Prober < CharSetProber
+    def initialize
+      super()
+      @codingSM = CodingStateMachine.new(UTF8SMModel)
+      reset()
+    end
+
+    def reset
+      super()
+      @codingSM.reset()
+      @numOfMBChar = 0
+    end
+
+    def get_charset_name
+      return "utf-8"
+    end
+
+    def feed(aBuf)
+      aBuf.each_byte do |b|
+        c = b.chr
+        codingState = @codingSM.next_state(c)
+        if codingState == EError
+          @state = ENotMe
+          break
+        elsif codingState == EItsMe
+          @state = EFoundIt
+          break
+        elsif codingState == EStart
+          if @codingSM.get_current_charlen() >= 2
+            @numOfMBChar += 1
+          end
+        end
+      end
+
+      if get_state() == EDetecting
+        if get_confidence() > SHORTCUT_THRESHOLD
+          @state = EFoundIt
+        end
+      end
+
+      return get_state()
+    end
+
+    def get_confidence
+      unlike = 0.99
+      if @numOfMBChar < 6
+        for i in (0...@numOfMBChar)
+          unlike = unlike * ONE_CHAR_PROB
+        end
+        return 1.0 - unlike
+      else
+        return unlike
+      end
+    end
+  end
+end

data/lib/rchardet/version.rb

@@ -0,0 +1,3 @@
+module CharDet
+  VERSION = "1.8.0"
+end

data/lib/rchardet.rb

@@ -0,0 +1,67 @@
+######################## BEGIN LICENSE BLOCK ########################
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+# 
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+# 
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+# 02110-1301  USA
+######################### END LICENSE BLOCK #########################
+
+require 'rchardet/version'
+require 'rchardet/charsetprober'
+require 'rchardet/mbcharsetprober'
+
+require 'rchardet/big5freq'
+require 'rchardet/big5prober'
+require 'rchardet/chardistribution'
+require 'rchardet/charsetgroupprober'
+
+require 'rchardet/codingstatemachine'
+require 'rchardet/constants'
+require 'rchardet/escprober'
+require 'rchardet/escsm'
+require 'rchardet/eucjpprober'
+require 'rchardet/euckrfreq'
+require 'rchardet/euckrprober'
+require 'rchardet/euctwfreq'
+require 'rchardet/euctwprober'
+require 'rchardet/gb18030freq'
+require 'rchardet/gb18030prober'
+require 'rchardet/hebrewprober'
+require 'rchardet/jisfreq'
+require 'rchardet/jpcntx'
+require 'rchardet/langbulgarianmodel'
+require 'rchardet/langcyrillicmodel'
+require 'rchardet/langgreekmodel'
+require 'rchardet/langhebrewmodel'
+require 'rchardet/langhungarianmodel'
+require 'rchardet/langthaimodel'
+require 'rchardet/latin1prober'
+
+require 'rchardet/mbcsgroupprober'
+require 'rchardet/mbcssm'
+require 'rchardet/sbcharsetprober'
+require 'rchardet/sbcsgroupprober'
+require 'rchardet/sjisprober'
+require 'rchardet/universaldetector'
+require 'rchardet/utf8prober'
+
+module CharDet
+  def CharDet.detect(aBuf)
+    aBuf = aBuf.dup.force_encoding(Encoding::BINARY)
+
+    u = UniversalDetector.new
+    u.reset
+    u.feed(aBuf)
+    u.close
+    u.result
+  end
+end

data/lib/zip/central_directory.rb

@@ -0,0 +1,212 @@
+module Zip
+  class CentralDirectory
+    include Enumerable
+
+    END_OF_CDS             = 0x06054b50
+    ZIP64_END_OF_CDS       = 0x06064b50
+    ZIP64_EOCD_LOCATOR     = 0x07064b50
+    MAX_END_OF_CDS_SIZE    = 65_536 + 18
+    STATIC_EOCD_SIZE       = 22
+
+    attr_reader :comment
+
+    # Returns an Enumerable containing the entries.
+    def entries
+      @entry_set.entries
+    end
+
+    def initialize(entries = EntrySet.new, comment = '') #:nodoc:
+      super()
+      @entry_set = entries.kind_of?(EntrySet) ? entries : EntrySet.new(entries)
+      @comment   = comment
+    end
+
+    def write_to_stream(io) #:nodoc:
+      cdir_offset = io.tell
+      @entry_set.each { |entry| entry.write_c_dir_entry(io) }
+      eocd_offset = io.tell
+      cdir_size = eocd_offset - cdir_offset
+      if ::Zip.write_zip64_support
+        need_zip64_eocd = cdir_offset > 0xFFFFFFFF || cdir_size > 0xFFFFFFFF || @entry_set.size > 0xFFFF
+        need_zip64_eocd ||= @entry_set.any? { |entry| entry.extra['Zip64'] }
+        if need_zip64_eocd
+          write_64_e_o_c_d(io, cdir_offset, cdir_size)
+          write_64_eocd_locator(io, eocd_offset)
+        end
+      end
+      write_e_o_c_d(io, cdir_offset, cdir_size)
+    end
+
+    def write_e_o_c_d(io, offset, cdir_size) #:nodoc:
+      tmp = [
+        END_OF_CDS,
+        0, # @numberOfThisDisk
+        0, # @numberOfDiskWithStartOfCDir
+        @entry_set ? [@entry_set.size, 0xFFFF].min : 0,
+        @entry_set ? [@entry_set.size, 0xFFFF].min : 0,
+        [cdir_size, 0xFFFFFFFF].min,
+        [offset, 0xFFFFFFFF].min,
+        @comment ? @comment.bytesize : 0
+      ]
+      io << tmp.pack('VvvvvVVv')
+      io << @comment
+    end
+
+    private :write_e_o_c_d
+
+    def write_64_e_o_c_d(io, offset, cdir_size) #:nodoc:
+      tmp = [
+        ZIP64_END_OF_CDS,
+        44, # size of zip64 end of central directory record (excludes signature and field itself)
+        VERSION_MADE_BY,
+        VERSION_NEEDED_TO_EXTRACT_ZIP64,
+        0, # @numberOfThisDisk
+        0, # @numberOfDiskWithStartOfCDir
+        @entry_set ? @entry_set.size : 0, # number of entries on this disk
+        @entry_set ? @entry_set.size : 0, # number of entries total
+        cdir_size, # size of central directory
+        offset # offset of start of central directory in its disk
+      ]
+      io << tmp.pack('VQ<vvVVQ<Q<Q<Q<')
+    end
+
+    private :write_64_e_o_c_d
+
+    def write_64_eocd_locator(io, zip64_eocd_offset)
+      tmp = [
+        ZIP64_EOCD_LOCATOR,
+        0, # number of disk containing the start of zip64 eocd record
+        zip64_eocd_offset, # offset of the start of zip64 eocd record in its disk
+        1 # total number of disks
+      ]
+      io << tmp.pack('VVQ<V')
+    end
+
+    private :write_64_eocd_locator
+
+    def read_64_e_o_c_d(buf) #:nodoc:
+      buf                                           = get_64_e_o_c_d(buf)
+      @size_of_zip64_e_o_c_d                        = Entry.read_zip_64_long(buf)
+      @version_made_by                              = Entry.read_zip_short(buf)
+      @version_needed_for_extract                   = Entry.read_zip_short(buf)
+      @number_of_this_disk                          = Entry.read_zip_long(buf)
+      @number_of_disk_with_start_of_cdir            = Entry.read_zip_long(buf)
+      @total_number_of_entries_in_cdir_on_this_disk = Entry.read_zip_64_long(buf)
+      @size                                         = Entry.read_zip_64_long(buf)
+      @size_in_bytes                                = Entry.read_zip_64_long(buf)
+      @cdir_offset                                  = Entry.read_zip_64_long(buf)
+      @zip_64_extensible                            = buf.slice!(0, buf.bytesize)
+      raise Error, 'Zip consistency problem while reading eocd structure' unless buf.empty?
+    end
+
+    def read_e_o_c_d(buf) #:nodoc:
+      buf                                           = get_e_o_c_d(buf)
+      @number_of_this_disk                          = Entry.read_zip_short(buf)
+      @number_of_disk_with_start_of_cdir            = Entry.read_zip_short(buf)
+      @total_number_of_entries_in_cdir_on_this_disk = Entry.read_zip_short(buf)
+      @size                                         = Entry.read_zip_short(buf)
+      @size_in_bytes                                = Entry.read_zip_long(buf)
+      @cdir_offset                                  = Entry.read_zip_long(buf)
+      comment_length                                = Entry.read_zip_short(buf)
+      @comment                                      = if comment_length.to_i <= 0
+                                                        buf.slice!(0, buf.size)
+                                                      else
+                                                        buf.read(comment_length)
+                                                      end
+      raise Error, 'Zip consistency problem while reading eocd structure' unless buf.empty?
+    end
+
+    def read_central_directory_entries(io) #:nodoc:
+      begin
+        io.seek(@cdir_offset, IO::SEEK_SET)
+      rescue Errno::EINVAL
+        raise Error, 'Zip consistency problem while reading central directory entry'
+      end
+      @entry_set = EntrySet.new
+      @size.times do
+        @entry_set << Entry.read_c_dir_entry(io)
+      end
+    end
+
+    def read_from_stream(io) #:nodoc:
+      buf = start_buf(io)
+      if zip64_file?(buf)
+        read_64_e_o_c_d(buf)
+      else
+        read_e_o_c_d(buf)
+      end
+      read_central_directory_entries(io)
+    end
+
+    def get_e_o_c_d(buf) #:nodoc:
+      sig_index = buf.rindex([END_OF_CDS].pack('V'))
+      raise Error, 'Zip end of central directory signature not found' unless sig_index
+
+      buf = buf.slice!((sig_index + 4)..(buf.bytesize))
+
+      def buf.read(count)
+        slice!(0, count)
+      end
+
+      buf
+    end
+
+    def zip64_file?(buf)
+      buf.rindex([ZIP64_END_OF_CDS].pack('V')) && buf.rindex([ZIP64_EOCD_LOCATOR].pack('V'))
+    end
+
+    def start_buf(io)
+      begin
+        io.seek(-MAX_END_OF_CDS_SIZE, IO::SEEK_END)
+      rescue Errno::EINVAL
+        io.seek(0, IO::SEEK_SET)
+      end
+      io.read
+    end
+
+    def get_64_e_o_c_d(buf) #:nodoc:
+      zip_64_start = buf.rindex([ZIP64_END_OF_CDS].pack('V'))
+      raise Error, 'Zip64 end of central directory signature not found' unless zip_64_start
+
+      zip_64_locator = buf.rindex([ZIP64_EOCD_LOCATOR].pack('V'))
+      raise Error, 'Zip64 end of central directory signature locator not found' unless zip_64_locator
+
+      buf = buf.slice!((zip_64_start + 4)..zip_64_locator)
+
+      def buf.read(count)
+        slice!(0, count)
+      end
+
+      buf
+    end
+
+    # For iterating over the entries.
+    def each(&a_proc)
+      @entry_set.each(&a_proc)
+    end
+
+    # Returns the number of entries in the central directory (and
+    # consequently in the zip archive).
+    def size
+      @entry_set.size
+    end
+
+    def self.read_from_stream(io) #:nodoc:
+      cdir = new
+      cdir.read_from_stream(io)
+      cdir
+    rescue Error
+      nil
+    end
+
+    def ==(other) #:nodoc:
+      return false unless other.kind_of?(CentralDirectory)
+
+      @entry_set.entries.sort == other.entries.sort && comment == other.comment
+    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.