zipping 0.2.3 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 70577713282f8648bbde02ed2cd685e278d7266c
-  data.tar.gz: 344ca0c1c1b95e31a5d8e7e0291762809b1fe05a
+  metadata.gz: 243995bc8d06cc56eb535cbca1b3ad5de5b61dbc
+  data.tar.gz: 5f563d079b0c7cbfbd0674f05c150e7ad330c7b1
 SHA512:
-  metadata.gz: dea1a7d86f095c275af8aa06a01ab7c586f3bd8db8df4a54d7fc64d485b88ce61b9a2de74ca557e5159e5b34bbc8d06a01ac42bc13b420a46fe3814509f1bd09
-  data.tar.gz: 72ffa3ecd714fbb0600dcf09c30bdfb81067271ac9e937c2ad0f4527c4d8c6c8688bd76a4b355ea8e8b6de5fc82ac6da0ed9aaf703a83b3543ffa8a9d202b91d
+  metadata.gz: 201505429f0c6572fe1b0dea7ee4e440598696bd73a537ba663fc73a28f5901597dfe38286697d452139822ebbde5571877707e73b1a474bebb29b08f2804907
+  data.tar.gz: 42df47b06e8e292857f030d58f397f8b623f0df7805d64d392f1020706761a422c8b7afd416b1fb678b6cdbfcd1011d72d610c5bce4eb70c0a10af68eb2ed8c0

data/README.md

@@ -1,6 +1,6 @@
 zipping
 =======
