seven_zip_ruby 1.0.0

data/ext/seven_zip_ruby/utils.h

@@ -0,0 +1,25 @@
+#ifndef UTILS_H__
+#define UTILS_H__
+
+#include <string>
+
+#ifdef _WIN32
+#include <winsock2.h>
+#include <windows.h>
+#include <oleauto.h>
+#else
+#include <windows.h>
+#endif
+
+#include <ruby.h>
+
+#include <CPP/Windows/PropVariant.h>
+
+VALUE ConvertBstrToString(const BSTR &bstr);
+BSTR ConvertStringToBstr(const std::string &str);
+BSTR ConvertStringToBstr(const char *str, int length);
+VALUE ConvertFiletimeToTime(const FILETIME &filetime);
+VALUE ConvertPropToValue(const PROPVARIANT &prop);
+void ConvertValueToProp(VALUE value, VARTYPE type, PROPVARIANT *prop);
+
+#endif

data/ext/seven_zip_ruby/win32/mutex.h

@@ -0,0 +1,130 @@
+#ifndef MUTEX_WIN32_H__
+#define MUTEX_WIN32_H__
+
+#include <winsock2.h>
+#include <windows.h>
+
+
+namespace SevenZip
+{
+
+class Mutex
+{
+  public:
+    Mutex(const char *name = "No Name")
+         : m_name(name)
+    {
+        InitializeCriticalSection(&m_mutex);
+    }
+
+    ~Mutex()
+    {
+        DeleteCriticalSection(&m_mutex);
+    }
+
+    void lock()
+    {
+        EnterCriticalSection(&m_mutex);
+    }
+
+    void unlock()
+    {
+        LeaveCriticalSection(&m_mutex);
+    }
+
+  private:
+    CRITICAL_SECTION m_mutex;
+    const char *m_name;
+};
+
+class MutexLocker
+{
+  public:
+    MutexLocker(Mutex *mutex)
+         : m_mutex(mutex)
+    {
+        m_mutex->lock();
+    }
+
+    ~MutexLocker()
+    {
+        m_mutex->unlock();
+    }
+
+  private:
+    Mutex *m_mutex;
+};
+
+class ConditionVariable
+{
+  public:
+    ConditionVariable()
+         : m_waiters_count_mutex("waiters_count"),
+           m_waiters_count(0)
+    {
+        m_signal_event = CreateEvent(NULL, FALSE, FALSE, NULL);
+        m_broadcast_event = CreateEvent(NULL, TRUE, FALSE, NULL);
+    }
+
+    ~ConditionVariable()
+    {
+        CloseHandle(m_signal_event);
+        CloseHandle(m_broadcast_event);
+    }
+
+    void wait(Mutex *mutex)
+    {
+        m_waiters_count_mutex.lock();
+        m_waiters_count++;
+        m_waiters_count_mutex.unlock();
+
+        mutex->unlock();
+
+        HANDLE events[] = { m_signal_event, m_broadcast_event };
+        DWORD ret = WaitForMultipleObjects (2, events, FALSE, INFINITE);
+
+        m_waiters_count_mutex.lock();
+        m_waiters_count--;
+        bool last = (ret == WAIT_OBJECT_0 + 1 && m_waiters_count == 0);
+        m_waiters_count_mutex.unlock();
+
+
+        if (last){
+            ResetEvent(m_broadcast_event);
+        }
+
+        mutex->lock();
+    }
+
+    void signal()
+    {
+        m_waiters_count_mutex.lock();
+        bool waiting = (m_waiters_count > 0);
+        m_waiters_count_mutex.unlock();
+
+        if (waiting){
+            SetEvent(m_signal_event);
+        }
+    }
+
+    void broadcast()
+    {
+        m_waiters_count_mutex.lock();
+        bool waiting = (m_waiters_count > 0);
+        m_waiters_count_mutex.unlock();
+
+        if (waiting){
+            SetEvent(m_broadcast_event);
+        }
+    }
+
+  private:
+    HANDLE m_signal_event;
+    HANDLE m_broadcast_event;
+    unsigned int m_waiters_count;
+    Mutex m_waiters_count_mutex;
+};
+
+}
+
+#endif

data/lib/seven_zip_ruby.rb

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+
+require_relative("seven_zip_ruby/version")
+
+Dir.chdir("#{__dir__}/seven_zip_ruby"){ require_relative("seven_zip_ruby/seven_zip_archive") }
+raise "Failed to initialize SevenZipRuby" unless (defined?(SevenZipRuby::SevenZipReader))
+
+require_relative("seven_zip_ruby/seven_zip_reader")
+require_relative("seven_zip_ruby/seven_zip_writer")
+require_relative("seven_zip_ruby/archive_info")
+require_relative("seven_zip_ruby/update_info")
+require_relative("seven_zip_ruby/entry_info")
+require_relative("seven_zip_ruby/exception")
+
+module SevenZipRuby
+end

data/lib/seven_zip_ruby/archive_info.rb

@@ -0,0 +1,21 @@
+module SevenZipRuby
+  class ArchiveInfo
+    def initialize(method, solid, num_blocks, header_size, phy_size)
+      @method, @solid, @num_blocks, @header_size, @phy_size =
+        method, solid, num_blocks, header_size, phy_size
+    end
+
+    attr_reader :method, :num_blocks, :header_size, :phy_size
+
+    alias size phy_size
+    alias block_num num_blocks
+
+    def solid?
+      return @solid
+    end
+
+    def inspect
+      "#<ArchiveInfo: #{method}, #{size}byte>"
+    end
+  end
+end

data/lib/seven_zip_ruby/entry_info.rb

@@ -0,0 +1,45 @@
+require("pathname")
+
+module SevenZipRuby
+  class EntryInfo
+    def initialize(index, path, method, dir, encrypted, anti, size, pack_size, ctime, atime, mtime, attrib, crc)
+      @index, @path, @method, @dir, @encrypted, @anti, @size, @pack_size, @ctime, @atime, @mtime, @attrib, @crc =
+        index, Pathname(path.to_s.force_encoding(Encoding::UTF_8)).cleanpath, method, dir, encrypted, anti, size, pack_size, ctime, atime, mtime, attrib, crc
+    end
+
+    attr_reader :index, :path, :method, :size, :pack_size, :ctime, :atime, :mtime, :attrib, :crc
+    alias to_i index
+
+    def directory?
+      return @dir
+    end
+
+    def file?
+      return !(@dir)
+    end
+
+    def encrypted?
+      return @encrypted
+    end
+
+    def anti?
+      return @anti
+    end
+
+    def has_data?
+      return !(@dir || @anti)
+    end
+
+    def inspect
+      if (@anti)
+        type = "anti"
+      elsif (@dir)
+        type = "dir"
+      else
+        type = "file"
+      end
+      str = path.to_s.encode(Encoding::ASCII, invalid: :replace, undef: :replace, replace: "?")
+      return "#<EntryInfo: #{index}, #{type}, #{str}>"
+    end
+  end
+end

data/lib/seven_zip_ruby/exception.rb

@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+
+module SevenZipRuby
+  class InvalidOperation < StandardError
+  end
+end
+

data/lib/seven_zip_ruby/seven_zip_reader.rb

