seven_zip_ruby 1.0.0-x64-mingw32

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 333a9e5d4a3ba9d029a31097890385421b26ad6a
+  data.tar.gz: 88079675cb2082646fd404de167d8f81a4a02f28
+SHA512:
+  metadata.gz: 679357fdb1bd67992b018e59f2da39aec1fce0cab80de6415a67fa7b4d3a6d5dd57792e3825b9c9319e05b14478f1024046b90c56e0b831fde6ec5d0b35895b6
+  data.tar.gz: 3562b6fc59348f8a8ed4808c6ca37e9b1aa40aa62544188dc31ee7c59d4552242289bbd5304f4a2b2c6875f91f006fd7d1cdf9257833baa7e39237c495c4cd4d

data/.gitignore

@@ -0,0 +1,25 @@
+*.rbc
+*.o
+*.so
+*.bundle
+*.bak
+mkmf.log
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+XTAGS
+ext/seven_zip_ruby/Makefile
+ext/seven_zip_ruby/*.def
+ext/seven_zip_ruby/*.pdb
+ext/p7zip/makefile.machine

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+rvm:
+  - "2.0.0"
+cache:
+  - apt
+before_install:
+  - bundle install --path=vendor/bundle
+  - sudo apt-get install p7zip-full
+install: bundle exec rake build_local
+script: bundle exec rspec spec/seven_zip_ruby_spec.rb

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in seven_zip_ruby.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,39 @@
+Copyright (c) 2013 Masamitsu MURASE
+
+SevenZipRuby
+
+  The GNU LGPL + unRAR restriction means that you must follow both 
+  GNU LGPL rules and unRAR restriction rules.
+
+  GNU LGPL information
+  --------------------
+
+    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 can receive a copy of the GNU Lesser General Public License from 
+    http://www.gnu.org/
+
+
+  unRAR restriction
+  -----------------
+
+    The decompression engine for RAR archives was developed using source 
+    code of unRAR program.
+    All copyrights to original unRAR code are owned by Alexander Roshal.
+
+    The license for original unRAR code has the following restriction:
+
+      The unRAR sources cannot be used to re-create the RAR compression algorithm, 
+      which is proprietary. Distribution of modified unRAR sources in separate form 
+      or as a part of other software is permitted, provided that it is clearly
+      stated in the documentation and source comments that the code may
+      not be used to develop a RAR (WinRAR) compatible archiver.
+

data/README.md

@@ -0,0 +1,176 @@
+# SevenZipRuby ![Logo](https://raw.github.com/masamitsu-murase/seven_zip_ruby/master/resources/seven_zip_ruby_logo.png)
+
+[![Build Status](https://travis-ci.org/masamitsu-murase/seven_zip_ruby.png?branch=master)](https://travis-ci.org/masamitsu-murase/seven_zip_ruby)
+
+This is a Ruby gem library to handle [7-Zip](http://www.7-zip.org) archives.
+
+This extension calls the native library, 7z.dll or 7z.so, internally and it is included in this gem.
+
+## Features
+* Use official DLL, 7z.dll, internally.
+* Support extracting data into memory.
+
+## Examples
+
+**This is a beta version.**  
+The interfaces may be changed.
+
+If you have any comments about interface API, let me know please.
+
+### Extract archive
+```ruby
+File.open("filename.7z", "rb") do |file|
+  SevenZipRuby::Reader.open(file) do |szr|
+    szr.extract_all "path_to_dir"
+  end
+end
+```
+
+You can also use handy method.
+```ruby
+File.open("filename.7z", "rb") do |file|
+  SevenZipRuby::Reader.extract_all(file, "path_to_dir")
+end
+```
+
+### Show entries in archive
+```ruby
+File.open("filename.7z", "rb") do |file|
+  SevenZipRuby::Reader.open(file) do |szr|
+    list = szr.entries
+    p list
+    # => [ "#<EntryInfo: 0, dir, dir/subdir>", "#<EntryInfo: 1, file, dir/file.txt>", ... ]
+  end
+end
+```
+
+### Extract encrypted archive
+```ruby
+File.open("filename.7z", "rb") do |file|
+  SevenZipRuby::Reader.open(file, { password: "Password String" }) do |szr|
+    szr.extract_all "path_to_dir"
+  end
+end
+```
+or
+```ruby
+File.open("filename.7z", "rb") do |file|
+  SevenZipRuby::Reader.extract_all(file, "path_to_dir", { password: "Password String" })
+end
+```
+
+
+### Verify archive
+```ruby
+File.open("filename.7z", "rb") do |file|
+  SevenZipRuby::Reader.verify(file)
+  # => true/false
+end
+```
+
+### Compress files
+```ruby
+File.open("filename.7z", "wb") do |file|
+  SevenZipRuby::Writer.open(file) do |szr|
+    szr.add_directory("dir")
+  end
+end
+```
+or
+```ruby
+File.open("filename.7z", "wb") do |file|
+  SevenZipRuby::Writer.add_directory(file, "dir")
+end
+```
+
+## Supported platforms
+
+* Windows
+* Linux
+* Mac OSX
+
+## More examples
+
+### Extract partially
+
+Extract files whose size is less than 1024.
+
+```ruby
+File.open("filename.7z", "rb") do |file|
+  SevenZipRuby::Reader.open(file) do |szr|
+    small_files = szr.entries.select{ |i| i.file? && i.size < 1024 }
+    szr.extract(small_files, "path_to_dir")
+  end
+end
+```
+
+### Get data from archive
+
+Extract data into memory.
+
+```ruby
+data = nil
+File.open("filename.7z", "rb") do |file|
+  SevenZipRuby::Reader.open(file) do |szr|
+    smallest_file = szr.entries.select(&:file?).min_by(&:size)
+    data = szr.extract_data(smallest_file)
+  end
+end
+p data
+#  => File content is shown.
+
+### Create archive manually
+
+```
+File.open("filename.7z", "rb") do |file|
+  SevenZipRuby::Writer.open(file) do |szr|
+    szr.add_file "entry1.txt"
+    szr.mkdir "dir1"
+    szr.mkdir "dir2"
+
+    data = [0, 1, 2, 3, 4].pack("C*")
+    szr.add_data data, "entry2.txt"
+  end
+end
+```
+
+### Set compression mode
+
+7zip supports LZMA, LZMA2, PPMD, BZIP2, DEFLATE and COPY.  
+
+```ruby
+# random data
+data = 50000000.to_enum(:times).map{ rand(256) }.pack("C*")
+
+a = StringIO.new("")
+start = Time.now
+SevenZipRuby::Writer.open(a) do |szr|
+  szr.method = "BZIP2"     # Set compression method to "BZIP2"
+  szr.multi_thread = false # Disable multi-threading mode
+  szr.add_data(data, "test.bin")
+end
+p(Time.now - start)
+#  => 11.180934
+
+a = StringIO.new("")
+start = Time.now
+SevenZipRuby::Writer.open(a) do |szr|
+  szr.method = "BZIP2"     # Set compression method to "BZIP2"
+  szr.multi_thread = true  # Enable multi-threading mode (default)
+  szr.add_data(data, "test.bin")
+end
+p(Time.now - start)
+#  => 3.607563    # Faster than single-threaded compression.
+```
+
+
+## TODO
+
+* Support file attributes on Linux and Mac OSX.
+* Support updating archive.
+* Support extracting rar archive.
+
+
+## License
+LGPL and unRAR license. Please refer to LICENSE.txt.
+

data/Rakefile

@@ -0,0 +1,47 @@
+require "fileutils"
+require "bundler/gem_tasks"
+
+BINARY_FILES = [ "seven_zip_archive.so", "seven_zip_archive.bundle" ]
+MAKE = (ENV["MAKE"] || ENV["make"] || (RUBY_PLATFORM.include?("mswin") ? "nmake" : "make"))
+
+task :build_platform => [ :pre_platform, :build, :post_platform ]
+
+task :pre_platform do
+  FileUtils.mv("seven_zip_ruby.gemspec", "seven_zip_ruby.gemspec.bak")
+  FileUtils.cp("resources/seven_zip_ruby.gemspec.platform", "seven_zip_ruby.gemspec")
+end
+
+task :post_platform do
+  FileUtils.mv("seven_zip_ruby.gemspec.bak", "seven_zip_ruby.gemspec")
+end
+
+
+task :build_local_all => [ :build_local_clean, :build_local ]
+task :build_local => [ :build_binary, :copy_binary ]
+
+task :build_local_clean do
+  Dir.chdir "ext/seven_zip_ruby" do
+    sh("#{MAKE} clean") if (File.exist?("Makefile"))
+  end
+
+  [ "ext/seven_zip_ruby", "lib/seven_zip_ruby" ].each do |dir|
+    FileUtils.rmtree(BINARY_FILES.map{ |i| "#{dir}/#{i}" })
+  end
+end
+
+task :build_binary do
+  Dir.chdir "ext/seven_zip_ruby" do
+    FileUtils.rmtree BINARY_FILES
+    sh "ruby extconf.rb"
+    sh "#{MAKE}"
+  end
+end
+
+task :copy_binary do
+  BINARY_FILES.each do |file|
+    src = File.join("ext", "seven_zip_ruby", file)
+    dest = File.join("lib", "seven_zip_ruby", file)
+    FileUtils.rmtree(dest) if (File.exist?(dest))
+    FileUtils.cp(src, dest) if (File.exist?(src))
+  end
+end

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