-[![Gem Version](https://badge.fury.io/rb/zipping.png)](http://badge.fury.io/rb/zipping)
+<a href="http://badge.fury.io/rb/zipping"><img src="https://badge.fury.io/rb/zipping@2x.png" alt="Gem Version" height="18"></a>
 
 This gem is for compressing files as a zip and outputting to a stream (or a stream-like interface object). The output to a stream proceeds little by little, as files are compressed.
 
@@ -65,4 +65,4 @@ Then, you get zip binary data in `zip_data`.
 
 ---
 
-Copyright (c) 2013 [Nekojarashi Inc.](http://www.nekojarashi.com)
+Copyright [Nekojarashi Inc.](http://www.nekojarashi.com)

data/lib/zipping/version.rb

@@ -1,3 +1,3 @@
 module Zipping
-  VERSION = "0.2.3"
+  VERSION = "0.2.5"
 end

data/lib/zipping.rb

@@ -1,6 +1,7 @@
 # -*- encoding: utf-8 -*-
 require "zipping/version"
 require 'zip'
+require 'pathname'
 
 module Zipping
 
@@ -9,21 +10,33 @@ module Zipping
   # Constants
   #
 
+  # header signatures
   ZS_c_pk0102        = 0x02014b50
   ZS_c_pk0304        = 0x04034b50
   ZS_c_pk0506        = 0x06054b50
   ZS_c_pk0708        = 0x08074b50
-  ZS_c_ver_dir       = 0x000a
-  ZS_c_ver_file      = 0x0014
+
+  # values for zip version
+  ZS_c_ver_nocomp    = 0x000a
+  ZS_c_ver_deflate   = 0x0014
   ZS_c_ver_made      = 0x0315
+
+  # values for option
   ZS_c_opt_none      = 0x0000
-  ZS_c_opt_nosize    = 0x0008
+  ZS_c_opt_0708      = 0x0008
+
+  # compression types
   ZS_c_comp_deflate  = 0x0008
+  ZS_c_comp_none     = 0x0000
+
+  # empty values
   ZS_c_int2_zero     = 0x0000
   ZS_c_int4_zero     = 0x00000000
 
+  # OS-specific attributes (OS X)
   ZS_c_oattr_dir     = 0x41ed4000
   ZS_c_oattr_file    = 0x81a44000
+  ZS_c_oattr_symlink = 0xa1ed4000
 
 
 
@@ -32,679 +45,424 @@ module Zipping
   #
 
   def self.files_to_zip(output_stream, files, file_division_size = 1048576, encoding = :utf8)
-    builder = ZipBuilder.new output_stream, files, file_division_size, encoding
-    builder.pack
+    builder = ZipBuilder.new output_stream, file_division_size, encoding
+    builder.pack files
+    builder.close
+    output_stream
+  end
+
+  # use if you need to make File directly.
+  def self.files_to_zipfile(path, files, encoding = :utf8)
+    File.open(path, 'wb'){|f| files_to_zip f, files, 1048576, encoding}
+  end
+
+  # use if you need to make binary String directly.
+  def self.files_to_zipdata(files, encoding = :utf8)
+    files_to_zip ''.force_encoding('ASCII-8bit'), files, 1048576, encoding
   end
 
 
+
   #
   # Internal Classes
   #
 
+  # Errors
+  class Error < StandardError
+  end
+
   # Output stream wrapper that measures size of stream passing through.
   class StreamMeter
     def initialize(output_stream)
       @output_stream = output_stream
       @size = 0
+      @crc = Zlib.crc32
     end
     def << (data)
       @size += data.length
+      @crc = Zlib.crc32 data, @crc
       @output_stream << data
     end
     attr_reader :size
+    attr_reader :crc
   end
 
   class ZipBuilder
 
     # Initialize ZipBuilder.
     # 'files' must be a String(file or directory path), a Hash(entity), or an Array of Strings and/or Hashes.
-    def initialize(output_stream, files, file_division_size = 1048576, encoding = :utf8)
-      @o = output_stream
-      @f = ZipBuilder.to_entities files
+    def initialize(output_stream, file_division_size = 1048576, encoding = :utf8)
+      @w = Writer.new output_stream, file_division_size
       @e = encoding
-      @s = file_division_size
+      @l = []
     end
 
-    # Create an Array of entity Hashes.
-    def self.to_entities(files)
-      if files.is_a? Hash
-        ret = [files]
-      elsif files.is_a? String
-        entity = ZipBuilder.to_entity(files)
-        ret = entity.nil? ? [] : [entity]
-      elsif files.is_a? Array
-        ret = []
-        files.each do |f|
-          entity = ZipBuilder.to_entity(f)
-          ret << entity unless entity.nil?
-        end
-      else
-        ret = []
-      end
-      ret
+    ### Attr controls
+
+    def reset_state
+      @pending_dirs = []
+      @current_dir = {name: '', time: Time.now}
     end
 
-    # Create an entity Hash with a path String
-    def self.to_entity(path)
-      return path if path.is_a?(Hash)
-      return nil unless path.is_a?(String) && File.exists?(path)
-      ret = {
-        :path => path,
-        :name => File.basename(path),
-        :time => Time.now
-      }
+    def has_dir?
+      ! @pending_dirs.empty?
     end
 
-    # Create ASCII-8bits string. Also convert encoding if needed.
-    def self.to_bytes(str, encoding = :utf8)
-      unless encoding.nil? || encoding == :utf8
-        case encoding
-        when :shift_jis
-          begin
-            str = str.encode 'Shift_JIS', :invalid => :replace, :undef => :replace, :replace => '??'
-          rescue => e
-          end
-        end
-      end
-      [str].pack('a*')
+    def next_dir
+      @pending_dirs.shift
     end
 
-    # Pack file and directory entities and output to stream.
-    def pack
-      return if @f.empty?
+    def postpone_dir(dir)
+      queue_entity dir, @pending_dirs
+    end
 
-      # directory entities found but not packed
-      @pending_dirs = []
+    def postpone_symlink(link)
+      queue_entity link, @l
+    end
+
+    def queue_entity(entity, queue)
+      entity[:abs_path] = abs_path_for entity[:name] || File.basename(entity[:path])
+      queue << entity
+    end
 
-      # current directory
-      @current_dir = ''
-      @current_dir_created_at = Time.now
+    def cd(dir)
+      @current_dir = dir
+    end
+
+    def root_dir?
+      @current_dir.nil? || @current_dir[:abs_path].nil?
+    end
+
+    def current_dir
+      root_dir? ? '' : @current_dir[:abs_path]
+    end
 
-      # data of positions necessary to create headers
-      @dp = []
+    def current_dir_entity
+      @current_dir
+    end
 
-      o = StreamMeter.new @o
+    def abs_path_for(name)
+      root_dir? ? name : (@current_dir[:abs_path] + '/' + name)
+    end
 
-      # pack file entities, store directory entities into @pending_dirs
-      pack_file_entities o
+    def abs_path_for_entity(entity)
+      abs_path_for entity[:name] || File.basename(entity[:path])
+    end
 
-      # retrieve and pack stored directories
-      until @pending_dirs.empty? do
+    ### Conversions
 
-        current_dir = @pending_dirs.shift
-        @current_dir = current_dir[:name] << '/'
-        @current_dir_created_at = current_dir[:time]
+    # Get entities of files in dir
+    def subdir_entities(dir = @current_dir)
+      Dir.glob(dir[:path] + '/*').map!{|path| {path: path, time: File.mtime(path), name: File.basename(path)}}
+    end
 
-        # write directory entry
-        pack_directory o, current_dir[:time]
+    # Fix an entity: time -> DOSTime object, name -> abs path in zip & encoded
+    def fix_entity(entity)
+      {
+        path: entity[:path],
+        filetime: Zip::DOSTime.at(entity[:time] || File.mtime(entity[:path])),
+        binary_name: string_to_bytes(abs_path_for_entity(entity)),
+        zip_path: abs_path_for_entity(entity)
+      }
+    end
 
-        begin
-          # get files in the directory
-          files = Dir.glob(current_dir[:path] + '/*')
+    def fix_current_dir_entity
+      fix_entity(@current_dir).merge!(
+        {
+          binary_name: string_to_bytes(@current_dir[:abs_path] + '/'),
+          zip_path: @current_dir[:abs_path]
+        }
+      )
+    end
 
-          # pack files, store directories as entities into @pending_dirs
-          pack_files o, files, current_dir
-        rescue => e
+    # Create ASCII-8bits string. Also convert encoding if needed.
+    def string_to_bytes(str)
+      unless @e.nil? || @e == :utf8
+        if @e == :shift_jis
+          begin
+            str = str.encode 'Shift_JIS', :invalid => :replace, :undef => :replace, :replace => '??'
+          rescue => e
+          end
         end
       end
+      [str].pack('a*')
+    end
 
-      # prepare to create headers
-      @header_offset = o.size
-      o = StreamMeter.new(@o)
+    ### Compression operations
 
-      # write headers
-      write_central_dir_headers o
-      @header_size = o.size
-      write_end_central_dir_header
+    # Pack file and directory entities and output to stream.
+    def pack(files)
+      entities = Entity.entities_from files
+      return if entities.empty?
+
+      reset_state
+      pack_entities entities
+      while has_dir?
+        cd next_dir
+        pack_current_dir
+      end
     end
 
-    # Pack file entities and output to stream. Directory entities are not packed but stored.
-    def pack_file_entities(o = @o, files = @f, dir = @current_dir, dirs = @pending_dirs, data_positions = @dp, encoding = @e, file_division_size = @s)
-      files.each do |file|
-        next unless file.is_a?(Hash) && file[:path]
+    # Pack a directory
+    def pack_current_dir
+      pack_current_directory_entity
+      pack_entities subdir_entities
+    end
 
-        f = file[:path]
-        if File.directory? f
-          dirs << file
-          next
-        end
-        next unless File.file? f
-        data_offset = o.size
-        file_path = f
-        fname = dir.clone << (file[:name] || File.basename(file_path))
-        bfname = ZipBuilder.to_bytes(fname, encoding)
-        filetime = Zip::DOSTime.at(file[:time] || File.mtime(file_path))
-        filesize = File.size(file_path)
-        pk = [
-          ZS_c_pk0304,
-          ZS_c_ver_file,
-          ZS_c_opt_nosize,
-          ZS_c_comp_deflate,
-          filetime.to_binary_dos_time,
-          filetime.to_binary_dos_date,
-          ZS_c_int4_zero,
-          ZS_c_int4_zero,
-          ZS_c_int4_zero,
-          bfname.length,
-          ZS_c_int2_zero
-        ]
-        bin = pk.pack('VvvvvvVVVvv')
-        o << bin
-        bin = bfname
-        o << bin
-
-        m = StreamMeter.new(o)
-        d = Zip::Deflater.new(m)
-        File.open(file_path) do |f|
-          cur_filesize = filesize
-          while cur_filesize > 0
-            if cur_filesize >= file_division_size
-              d << f.read(file_division_size)
-              cur_filesize -= file_division_size
-            else
-              d << f.read(cur_filesize)
-              cur_filesize = 0
-            end
-          end
+    # Pack symlinks if its link path exists in zip
+    def pack_symlinks
+      reset_state
+      @l.each do |link|
+        if @w.path_exists? Entity.linked_path(link[:abs_path], File.readlink(link[:path]))
+          link[:name] = link[:abs_path]
+          pack_symbolic_link_entity link
         end
-        d.finish
-
-        pk = [
-          ZS_c_pk0708,
-          d.crc,
-          m.size,
-          d.size
-        ]
-        bin = pk.pack('VVVV')
-        o << bin
-        data_positions << {
-          :folder => false,
-          :file => fname,
-          :file_dos_time => filetime.to_binary_dos_time,
-          :file_dos_date => filetime.to_binary_dos_date,
-          :binary_fname => bfname,
-          :offset => data_offset,
-          :crc => d.crc,
-          :complen => m.size,
-          :uncomplen => d.size
-        }
       end
     end
 
-    # Pack directory and output to stream.
-    def pack_directory(o = @o, time_created_at = @current_dir_created_at, dir = @current_dir, data_positions = @dp, encoding = @e)
-      bdir = ZipBuilder.to_bytes(dir, encoding)
-      data_offset = o.size
-      filetime = Zip::DOSTime.at(time_created_at);
-      filesize = 0
-      pk = [
-        ZS_c_pk0304,
-        ZS_c_ver_dir,
-        ZS_c_opt_none,
-        ZS_c_comp_deflate,
-        filetime.to_binary_dos_time,
-        filetime.to_binary_dos_date,
-        ZS_c_int4_zero,
-        ZS_c_int4_zero,
-        ZS_c_int4_zero,
-        bdir.length,
-        ZS_c_int2_zero
-      ]
-      bin = pk.pack('VvvvvvVVVvv')
-      o << bin
-      bin = bdir
-      o << bin
-      data_positions << {
-        :folder => true,
-        :file => dir,
-        :file_dos_time => filetime.to_binary_dos_time,
-        :file_dos_date => filetime.to_binary_dos_date,
-        :binary_fname => bdir,
-        :offset => data_offset,
-        :crc => ZS_c_int4_zero,
-        :complen => ZS_c_int4_zero,
-        :uncomplen => ZS_c_int4_zero
-      }
+    # Create central directories
+    def close
+      pack_symlinks
+      @w.close
     end
 
-    # Pack files and output to stream. Directories are not packed but stored.
-    def pack_files(o, files, dir, dirs = @pending_dirs, data_positions = @dp, encoding = @e, file_division_size = @s)
-      files.each do |f|
-        if File.directory? f
-          dirs << {
-            :path => f,
-            :name => dir[:name] + File.basename(f),
-            :time => dir[:time]
-          }
-          next
-        end
-        next unless File.file? f
-        data_offset = o.size
-        file_path = f
-        file = dir[:name] + File.basename(file_path)
-        bfile = ZipBuilder.to_bytes(file, encoding)
-        filetime = Zip::DOSTime.at(dir[:time] || File.mtime(file_path))
-        filesize = File.size(file_path)
-        pk = [
-          ZS_c_pk0304,
-          ZS_c_ver_file,
-          ZS_c_opt_nosize,
-          ZS_c_comp_deflate,
-          filetime.to_binary_dos_time,
-          filetime.to_binary_dos_date,
-          ZS_c_int4_zero,
-          ZS_c_int4_zero,
-          ZS_c_int4_zero,
-          bfile.length,
-          ZS_c_int2_zero
-        ]
-        bin = pk.pack('VvvvvvVVVvv')
-        o << bin
-        bin = bfile
-        o << bin
-
-        m = StreamMeter.new(o)
-        d = Zip::Deflater.new(m)
-        File.open(file_path) do |f|
-          cur_filesize = filesize
-          while cur_filesize > 0
-            if cur_filesize >= file_division_size
-              d << f.read(file_division_size)
-              cur_filesize -= file_division_size
-            else
-              d << f.read(cur_filesize)
-              cur_filesize = 0
-            end
-          end
+    # Pack file entities. Directory entities are queued, not packed in this method.
+    def pack_entities(entities)
+      entities.each do |entity|
+        # ignore bad entities
+        next unless entity.is_a?(Hash) && entity[:path]
+
+        path = entity[:path]
+        if File.symlink? path
+          postpone_symlink entity
+        elsif File.directory? path
+          postpone_dir entity
+        elsif File.file? path
+          pack_file_entity entity
         end
-        d.finish
-
-        pk = [
-          ZS_c_pk0708,
-          d.crc,
-          m.size,
-          d.size
-        ]
-        bin = pk.pack('VVVV')
-        o << bin
-        data_positions << {
-          :folder => false,
-          :file => file,
-          :file_dos_time => filetime.to_binary_dos_time,
-          :file_dos_date => filetime.to_binary_dos_date,
-          :binary_fname => bfile,
-          :offset => data_offset,
-          :crc => d.crc,
-          :complen => m.size,
-          :uncomplen => d.size
-        }
       end
     end
 
-    # Write central directories.
-    def write_central_dir_headers(o = @o, data_positions = @dp)
-      data_positions.each do |dp|
-        pk = [
-          ZS_c_pk0102,
-          ZS_c_ver_made,
-          (dp[:folder] ? ZS_c_ver_dir : ZS_c_ver_file),
-          ZS_c_opt_nosize,
-          ZS_c_comp_deflate,
-          dp[:file_dos_time],
-          dp[:file_dos_date],
-          dp[:crc],
-          dp[:complen],
-          dp[:uncomplen],
-          dp[:binary_fname].length,
-          ZS_c_int2_zero,
-          ZS_c_int2_zero,
-          ZS_c_int2_zero,
-          ZS_c_int2_zero,
-          (dp[:folder] ? ZS_c_oattr_dir : ZS_c_oattr_file),
-          dp[:offset]
-        ]
-        bin = pk.pack('VvvvvvvVVVvvvvvVV')
-        o << bin
-        bin = dp[:binary_fname]
-        o << bin
+    def pack_file_entity(entity)
+      pack_entity entity do
+        @w.write_file_entry
       end
     end
 
-    # Write end of central directory.
-    def write_end_central_dir_header(o = @o, entry_count = @dp.length, dirsize = @header_size, offset = @header_offset)
-      pk = [
-        ZS_c_pk0506,
-        ZS_c_int2_zero,
-        ZS_c_int2_zero,
-        entry_count,
-        entry_count,
-        dirsize,
-        offset,
-        ZS_c_int2_zero
-      ]
-      o << pk.pack('VvvvvVVv')
+    def pack_symbolic_link_entity(entity)
+      pack_entity entity do
+        @w.write_symbolic_link_entry
+      end
     end
-  end
 
+    def pack_current_directory_entity
+      @w.load_entity fix_current_dir_entity
+      @w.write_directory_entry
+    end
 
-  #
-  # Internal method
-  #
+    def pack_entity(entity)
+      @w.load_entity fix_entity entity
+      yield
+    end
+  end
 
-  # Pack files into zip.
-  # You must pass an entity Hash (or Array of them) consists of :path(path of file to pack into zip) and :name(file path inside zip) to this method as 'target_files'.
-  # Optionally, you may add :time(time created at) to the entity Hashes.
-  def self.create_zip_file_with_file_entities(outputStream, target_files, usesjis = true, file_division_size = 1048576)
-    begin
-
-      # prepare entry list for zip
-      target_files = [target_files] unless target_files.instance_of? Array
-      entries = []
-      target_files.each do |file|
-        if file.is_a? String
-          begin
-            entry = {
-              :path => file,
-              :name => File.basename(file),
-              :time => File.mtime(file)
-            }
-          rescue => e
-            next
-          end
-        elsif file.is_a? Hash
-          next unless file[:path] && file[:path].is_a?(String)
-          entry = file
-          path = entry[:path]
-          entry[:name] = File.basename(path) unless entry[:name] && entry[:name].is_a?(String)
-          entry[:time] = File.mtime(path) unless entry[:time] && entry[:time].is_a?(Time)
-        else
-          next
-        end
-        entries << entry
-      end
-      return if entries.empty?
+  class Writer
 
-      # prepare to measure stream size
-      o = StreamMeter.new(outputStream)
+    def initialize(output_stream, file_division_size)
+      @output_stream = output_stream
+      raise Error, 'Specified output stream does not support `<<\' method.' unless @output_stream.respond_to? :<<
+      @o = StreamMeter.new output_stream
+      @s = file_division_size
+      raise Error, 'Bad file_division_size' unless @s.is_a?(Integer) && @s > 0
+      @dps = []
+      @entries = []
+    end
 
-      # container to collect header info
-      data_positions = []
+    ### Data interface
 
-      # compress entries
-      self.compress_entries(o, entries, data_positions, usesjis, file_division_size)
+    def load_entity(entity)
+      @fixed_entity = entity
+      @entries << entity[:zip_path]
+    end
 
-      # measure stream size
-      pk0102_offset = o.size
+    def path_exists?(abs_path)
+      @entries.include? abs_path
+    end
 
-      # prepare to measure header size
-      m = StreamMeter.new(o)
+    ### Write operations
 
-      # write headers
-      self.create_central_dir_headers(m, data_positions)
+    def write_file_entry
+      write_entry do |path, filetime, name|
+        write PKHeader.pk0304(filetime, name.length, true).pack('VvvvvvVVVvv'), name
+        ret = deflate_file path
+        write PKHeader.pk0708(ret[:crc], ret[:complen], ret[:uncomplen]).pack('VVVV')
+        ret
+      end
+    end
 
-      # measure header size
-      pk0102_size = m.size
+    def write_directory_entry
+      write_entry_without_compress '', :dir
+    end
 
-      # write tail header
-      self.create_end_cent_dir_header(o, data_positions.length, pk0102_size, pk0102_offset)
-    rescue => e
+    def write_symbolic_link_entry
+      write_entry_without_compress File.readlink(@fixed_entity[:path]), :symlink
     end
-  end
 
-  # Pack files and folders into zip.
-  # All files in folders are also packed into zip, and the structure inside folders are conserved.
-  def self.create_zip_file_with_files_and_directories(outputStream, target_files, usesjis = true, file_division_size = 1048576)
-    begin
+    def close
+      # start of central directories
+      @header_offset = current_position
+      write_central_dir_headers
 
-      target_files = [target_files] unless target_files.instance_of? Array
-      return if target_files.empty?
+      # total size of central directories
+      @header_size = current_position - @header_offset
+      write_end_central_dir_header
+    end
 
-      dirs = []
-      o = StreamMeter.new(outputStream)
-      data_positions = []
+    ### Internal methods
+    private
+
+    def write(*args)
+      args.each do |content|
+        @o << content
+      end
+    end
 
-      self.compress_file_list(o, target_files, "", dirs, data_positions, usesjis, file_division_size)
+    def current_position
+      @o.size
+    end
 
-      while dirs.length > 0 do
-        current_directory = dirs.shift
-        dir_path = current_directory[0]
-        dir = current_directory[1]
-        dir << '/'
-        self.create_directory_entry(o, dir_path, dir, data_positions, usesjis, file_division_size)
+    def pipe_little_by_little(o, i)
+      o << i.read(@s) until i.eof?
+    end
 
-        files = Dir.glob(dir_path << '/*')
-        self.compress_file_list(o, files, dir, dirs, data_positions, usesjis, file_division_size)
+    def deflate_file(path)
+      meter = StreamMeter.new @o
+      deflater = Zip::Deflater.new meter
+      File.open(path, 'rb'){|f| pipe_little_by_little deflater, f}
+      deflater.finish
+      {
+        crc: deflater.crc,
+        complen: meter.size,
+        uncomplen: deflater.size,
+        deflated: true
+      }
+    end
 
+    def write_entry_without_compress(data, type)
+      write_entry do |path, filetime, name|
+        crc = Zlib.crc32 data
+        write PKHeader.pk0304(filetime, name.length, false, crc, data.size, data.size).pack('VvvvvvVVVvv'), name, data
+        {
+          type: type,
+          crc: crc,
+          complen: data.size,
+          uncomplen: data.size
+        }
       end
+    end
 
-      pk0102_offset = o.size
-      m = StreamMeter.new(o)
-      self.create_central_dir_headers(m, data_positions)
+    def write_entry
+      remember_entry_info current_position, yield(@fixed_entity[:path], @fixed_entity[:filetime], @fixed_entity[:binary_name])
+    end
 
-      self.create_end_cent_dir_header(o, data_positions.length, m.size, pk0102_offset)
-    rescue => e
+    def remember_entry_info(offset, write_result)
+      @dps << @fixed_entity.merge!(write_result).merge!({offset: offset})
     end
-  end
 
-  # Get file name as ASCII-8bits.
-  # If needed, also convert encoding.
-  def self.get_binary_fname(str, usesjis)
-    if usesjis
-      begin
-        str = str.encode 'Shift_JIS', :invalid => :replace, :replace => '??'
-      rescue => e
+    def write_central_dir_headers
+      @dps.each do |dp|
+        write PKHeader.pk0102(dp).pack('VvvvvvvVVVvvvvvVV'), dp[:binary_name]
       end
     end
-    return [str].pack('a*')
-  end
 
-  # Write directory entry.
-  #
-  def self.create_directory_entry(o, dir_path, dir, data_positions, usesjis = false, file_division_size = 1048576)
-    bdir = self.get_binary_fname(dir, usesjis)
-    data_offset = o.size
-    filetime = Zip::DOSTime.at(File.mtime(dir_path))
-    filesize = 0
-    pk = [
-      ZS_c_pk0304,
-      ZS_c_ver_dir,
-      ZS_c_opt_none,
-      ZS_c_comp_deflate,
-      filetime.to_binary_dos_time,
-      filetime.to_binary_dos_date,
-      ZS_c_int4_zero,
-      ZS_c_int4_zero,
-      ZS_c_int4_zero,
-      bdir.length,
-      ZS_c_int2_zero
-    ]
-    bin = pk.pack('VvvvvvVVVvv')
-    o << bin
-    bin = bdir
-    o << bin
-    data_positions << {
-      :folder => true,
-      :file => dir,
-      :file_dos_time => filetime.to_binary_dos_time,
-      :file_dos_date => filetime.to_binary_dos_date,
-      :binary_fname => bdir,
-      :offset => data_offset,
-      :crc => ZS_c_int4_zero,
-      :complen => ZS_c_int4_zero,
-      :uncomplen => ZS_c_int4_zero
-    }
+    def write_end_central_dir_header
+      write PKHeader.pk0506(@dps.length, @header_size, @header_offset).pack('VvvvvVVv')
+    end
   end
 
-  def self.compress_entries(o, entries, data_positions, usesjis = false, file_division_size = 1048576)
-    # `o' must be an output stream which has `size' method
-
-    entries.each do |entry|
-      path = entry[:path]
-      name = entry[:name]
-      mtime = entry[:time]
+  class Entity
+    def self.entities_from(files)
+      if files.is_a? Array
+        entities_from_array files
+      else
+        [entity_from(files)]
+      end
+    end
 
-      next if File.directory? path
-      next unless File.file? path
-      data_offset = o.size
-      b_name = self.get_binary_fname(name, usesjis)
-      filesize = File.size(path)
-      pk = [
-        ZS_c_pk0304,
-        ZS_c_ver_file,
-        ZS_c_opt_nosize,
-        ZS_c_comp_deflate,
-        mtime.to_binary_dos_time,
-        mtime.to_binary_dos_date,
-        ZS_c_int4_zero,
-        ZS_c_int4_zero,
-        ZS_c_int4_zero,
-        b_name.length,
-        ZS_c_int2_zero
-      ]
-      bin = pk.pack('VvvvvvVVVvv')
-      o << bin
-      bin = b_name
-      o << bin
-
-      m = StreamMeter.new(o)
-      d = Zip::Deflater.new(m)
-      File.open(path) do |f|
-        cur_filesize = filesize
-        while cur_filesize > 0
-          if cur_filesize >= file_division_size
-            d << f.read(file_division_size)
-            cur_filesize -= file_division_size
-          else
-            d << f.read(cur_filesize)
-            cur_filesize = 0
-          end
-        end
+    # Create an entity Hash with a path String
+    def self.entity_from(ent)
+      if ent.is_a?(Hash) && File.exists?(ent[:path])
+        ent
+      elsif ent.is_a?(String) && File.exists?(ent)
+        entity_from_path ent
       end
-      d.finish
+    end
 
-      pk = [
-        ZS_c_pk0708,
-        d.crc,
-        m.size,
-        d.size
-      ]
-      bin = pk.pack('VVVV')
-      o << bin
-      data_positions << {
-        :folder => false,
-        :file => name,
-        :file_dos_time => filetime.to_binary_dos_time,
-        :file_dos_date => filetime.to_binary_dos_date,
-        :binary_fname => b_name,
-        :offset => data_offset,
-        :crc => d.crc,
-        :complen => m.size,
-        :uncomplen => d.size
+    def self.entities_from_array(arr)
+      arr.map{|ent| entity_from ent}.delete_if(&:nil?)
+    end
+
+    def self.entity_from_path(path)
+      {
+        :path => path,
+        :name => File.basename(path),
+        :time => File.mtime(path)
       }
     end
 
+    def self.linked_path(abs_path, link)
+      (Pathname.new(abs_path).parent + link).expand_path('/').to_s[1..-1]
+    end
   end
 
-  def self.compress_file_list(o, files, dir, dirs, data_positions, usesjis = false, file_division_size = 1048576)
-    files.each do |f|
-      if File.directory? f
-        dirs << [f, dir.clone << File.basename(f)]
-        next
-      end
-      next unless File.file? f
-      data_offset = o.size
-      file_path = f
-      file = dir.clone << File.basename(file_path)
-      bfile = self.get_binary_fname(file, usesjis)
-      filetime = Zip::DOSTime.at(File.mtime(file_path))
-      filesize = File.size(file_path)
-      pk = [
+  module PKHeader
+    # 0102: central directory
+    def self.pk0102(dp)
+      # dp: info of an entry
+      [
+        ZS_c_pk0102,
+        ZS_c_ver_made,
+        (dp[:deflated] ? ZS_c_ver_nocomp : ZS_c_ver_deflate),
+        (dp[:deflated] ? ZS_c_opt_0708 : ZS_c_opt_none),
+        (dp[:deflated] ? ZS_c_comp_deflate : ZS_c_comp_none),
+        dp[:filetime].to_binary_dos_time,
+        dp[:filetime].to_binary_dos_date,
+        dp[:crc],
+        dp[:complen],
+        dp[:uncomplen],
+        dp[:binary_name].length,
+        ZS_c_int2_zero,
+        ZS_c_int2_zero,
+        ZS_c_int2_zero,
+        ZS_c_int2_zero,
+        (dp[:type] == :symlink ? ZS_c_oattr_symlink : dp[:type] == :dir ? ZS_c_oattr_dir : ZS_c_oattr_file),
+        dp[:offset]
+      ]
+    end
+
+    # 0304: header of entries
+    def self.pk0304(filetime, namelen, deflated, crc = nil, compsize = nil, uncompsize = nil)
+      [
         ZS_c_pk0304,
-        ZS_c_ver_file,
-        ZS_c_opt_nosize,
-        ZS_c_comp_deflate,
+        (deflated ? ZS_c_ver_deflate : ZS_c_ver_nocomp),
+        (deflated ? ZS_c_opt_0708 : ZS_c_opt_none),
+        (deflated ? ZS_c_comp_deflate : ZS_c_comp_none),
         filetime.to_binary_dos_time,
         filetime.to_binary_dos_date,
-        ZS_c_int4_zero,
-        ZS_c_int4_zero,
-        ZS_c_int4_zero,
-        bfile.length,
+        (crc || ZS_c_int4_zero),
+        (compsize || ZS_c_int4_zero),
+        (uncompsize || ZS_c_int4_zero),
+        namelen,
         ZS_c_int2_zero
       ]
-      bin = pk.pack('VvvvvvVVVvv')
-      o << bin
-      bin = bfile
-      o << bin
-
-      m = StreamMeter.new(o)
-      d = Zip::Deflater.new(m)
-      File.open(file_path) do |f|
-        cur_filesize = filesize
-        while cur_filesize > 0
-          if cur_filesize >= file_division_size
-            d << f.read(file_division_size)
-            cur_filesize -= file_division_size
-          else
-            d << f.read(cur_filesize)
-            cur_filesize = 0
-          end
-        end
-      end
-      d.finish
-
-      pk = [
-        ZS_c_pk0708,
-        d.crc,
-        m.size,
-        d.size
-      ]
-      bin = pk.pack('VVVV')
-      o << bin
-      data_positions << {
-        :folder => false,
-        :file => file,
-        :file_dos_time => filetime.to_binary_dos_time,
-        :file_dos_date => filetime.to_binary_dos_date,
-        :binary_fname => bfile,
-        :offset => data_offset,
-        :crc => d.crc,
-        :complen => m.size,
-        :uncomplen => d.size
-      }
     end
 
-  end
-
-  def self.create_central_dir_headers(o, data_positions)
-      data_positions.each do |dp|
-        pk = [
-          ZS_c_pk0102,
-          ZS_c_ver_made,
-          (dp[:folder] ? ZS_c_ver_dir : ZS_c_ver_file),
-          ZS_c_opt_nosize,
-          ZS_c_comp_deflate,
-          dp[:file_dos_time],
-          dp[:file_dos_date],
-          dp[:crc],
-          dp[:complen],
-          dp[:uncomplen],
-          dp[:binary_fname].length,
-          ZS_c_int2_zero,
-          ZS_c_int2_zero,
-          ZS_c_int2_zero,
-          ZS_c_int2_zero,
-          (dp[:folder] ? ZS_c_oattr_dir : ZS_c_oattr_file),
-          dp[:offset]
-        ]
-        bin = pk.pack('VvvvvvvVVVvvvvvVV')
-        o << bin
-        bin = dp[:binary_fname]
-        o << bin
-      end
-  end
-
-  def self.create_end_cent_dir_header(o, entry_count, dirsize, offset)
-      pk = [
+    # 0506: end of central directory
+    def self.pk0506(entry_count, dirsize, offset)
+      # entry_count: count of entries in zip
+      # dirsize: sum of central directory sizes
+      # offset: byte offset of the first central directory
+      [
         ZS_c_pk0506,
         ZS_c_int2_zero,
         ZS_c_int2_zero,
@@ -714,6 +472,19 @@ module Zipping
         offset,
         ZS_c_int2_zero
       ]
-      o << pk.pack('VvvvvVVv')
+    end
+
+    # 0708: optional trailer of entries
+    def self.pk0708(crc, compsize, uncompsize)
+      # crc: CRC32 for uncompressed data
+      # compsize: size of compressed data
+      # uncompsize: size of uncompressed data
+      [
+        ZS_c_pk0708,
+        crc,
+        compsize,
+        uncompsize
+      ]
+    end
   end
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zipping
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.5
 platform: ruby
 authors:
 - Shuntaro Shitasako
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-14 00:00:00.000000000 Z
+date: 2014-07-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -114,3 +114,4 @@ summary: Compress files as a zip and output it to a stream.
 test_files:
 - spec/spec_helper.rb
 - spec/zipping_spec.rb
+has_rdoc: