seven_zip_ruby 1.1.0 → 1.2.0

data/ext/seven_zip_ruby/seven_zip_archive.h

@@ -25,7 +25,9 @@
 
 
 #include <ruby.h>
+#ifdef HAVE_RUBY_THREAD_H
 #include <ruby/thread.h>
+#endif
 
 #include <CPP/Common/MyCom.h>
 #include <CPP/Windows/PropVariant.h>
@@ -37,6 +39,21 @@
 #include "util_common.h"
 
 
+#ifdef NO_RB_THREAD_CALL_WITHOUT_GVL
+inline VALUE rb_thread_call_without_gvl(void *(*func)(void *data), void *data1,
+                                        rb_unblock_function_t *ubf, void *data2)
+{
+    typedef VALUE (*func_t)(void *);
+
+    return rb_thread_blocking_region((func_t)func, data1, ubf, data2);
+}
+#endif
+
+// For old compiler
+#ifdef NO_NULLPTR
+#define nullptr NULL
+#endif
+
 namespace SevenZip
 {
 
@@ -105,33 +122,29 @@ class ArchiveBase
   public:
     ArchiveBase();
     ~ArchiveBase();
+    void setSelf(VALUE self);
+    VALUE self();
     void rubyEventLoop();
     static VALUE staticRubyEventLoop(void *p);
-    bool runRubyAction(RubyAction action);
-    void finishRubyAction();
-    static void cancelAction(void *p);
-    void cancelAction();
+    template<typename T> bool runRubyAction(T t);
     static VALUE runProtectedRubyAction(VALUE p);
 
+  protected:
+    void mark();
+    void prepareAction();
+
     template<typename T>
       void runNativeFunc(T func);
     template<typename T, typename U>
       bool runNativeFuncProtect(T func, U cancel);
-    template<typename T>
-      static void *staticRunFunctor(void *p);
-    template<typename T>
-      static void staticRunFunctor2(void *p);
-    template<typename T>
-      static VALUE staticRunFunctorForProtect(VALUE p);
-
-  protected:
-    void mark();
-    void prepareAction();
 
   private:
     void startEventLoopThread();
     void terminateEventLoopThread();
+    void killEventLoopThread();
+    void finishRubyAction();
     bool runRubyActionImpl(RubyAction *action);
+    void cancelAction();
     virtual void setErrorState() = 0;
 
 
@@ -139,10 +152,11 @@ class ArchiveBase
     static RubyAction ACTION_END;
 
   private:
-    RubyActionTuple *m_action_tuple;
+    RubyActionTuple * volatile m_action_tuple;
     Mutex m_action_mutex;
     ConditionVariable m_action_cond_var;
-    bool m_event_loop_running;
+    volatile bool m_event_loop_running;
+    VALUE m_self;
 
   protected:
     RubyActionResult m_action_result;
@@ -151,65 +165,41 @@ class ArchiveBase
 template<typename T>
 void ArchiveBase::runNativeFunc(T func)
 {
-    void *(*functor)(void *);
-    functor = staticRunFunctor<T>;
-
     typedef std::function<void ()> func_type;
+
+    func_type functor = func;
+    func_type cancel = [&](){ cancelAction(); };
+
     func_type protected_func = [&](){
-        rb_thread_call_without_gvl(functor, reinterpret_cast<void*>(&func),
-                                   cancelAction, reinterpret_cast<void*>(this));
+        rb_thread_call_without_gvl(rubyCppUtilFunction1, reinterpret_cast<void*>(&functor),
+                                   rubyCppUtilFunction2, reinterpret_cast<void*>(&cancel));
     };
 
     int state = 0;
-    rb_protect(staticRunFunctorForProtect<func_type>, reinterpret_cast<VALUE>(&protected_func), &state);
+    rb_protect(rubyCppUtilFunctionForProtect, reinterpret_cast<VALUE>(&protected_func), &state);
     if (state){
-        throw RubyCppUtil::RubyException("Interrupted");
+        throw RubyCppUtil::RubyException(std::string("Interrupted"));
     }
 }
 
 template<typename T, typename U>
 bool ArchiveBase::runNativeFuncProtect(T func, U cancel)
 {
-    void *(*functor)(void *);
-    void (*functor2)(void *);
-    functor = staticRunFunctor<T>;
-    functor2 = staticRunFunctor2<U>;
-
     typedef std::function<void ()> func_type;
+
+    func_type functor1 = func;
+    func_type functor2 = cancel;
+
     func_type protected_func = [&](){
-        rb_thread_call_without_gvl(functor, reinterpret_cast<void*>(&func),
-                                   functor2, reinterpret_cast<void*>(&cancel));
+        rb_thread_call_without_gvl(rubyCppUtilFunction1, reinterpret_cast<void*>(&functor1),
+                                   rubyCppUtilFunction2, reinterpret_cast<void*>(&functor2));
     };
 
     int state = 0;
-    rb_protect(staticRunFunctorForProtect<func_type>, reinterpret_cast<VALUE>(&protected_func), &state);
+    rb_protect(rubyCppUtilFunctionForProtect, reinterpret_cast<VALUE>(&protected_func), &state);
     return (state == 0);
 }
 
-template<typename T>
-void *ArchiveBase::staticRunFunctor(void *p)
-{
-    T *t = reinterpret_cast<T*>(p);
-    (*t)();
-    return 0;
-}
-
-template<typename T>
-void ArchiveBase::staticRunFunctor2(void *p)
-{
-    T *t = reinterpret_cast<T*>(p);
-    (*t)();
-    return;
-}
-
-template<typename T>
-VALUE ArchiveBase::staticRunFunctorForProtect(VALUE p)
-{
-    T *t = reinterpret_cast<T*>(p);
-    (*t)();
-    return Qnil;
-}
-
 class ArchiveReader : public ArchiveBase
 {
   private:
@@ -487,6 +477,26 @@ class InStream : public IInStream, public CMyUnknownImp
     ArchiveBase *m_archive;
 };
 
+class FileInStream : public IInStream, public CMyUnknownImp
+{
+  public:
+    FileInStream(const std::string &filename, ArchiveBase *archive);
+    ~FileInStream();
+
+    MY_UNKNOWN_IMP1(IInStream)
+
+    STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
+    STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
+
+  private:
+    ArchiveBase *m_archive;
+#ifdef USE_WIN32_FILE_API
+    HANDLE m_file_handle;
+#else
+    std::ifstream m_file;
+#endif
+};
+
 
 class OutStream : public IOutStream, public CMyUnknownImp
 {
@@ -505,6 +515,23 @@ class OutStream : public IOutStream, public CMyUnknownImp
     ArchiveBase *m_archive;
 };
 
+// Not implemented yet.
+class FileOutStream : public IOutStream, public CMyUnknownImp
+{
+  public:
+    FileOutStream(const std::string &filename, ArchiveBase *archive);
+
+    MY_UNKNOWN_IMP1(IOutStream)
+
+    STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
+
+    STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
+    STDMETHOD(SetSize)(UInt64 size);
+
+  private:
+    const std::string m_filename;
+    ArchiveBase *m_archive;
+};
 
 
 ////////////////////////////////////////////////////////////////

data/ext/seven_zip_ruby/util_common.cpp

@@ -0,0 +1,28 @@
+
+#include <functional>
+
+#include "util_common.h"
+
+extern "C" VALUE rubyCppUtilFunctionForProtect(VALUE p)
+{
+    typedef std::function<void ()> func_type;
+    func_type *func = reinterpret_cast<func_type*>(p);
+    (*func)();
+    return Qnil;
+}
+
+extern "C" void *rubyCppUtilFunction1(void *p)
+{
+    typedef std::function<void ()> func_type;
+    func_type *func = reinterpret_cast<func_type*>(p);
+    (*func)();
+    return nullptr;
+}
+
+extern "C" void rubyCppUtilFunction2(void *p)
+{
+    typedef std::function<void ()> func_type;
+    func_type *func = reinterpret_cast<func_type*>(p);
+    (*func)();
+}
+

data/ext/seven_zip_ruby/util_common.h

@@ -4,13 +4,18 @@
 #include <algorithm>
 #include <functional>
 #include <utility>
+#include <string>
+#include <iostream>
 
 #include <ruby.h>
 
+extern "C" VALUE rubyCppUtilFunctionForProtect(VALUE p);
+extern "C" void *rubyCppUtilFunction1(void *p);
+extern "C" void rubyCppUtilFunction2(void *p);
+
 namespace RubyCppUtil
 {
 
-
 class RubyException
 {
   public:
@@ -34,6 +39,23 @@ class RubyException
 };
 
 
+template<typename T>
+void runRubyFunction(T func)
+{
+    std::function<void ()> function = func;
+    int state = 0;
+    rb_protect(rubyCppUtilFunctionForProtect, reinterpret_cast<VALUE>(&function), &state);
+
+    if (state){
+        VALUE exception = rb_gv_get("$!");
+        if (!NIL_P(exception)){
+            throw RubyException(exception);
+        }
+        throw RubyException(std::string("Unknown exception"));
+    }
+}
+
+
 template<typename T, VALUE (T::*func)()>
 VALUE wrappedFunction0(VALUE self)
 {
@@ -371,6 +393,7 @@ VALUE wrapInitialize(VALUE self)
     Data_Get_Struct(self, T, p);
     std::fill_n(reinterpret_cast<unsigned char*>(p), sizeof(T), ~INIT_MEMORY_VALUE);
     new(p) T();
+    p->setSelf(self);
 
     return Qnil;
 }
@@ -388,7 +411,7 @@ VALUE rb_define_wrapped_cpp_class(const char *name, VALUE super)
 
     VALUE cls = rb_define_class(name, super);
     rb_define_alloc_func(cls, alloc);
-    rb_define_method(cls, "initialize", RUBY_METHOD_FUNC(init), 0);
+    rb_define_private_method(cls, "initialize", RUBY_METHOD_FUNC(init), 0);
     return cls;
 }
 
@@ -404,7 +427,7 @@ VALUE rb_define_wrapped_cpp_class_under(VALUE outer, const char *name, VALUE sup
 
     VALUE cls = rb_define_class_under(outer, name, super);
     rb_define_alloc_func(cls, alloc);
-    rb_define_method(cls, "initialize", RUBY_METHOD_FUNC(init), 0);
+    rb_define_private_method(cls, "initialize", RUBY_METHOD_FUNC(init), 0);
     return cls;
 }
 

data/ext/seven_zip_ruby/utils.cpp

@@ -500,7 +500,6 @@ void ConvertTimeToFiletime(VALUE time, FILETIME *filetime)
 
 VALUE ConvertPropToValue(const PROPVARIANT &prop)
 {
-    VALUE ret;
     switch(prop.vt){
       case VT_EMPTY:
       case VT_NULL:

data/ext/seven_zip_ruby/win32/mutex.h

@@ -121,8 +121,8 @@ class ConditionVariable
   private:
     HANDLE m_signal_event;
     HANDLE m_broadcast_event;
-    unsigned int m_waiters_count;
     Mutex m_waiters_count_mutex;
+    unsigned int m_waiters_count;
 };
 
 }

data/lib/seven_zip_ruby.rb

@@ -1,16 +1,27 @@
 # -*- coding: utf-8 -*-
 
-require_relative("seven_zip_ruby/version")
+require("seven_zip_ruby/version")
 
-Dir.chdir("#{__dir__}/seven_zip_ruby"){ require_relative("seven_zip_ruby/seven_zip_archive") }
+external_lib = (RUBY_PLATFORM.downcase.match(/mswin|mingw/) ? "7z.dll" : "7z.so")
+dir = $:.find do |i|
+  next File.file?(File.join(i, "seven_zip_ruby", external_lib))
+end
+raise "Failed to find 7z.dll or 7z.so" unless (dir)
+
+Dir.chdir(File.join(dir, "seven_zip_ruby"))do
+  begin
+    version = RUBY_VERSION.match(/\d+\.\d+/)
+    require("seven_zip_ruby/#{version}/seven_zip_archive")
+  rescue LoadError
+    require("seven_zip_ruby/seven_zip_archive")
+  end
+end
 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")
+require("seven_zip_ruby/seven_zip_reader")
+require("seven_zip_ruby/seven_zip_writer")
+require("seven_zip_ruby/archive_info")
+require("seven_zip_ruby/update_info")
+require("seven_zip_ruby/entry_info")
+require("seven_zip_ruby/exception")
 
-module SevenZipRuby
-end

data/lib/seven_zip_ruby/entry_info.rb

@@ -4,11 +4,12 @@ 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
+        index, Pathname(path.to_s.force_encoding(Encoding::UTF_8)).cleanpath.to_s, 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
+    alias crc32 crc
 
     def directory?
       return @dir
@@ -38,7 +39,7 @@ module SevenZipRuby
       else
         type = "file"
       end
-      str = path.to_s.encode(Encoding::ASCII, invalid: :replace, undef: :replace, replace: "?")
+      str = path.encode(Encoding::ASCII, invalid: :replace, undef: :replace, replace: "?")
       return "#<EntryInfo: #{index}, #{type}, #{str}>"
     end
   end

data/lib/seven_zip_ruby/seven_zip_reader.rb

@@ -28,6 +28,11 @@ module SevenZipRuby
   #     end
   #   end
   #
+  #   # Extract archive 2
+  #   SevenZipRuby::Reader.open_file("filename.7z") do |szr|
+  #     szr.extract(:all, "path_to_dir")
+  #   end
+  #
   #   # Extract encrypted archive
   #   File.open("filename.7z", "rb") do |file|
   #     SevenZipRuby::Reader.open(file, password: "Password String") do |szr|
@@ -103,6 +108,40 @@ module SevenZipRuby
         end
       end
 
+
+      # Open 7zip archive to read.
+      #
+      # ==== Args
+      # +filename+ :: Filename of 7zip archive.
+      # +param+ :: Optional hash parameter. <tt>:password</tt> key represents password of this archive.
+      #
+      # ==== Examples
+      #   # Open archive
+      #   SevenZipRuby::SevenZipReader.open_file("filename.7z") do |szr|
+      #     # Read and extract archive.
+      #   end
+      #
+      #   # Open encrypted archive
+      #   SevenZipRuby::SevenZipReader.open_file("filename.7z", password: "PasswordOfArchive") do |szr|
+      #     # Read and extract archive.
+      #   end
+      #
+      #   # Open without block.
+      #   szr = SevenZipRuby::SevenZipReader.open_file("filename.7z")
+      #   # Read and extract archive.
+      #   szr.close
+      def open_file(filename, param = {}, &block)  # :yield: szr
+        szr = self.new
+        szr.open_file(filename, param)
+        if (block)
+          block.call(szr)
+          szr.close
+        else
+          szr
+        end
+      end
+
+
       # Open and extract 7zip archive.
       #
       # ==== Args
@@ -167,6 +206,8 @@ module SevenZipRuby
       end
     end
 
+    undef initialize_copy, clone, dup
+
     # Open 7zip archive.
     #
     # ==== Args
@@ -187,6 +228,31 @@ module SevenZipRuby
       return self
     end
 
+    # Open 7zip archive file.
+    #
+    # ==== Args
+    # +filename+ :: Filename of 7zip archive.
+    # +param+ :: Optional hash parameter. <tt>:password</tt> key represents password of this archive.
+    #
+    # ==== Examples
+    #   szr = SevenZipRuby::SevenZipReader.new
+    #   szr.open_file("filename.7z")
+    #   # ...
+    #   szr.close
+    def open_file(filename, param = {})
+      @stream = File.open(filename, "rb")
+      self.open(@stream, param)
+      return self
+    end
+
+    def close
+      close_impl
+      if (@stream)
+        @stream.close
+        @stream = nil
+      end
+    end
+
     # Verify 7zip archive.
     #
     # ==== Args
@@ -252,9 +318,11 @@ module SevenZipRuby
       when Symbol
         raise SevenZipError.new("Argument error") unless (index == :all)
         return extract_all(path)
-      when Array
+      when Enumerable
         index_list = index.map(&:to_i).sort.uniq
         extract_files_impl(index_list, file_proc(path))
+      when nil
+        raise ArgumentError.new("Invalid parameter index")
       else
         extract_impl(index.to_i, file_proc(path))
       end
@@ -328,7 +396,7 @@ module SevenZipRuby
         extract_all_impl(data_proc(ret, idx_prj))
         return ret
 
-      when Array
+      when Enumerable
         index_list = index.map(&:to_i)
         idx_prj = Hash[*(index_list.each_with_index.map{ |idx, i| [ idx, i ] }.flatten)]
 
@@ -336,6 +404,9 @@ module SevenZipRuby
         extract_files_impl(index_list, data_proc(ret, idx_prj))
         return ret
 
+      when nil
+        raise ArgumentError.new("Invalid parameter index")
+
       else
         index = index.to_i
         item = entry(index)
@@ -360,14 +431,15 @@ module SevenZipRuby
         case(type)
         when :stream
           ret = nil
+          arg_path = Pathname(arg.path)
           if (arg.anti?)
-            arg.path.rmtree if (arg.path.exist?)
+            arg_path.rmtree if (arg_path.exist?)
           elsif (arg.file?)
-            path = arg.path.expand_path(base_dir)
+            path = arg_path.expand_path(base_dir)
             path.parent.mkpath
             ret = File.open(path, "wb")
           else
-            path = arg.path.expand_path(base_dir)
+            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)
@@ -379,7 +451,7 @@ module SevenZipRuby
           raise InvalidArchive.new("Corrupted archive or invalid password") unless (arg[:success])
 
           unless (arg[:info].anti?)
-            path = arg[:info].path.expand_path(base_dir)
+            path = Pathname(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