@@ -0,0 +1,180 @@
+require("stringio")
+
+module SevenZipRuby
+  class SevenZipReader
+    class << self
+      def open(*args, &block)
+        szr = self.new
+        szr.open(*args)
+        if (block)
+          block.call(szr)
+          szr.close
+        else
+          szr
+        end
+      end
+
+      def extract(stream, index, dir = ".", param = {})
+        password = { password: param.delete(:password) }
+        self.open(stream, password) do |szr|
+          szr.extract(index, dir, param)
+        end
+      end
+
+      def extract_all(stream, dir = ".", param = {})
+        password = { password: param.delete(:password) }
+        self.open(stream, password) do |szr|
+          szr.extract_all(dir, param)
+        end
+      end
+
+      def verify(*args)
+        szr = self.open(*args)
+        ret = szr.verify
+        szr.close
+        return ret
+      end
+    end
+
+    def open(stream, param = {})
+      param[:password] = param[:password].to_s if (param[:password])
+      stream.set_encoding(Encoding::ASCII_8BIT)
+      open_impl(stream, param)
+      return self
+    end
+
+
+    def file_proc(base_dir)
+      base_dir = base_dir.to_s
+      return Proc.new do |type, arg|
+        case(type)
+        when :stream
+          ret = nil
+          if (arg.anti?)
+            arg.path.rmtree if (arg.path.exist?)
+          elsif (arg.file?)
+            path = arg.path.expand_path(base_dir)
+            path.parent.mkpath
+            ret = File.open(path, "wb")
+          else
+            path = arg.path.expand_path(base_dir)
+            path.mkpath
+            set_file_attribute(path.to_s, arg.attrib) if (arg.attrib)
+            path.utime(arg.atime || path.atime, arg.mtime || path.mtime)
+          end
+          next ret
+
+        when :result
+          arg[:stream].close
+          unless (arg[:info].anti?)
+            path = arg[:info].path.expand_path(base_dir)
+            set_file_attribute(path.to_s, arg[:info].attrib) if (arg[:info].attrib)
+            path.utime(arg[:info].atime || path.atime, arg[:info].mtime || path.mtime)
+          end
+        end
+      end
+    end
+    private :file_proc
+
+    def data_proc(output, idx_prj)
+      return Proc.new do |type, arg|
+        case(type)
+        when :stream
+          ret = (arg.has_data? ? StringIO.new("".b) : nil)
+          unless (arg.has_data?)
+            output[idx_prj[arg.index]] = nil
+          end
+          next ret
+
+        when :result
+          arg[:stream].close
+          if (arg[:info].has_data?)
+            output[idx_prj[arg[:info].index]] = arg[:stream].string
+          end
+
+        end
+      end
+    end
+    private :data_proc
+
+
+    def test
+      begin
+        return test_all_impl(nil)
+      rescue
+        return false
+      end
+    end
+    alias verify test
+
+    def verify_detail
+      begin
+        return test_all_impl(true)
+      rescue
+        return nil
+      end
+    end
+
+    def extract(index, dir = ".")
+      path = File.expand_path(dir)
+      case(index)
+      when Symbol
+        raise SevenZipError.new("Argument error") unless (index == :all)
+        return extract_all(path)
+      when Array
+        index_list = index.map(&:to_i).sort.uniq
+        extract_files_impl(index_list, file_proc(path))
+      else
+        extract_impl(index.to_i, file_proc(path))
+      end
+    end
+
+    def extract_all(dir = ".")
+      extract_all_impl(file_proc(File.expand_path(dir)))
+    end
+
+    def extract_if(dir = ".", &block)
+      extract(entries.select(&block).map(&:index), dir)
+    end
+
+    def extract_data(index)
+      case(index)
+      when :all
+        idx_prj = Object.new
+        def idx_prj.[](index)
+          return index
+        end
+
+        ret = []
+        extract_all_impl(data_proc(ret, idx_prj))
+        return ret
+
+      when Array
+        index_list = index.map(&:to_i)
+        idx_prj = Hash[*(index_list.each_with_index.map{ |idx, i| [ idx, i ] }.flatten)]
+
+        ret = []
+        extract_files_impl(index_list, data_proc(ret, idx_prj))
+        return ret
+
+      else
+        index = index.to_i
+        item = entry(index)
+        return nil unless (item.has_data?)
+
+        idx_prj = Object.new
+        def idx_prj.[](index)
+          return 0
+        end
+
+        ret = []
+        extract_impl(index, data_proc(ret, idx_prj))
+        return ret[0]
+
+      end
+    end
+  end
+
+
+  Reader = SevenZipReader
+end

data/lib/seven_zip_ruby/seven_zip_writer.rb

@@ -0,0 +1,143 @@
+require("stringio")
+
+module SevenZipRuby
+  class SevenZipWriter
+    PATH_ENCODING = Encoding::UTF_8
+
+    class << self
+      def open(stream, param = {}, &block)
+        szw = self.new
+        szw.open(stream, param)
+        if (block)
+          block.call(szw)
+          szw.compress
+          szw.close
+        else
+          szw
+        end
+      end
+
+      def add_directory(stream, dir, param = {})
+        password = { password: param.delete(:password) }
+        self.open(stream, password) do |szw|
+          szw.add_directory(dir, param)
+        end
+      end
+      alias add_dir add_directory
+
+      def add_file(stream, filename, param = {})
+        password = { password: param.delete(:password) }
+        self.open(stream, password) do |szw|
+          szw.add_file(filename, param)
+        end
+      end
+    end
+
+    def open(stream, param = {})
+      stream.set_encoding(Encoding::ASCII_8BIT)
+      open_impl(stream, param)
+      return self
+    end
+
+    def compress
+      compress_impl(compress_proc)
+      return self
+    end
+
+    def add_file(filename, opt={})
+      path = Pathname(filename)
+      check_option(opt, [ :as ])
+
+      if (opt[:as])
+        filename = Pathname(opt[:as]).cleanpath
+        raise ArgumentError.new(":as should contain valid pathname. #{opt[:as]}") if (filename.to_s.empty?)
+        raise ArgumentError.new(":as should be relative. #{opt[:as]}") if (filename.absolute?)
+      else
+        raise ArgumentError.new("filename should be relative. #{filename}") if (path.absolute?)
+        filename = path.cleanpath
+      end
+      add_item(UpdateInfo.file(filename.to_s.encode(PATH_ENCODING), path, self))
+      return self
+    end
+
+    def add_data(data, filename, opt={})
+      path = Pathname(filename)
+      raise ArgumentError.new("filename should be relative") if (path.absolute?)
+      check_option(opt, [ :ctime, :atime, :mtime ])
+
+      name = path.cleanpath.to_s.encode(PATH_ENCODING)
+      add_item(UpdateInfo.buffer(name, data, opt))
+      return self
+    end
+
+    def add_directory(directory, opt={})
+      directory = Pathname(directory).cleanpath
+      check_option(opt, [ :as ])
+
+      if (opt[:as])
+        base_dir = Pathname(opt[:as]).cleanpath
+        raise ArgumentError.new(":as should contain valid pathname. #{opt[:as]}") if (base_dir.to_s.empty?)
+        raise ArgumentError.new(":as should be relative. #{opt[:as]}") if (base_dir.absolute?)
+
+        mkdir(base_dir, { ctime: directory.ctime, atime: directory.atime, mtime: directory.mtime })
+      else
+        raise ArgumentError.new("directory should be relative #{directory}") if (directory.absolute?)
+
+        mkdir(directory, { ctime: directory.ctime, atime: directory.atime, mtime: directory.mtime })
+      end
+
+      Pathname.glob(directory.join("**", "*").to_s) do |entry|
+        name = (base_dir + entry.relative_path_from(directory)).cleanpath if (base_dir)
+
+        if (entry.file?)
+          add_file(entry, as: name)
+        elsif (entry.directory?)
+          mkdir(name || entry, { ctime: entry.ctime, atime: entry.atime, mtime: entry.mtime })
+        else
+          raise "#{entry} is invalid entry"
+        end
+      end
+
+      return self
+    end
+    alias add_dir add_directory
+
+    def mkdir(directory_name, opt={})
+      path = Pathname(directory_name)
+      raise ArgumentError.new("directory_name should be relative") if (path.absolute?)
+      check_option(opt, [ :ctime, :atime, :mtime ])
+
+      name = path.cleanpath.to_s.encode(PATH_ENCODING)
+      add_item(UpdateInfo.dir(name, opt))
+      return self
+    end
+
+
+    def check_option(opt, keys)
+      invalid_keys = opt.keys - keys
+      raise ArgumentError.new("invalid option: " + invalid_keys.join(", ")) unless (invalid_keys.empty?)
+    end
+
+
+    def compress_proc
+      return Proc.new do |type, info|
+        case(type)
+        when :stream
+          if (info.buffer?)
+            next StringIO.new(info.data)
+          elsif (info.file?)
+            next File.open(info.data, "rb")
+          else
+            next nil
+          end
+        when :result
+          info[:stream].close if (info[:stream])
+        end
+      end
+    end
+    private :compress_proc
+  end
+
+
+  Writer = SevenZipWriter
+end