zstandard 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: be082988dab6b74aeeb9b9a22f5d3bc2a7c4e458
+  data.tar.gz: b85823b5c30374c5bbef7b5d3ff34db8d0bfad1b
+SHA512:
+  metadata.gz: 72bcd58d297a430824218ec3dacb656f11aaa118e53cc952aa1e575202e6e24fa253d1d831eec16733d0ced2521809fb39d7da76b83e1cc52728b1f85a7b0b11
+  data.tar.gz: 248e3858167a8e58e7baaf494803e54ff3a19f2e83a440db1b3027328546b82589eecd993b2717035ed3e64a682d62d3139cf0dc53f8862711e18067c668f4ce

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format documentation
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,16 @@
+sudo: false
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.10
+  - 2.2.6
+  - 2.3.3
+  - 2.4.1
+  - jruby-1.7.26
+  - jruby-9.1.7.0
+
+before_install:
+  - gem install bundler -v 1.13.6
+
+script: bundle && ./run_rspec_with_bundled_libraries.sh

data/.yardopts

@@ -0,0 +1 @@
+--markup=markdown

data/Gemfile

@@ -0,0 +1,31 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in zstandard.gemspec
+gemspec
+
+group :development do
+  gem "benchmark-ips"
+  gem "bundler"
+  gem "rake"
+  gem "ruby-progressbar", "~> 1.0"
+  gem "rspec", "~> 3.0"
+
+  if RUBY_ENGINE == "ruby"
+    gem "simplecov" if RUBY_VERSION >= "2.0.0"
+
+    if !ENV["CI"]
+      gem "pry"
+
+      if RUBY_VERSION < "2.0.0"
+        gem "pry-nav"
+      else
+        gem "pry-byebug"
+      end
+
+      # yard and friends
+      gem "redcarpet"
+      gem "github-markup"
+      gem "yard"
+    end
+  end
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Michael Sievers
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,179 @@
+# zstandard-ruby
+
+[![Build Status](https://travis-ci.org/msievers/zstandard-ruby.svg?branch=master)](https://travis-ci.org/msievers/zstandard-ruby)
+
+* [Installation](#installation)
+* [Usage](#usage)
+* [Advanced Usage](#advanced-usage)
+* [Configuration](#configuration)
+* [Docs](#docs)
+* [Examples for installing `libzstd`](#examples-for-installing-libzstd)
+* [Contributing](#contributing)
+* [License](#license)
+
+This gem implements FFI based bindings to the [Zstandard](https://facebook.github.io/zstd) compression library `libzstd`. The [Zstandard](https://facebook.github.io/zstd) compression algorithm shines because it compresses data with the same or better ratio as *Zlib* but does this (much) faster, depending on the input. For the majority of cases it's **faster and better** then *Zlib*.
+
+It **does not** ship the actual `libzstd` library but expects some version to be present on your system.
+
+## Installation
+
+Make sure you have `libzstd` installed on your system. In doubt, have a look at the [examples for installing `libzstd`](#examples-for-installing-libzstd).
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "zstandard"
+```
+
+And then execute:
+
+```
+bundle
+```
+
+Or install it yourself as:
+
+```
+gem install zstandard
+```
+
+## Usage
+
+The gem provides an API which aims compatibility the with `zlib` gem. There are two module methods
+* `deflate(string, level)`
+* `inflate(compressed_string)`
+
+The only difference between this and the `zlib` gem is the interpretation of the compression level. For `zlib`, this is a value between `1..9`, whereas for `Zstandard` it's between `1..22`.
+
+For most use cases, you should try to keep the compression level (very) low for `Zstandard`, because often compression time increases without significant better compression ratios. If in doubt, *do not specify* a compression level at all, which will use the default compression level.
+
+```ruby
+require "zstandard"
+
+compressed_string = Zstandard.deflate(string)
+decompressed_string = Zstandard.inflate(compressed_string)
+```
+
+## Advanced Usage
+
+*This is not intended to be used by regular users.*
+
+Besides the high level API which targets compatibility with the well known `zlib` gem there are two additional layers you can interact with. There is a low-level API which tries to cover differences between various `libzstd` version, e.g. different *frame header* formats. You should only use this if you know, what you are doing.
+
+```ruby
+require "zstandard"
+
+compressed_string = Zstandard::API.simple_compress(string)
+decompressed_string = Zstandard::API.simple_decompress(compressed_string)
+```
+
+The most low-level bindings are exposed via `Zstandard::FFIBindings`. If there is any reason for this, you can do the following.
+
+```ruby
+require "zstandard"
+
+zstd_library_version = Zstandard::FFIBindings.zstd_version_number
+```
+
+## Configuration
+
+This gem can be configured by setting various environment variables. Please be carefull if you decide to change/overwrite any of these. The default values are carefully choosen and there should be no need to alter one of these for regular use cases.
+
+### `ZSTANDARD_LIBRARY`
+
+If you have `libzstd` installed in some unusual location or if you want to explictly tell, which library to use, you can set `ZSTANDARD_LIBRARY` to the path of the library you want to use. This can be handy for example if you have the latest version compiled in `/usr/local/lib`, but your system has an old version in `/usr/lib`.
+
+```
+ZSTANDARD_LIBRARY=/usr/local/lib/libzstd.so bundle exec rake rspec
+```
+
+### `ZSTANDARD_MAX_SIMPLE_DECOMPRESS_SIZE`
+
+This specifies the maximum (decompressed) size of a string for which the simple decompression approach should be used. In order minimise memory consumption, if the expected decompressed size exceeds this limit, streaming decompression is used.
+
+### `ZSTANDARD_MAX_STREAMING_DECOMRPESS_BUFFER_SIZE`
+
+For streaming decompression, this specifies the size of the decompression bufffer.
+
+## Docs
+
+Yard generated docs can be found at [http://www.rubydoc.info/github/msievers/zstandard-ruby](http://www.rubydoc.info/github/msievers/zstandard-ruby).
+
+## Examples for installing `libzstd`
+
+* [Debian](#debian)
+* [Fedora](#fedora)
+* [FreeBSD](#freebsd)
+* [Mac](#mac)
+* [NetBSD](#netbsd)
+* [Ubuntu](#ubuntu)
+
+### Debian
+
+#### Jessie (8.x)
+
+The package is only included in `sid`, the unstable Debian version. There are guides describing how to install unstable packages into a stable Debian, for example at [Linuxaria](https://linuxaria.com/howto/how-to-install-a-single-package-from-debian-sid-or-debian-testing) or [serverfault.com](https://serverfault.com/questions/22414/how-can-i-run-debian-stable-but-install-some-packages-from-testing).
+
+```
+# run as root
+
+apt-get install zstd
+```
+
+### Fedora
+
+#### Fedora 23
+
+```
+sudo dnf install libzstd
+```
+
+### FreeBSD
+
+#### FreeBSD 10
+
+```
+# run as root
+
+portsnap fetch && portsnap extract
+
+cd /usr/ports/archivers/zstd
+make install
+```
+
+### Mac
+
+```
+brew install zstd
+```
+
+### NetBSD
+
+#### NetBSD 7
+
+```
+# run as root
+
+# the following assumes you are running a x86_64 system with NetBSD 7.0.x
+
+export PATH="/usr/pkg/sbin:$PATH"
+export PKG_PATH="ftp://ftp.netbsd.org/pub/pkgsrc/packages/NetBSD/x86_64/7.0_current/All/"
+
+pkg_add zstd
+```
+
+### Ubuntu
+
+#### Xenial Xerus (16.04) and above
+
+```
+sudo apt-get install zstd
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at [https://github.com/msievers/zstandard-ruby](https://github.com/msievers/zstandard-ruby).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,13 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+Dir.glob("benchmarks/*.rake").each do |file|
+  import file
+end
+
+desc "Run benchmarks"
+task :benchmark => ["benchmarks:deflate"]

data/lib/zstandard.rb

@@ -0,0 +1,23 @@
+require_relative "./zstandard/api"
+require_relative "./zstandard/config"
+require_relative "./zstandard/version"
+
+module Zstandard
+  class Error < ::StandardError; end;
+  class DecompressedSizeUnknownError < Error; end;
+  class LibraryVersionNotSupportedError < Error; end;
+
+  def self.deflate(string, level = nil)
+    API.simple_compress(string, level: level)
+  end
+
+  def self.inflate(string)
+    decompressed_size = API.decompressed_size(string)
+
+    if decompressed_size > 0 && decompressed_size <= Config::MAX_SIMPLE_DECOMPRESS_SIZE
+      API.simple_decompress(string)
+    else
+      API.streaming_decompress(string)
+    end
+  end
+end

data/lib/zstandard/api.rb

@@ -0,0 +1,123 @@
+require_relative "./config"
+require_relative "./ffi_bindings"
+
+module Zstandard
+  # Internal API layer to abstract different libzstd calling semantics/versions
+  module API
+    def self.streaming_decompress(string, options = {})
+      dst_size = window_size(string)
+
+      # The docs propose to check the dst size (windowSize), because it could be manipulated
+      raise "Invalid dst size!" if dst_size <= 0 || dst_size > Config::MAX_STREAMING_DECOMRPESS_BUFFER_SIZE
+
+      src = FFI::MemoryPointer.from_string(string) # we need the pointer for arithmetics
+      dst = FFI::MemoryPointer.new(:char, dst_size)
+
+      dst_offset = 0
+      src_offset = 0
+      result = []
+
+      dctx = FFIBindings.zstd_create_dctx
+      FFIBindings.zstd_decompress_begin(dctx)
+
+      while (src_size = FFIBindings.zstd_next_src_size_to_deompress(dctx)) != 0
+        nbytes = FFIBindings.zstd_decompress_continue(
+          dctx,
+          dst + dst_offset,
+          (dst + dst_offset).size,
+          src + src_offset,
+          src_size
+        )
+
+        if FFIBindings.zstd_is_error(error_code = nbytes) > 0
+          raise FFIBindings.zstd_get_error_name(error_code)
+        elsif nbytes > 0
+          result << (dst + dst_offset).read_bytes(nbytes)
+          dst_offset += nbytes
+          dst_offset = 0 if (dst + dst_offset).size == 0
+        end
+
+        src_offset += src_size
+      end
+
+      dst.free
+      src.free
+      FFIBindings.zstd_free_dctx(dctx)
+
+      result.join
+    end
+
+    #
+    # Tries to gather the size of the decompressed data.
+    #
+    # @param [String] string Compressed data
+    # @return [Integer] size of the decompressed data or 0
+    #
+    def self.decompressed_size(string)
+      if FFIBindings.zstd_version_number < 600
+        parameters = FFIBindings::ZSTD_parameters.new
+        FFIBindings.zstd_get_frame_params(parameters, string, string.bytesize)
+        parameters[:srcSize]
+      elsif FFIBindings.zstd_version_number < 10104
+        frame_params = FFIBindings::ZSTD_frameParams.new
+        FFIBindings.zstd_get_frame_params(frame_params, string, string.bytesize)
+        frame_params[:frameContentSize]
+      else
+        FFIBindings.zstd_find_decompressed_size(string, string.bytesize)
+      end
+    end
+
+    def self.simple_compress(string, options = {})
+      level = options[:level] || 0 # 0 means default
+
+      dst_size = FFIBindings.zstd_compress_bound(string.bytesize)
+      dst = FFI::MemoryPointer.new(:char, dst_size)
+
+      error_code = number_of_bytes = FFIBindings.zstd_compress(dst, dst_size, string, string.bytesize, level)
+
+      if FFIBindings.zstd_is_error(error_code) >= 0
+        dst.read_bytes(number_of_bytes)
+      else
+        raise "error"
+      end
+    end
+
+    def self.simple_decompress(string, options = {})
+      #
+      # The docs state, that one should be carefull when using the simple decompress API, because
+      # it relies on the upfront knowledge of the decompressed (dst) size. This information may
+      # by present within the frame header (or not). If it's present, it can be very large and/or
+      # intentionally modified, so it's vital to check that this value is within the systems limits
+      # and fallback to streaming decompression if unsure.
+      #
+      dst = FFI::MemoryPointer.new(:char, dst_size = API.decompressed_size(string))
+      error_code = number_of_bytes = FFIBindings.zstd_decompress(dst, dst_size, string, string.bytesize)
+
+      if FFIBindings.zstd_is_error(error_code) != 0
+        raise FFIBindings.zstd_get_error_name(error_code).read_string
+      else
+        dst.read_bytes(number_of_bytes)
+      end
+    end
+
+    def self.window_size(string)
+      if FFIBindings.zstd_version_number < 600
+        parameters = FFIBindings::ZSTD_parameters.new
+        FFIBindings.zstd_get_frame_params(parameters, string, string.bytesize)
+        2 ** parameters[:windowLog]
+      elsif FFIBindings.zstd_version_number < 700
+        frame_params = FFIBindings::ZSTD_frameParams.new
+        FFIBindings.zstd_get_frame_params(frame_params, string, string.bytesize)
+        2 ** frame_params[:windowLog]
+      elsif Zstandard::FFIBindings.zstd_version_number < 10300
+        frame_params = FFIBindings::ZSTD_frameParams.new
+        FFIBindings.zstd_get_frame_params(frame_params, string, string.bytesize)
+        frame_params[:windowSize]
+      else
+        frame_header = FFIBindings::ZSTD_frameHeader.new
+        FFIBindings.zstd_get_frame_header(frame_header, string, string.bytesize)
+        frame_header[:windowSize]
+      end
+    end
+  end
+end

data/lib/zstandard/config.rb

@@ -0,0 +1,24 @@
+module Zstandard
+  module Config
+    LIBRARY_PATH = ENV["ZSTANDARD_LIBRARY"] || "zstd"
+
+    # Threshold for switching to streaming decompression
+    MAX_SIMPLE_DECOMPRESS_SIZE =
+    begin
+      default = 1024 * 1024 * 32
+      env_param = ENV["ZSTANDARD_MAX_SIMPLE_DECOMPRESS_SIZE"].to_i
+      env_param > 0 ? env_param : default
+    end
+    .freeze
+
+    # Caps the window size of compressed data to prohibit abuse (e.g. by
+    # manipulated frame headers). The docs propose to support at least 8MB.
+    MAX_STREAMING_DECOMRPESS_BUFFER_SIZE =
+    begin
+      default = 1024 * 1024 * 8
+      env_param = ENV["ZSTANDARD_MAX_STREAMING_DECOMRPESS_BUFFER_SIZE"].to_i
+      env_param > 0 ? env_param : default
+    end
+    .freeze
+  end
+end

data/lib/zstandard/ffi_bindings.rb

@@ -0,0 +1,214 @@
+require "ffi"
+require_relative "./config"
+
+module Zstandard
+  module FFIBindings
+    extend FFI::Library
+    begin
+      ffi_lib Config::LIBRARY_PATH
+    rescue LoadError => e
+      STDERR.puts "Could not open #{Config::LIBRARY_PATH} shared library!"
+      STDERR.puts
+      STDERR.puts "Please be sure you have zstd installed. This can be accomplished via"
+      STDERR.puts "- your systems package management (e.g. apt-get install zstd)"
+      STDERR.puts "- compiled/installed by yourself (use ZSTANDARD_LIBRARY env variable for non-default paths)"
+      STDERR.puts
+      raise e
+    end
+
+    # this is placed upfront because it's needed for various conditionals
+    attach_function :zstd_version_number, :ZSTD_versionNumber, [], :uint
+
+    raise Zstandard::LibraryVersionNotSupportedError if zstd_version_number < 500
+
+    #
+    # @!group Simple API
+    #
+
+    # @!method self.zstd_compress(dst, dstCapacity, src, srcSize, compressionLevel)
+    #   @param [void*] dst
+    #   @param [size_t] dstCapacity
+    #   @param [const void*] src
+    #   @param [size_t] srcSize
+    #   @param [int] compressionLevel
+    #   @return [size_t] the compressed size
+    attach_function :zstd_compress, :ZSTD_compress, [:pointer, :size_t, :pointer, :size_t, :int], :size_t
+
+
+    # @!method self.zstd_compress_bound(srcSize)
+    #   @param [size_t] srcSize
+    #   @return [size_t]
+    attach_function :zstd_compress_bound, :ZSTD_compressBound, [:size_t], :size_t
+
+    # @!method self.zstd_decompress(dst, dstCapacity, src, compressedSize)
+    #   @param [void*] dst
+    #   @param [size_t] dstCapacity
+    #   @param [const void*] src
+    #   @param [size_t] compressedSize
+    #   @return [size_t] the decompressed size
+    attach_function :zstd_decompress, :ZSTD_decompress, [:pointer, :size_t, :pointer, :size_t], :size_t
+
+    #
+    # @!group Buffer-less streaming decompression
+    #
+
+    # @!method self.zstd_create_dctx
+    #   @return [ZSTD_DCtx*]
+    attach_function :zstd_create_dctx, :ZSTD_createDCtx, [], :pointer
+
+    # @!method self.zstd_decompress_begin(dctx)
+    #   @param [ZSTD_DCtx*] dctx
+    #   @return [size_t]
+    attach_function :zstd_decompress_begin, :ZSTD_decompressBegin, [:pointer], :size_t
+
+    # @!method self.zstd_decompress_continue(dctx, dst, dstCapacity, src, srcSize)
+    #   @param [ZSTD_DCtx*] dctx
+    #   @param [void*] dst
+    #   @param [size_t] dstCapacity
+    #   @param [const void*] src
+    #   @param [size_t] srcSize
+    #   @return [size_t]
+    attach_function :zstd_decompress_continue, :ZSTD_decompressContinue, [:pointer, :pointer, :size_t, :pointer, :size_t], :size_t
+
+    # @!method self.zstd_find_decompressed_size
+    #   @param [const void*] src
+    #   @param [size_t] srcSize
+    #   @return [unsigned long long]
+    if zstd_version_number >= 10104
+      attach_function :zstd_find_decompressed_size, :ZSTD_findDecompressedSize, [:pointer, :size_t], :uint64
+    end
+
+    # @!method self.zstd_free_dctx(dctx)
+    #   @param [ZSTD_DCtx*] dctx
+    #   @return [size_t]
+    attach_function :zstd_free_dctx, :ZSTD_freeDCtx, [:pointer], :size_t
+
+    # @!method self.zstd_get_frame_params(fparamsPtr, src, srcSize)
+    #   @param [ZSTD_parameters,ZSTD_frameParams] fparamsPtr (type depends on the version of `libzstd`, from `>= 0.6.0`, it's {ZSTD_frameParams}, before it's {ZSTD_parameters})
+    #   @param [const void*] src
+    #   @param [size_t] srcSize
+    #   @return [size_t]
+    # size_t ZSTD_getFrameParams(ZSTD_frameParams* fparamsPtr, const void* src, size_t srcSize)
+    if zstd_version_number < 10300
+      attach_function :zstd_get_frame_params, :ZSTD_getFrameParams, [:pointer, :pointer, :size_t], :size_t
+    else
+      attach_function :zstd_get_frame_header, :ZSTD_getFrameHeader, [:pointer, :pointer, :size_t], :size_t
+    end
+
+    # @!method zstd_next_src_size_to_deompress(dctx)
+    #   @param [ZSTD_DCtx*] dctx
+    #   @return [size_t]
+    attach_function :zstd_next_src_size_to_deompress, :ZSTD_nextSrcSizeToDecompress, [:pointer], :size_t
+
+    #
+    # @!group Helpers
+    #
+
+    # @!method zstd_get_error_name(code)
+    #   @param [size_t] code
+    #   @return [const char*]
+    attach_function :zstd_get_error_name, :ZSTD_getErrorName, [:size_t], :pointer
+
+    # @!method zstd_is_error(code)
+    #   @param [size_t] code
+    #   @return [unsigned] an integer indicating if this is an error code. A value > 0 indicates `true`.
+    # unsigned ZSTD_isError(size_t code)
+    attach_function :zstd_is_error, :ZSTD_isError, [:size_t], :uint
+
+    # @!method zstd_version_number
+    #   @return [uint]
+
+    # @!endgroup Helpers
+
+    #
+    # (Advanced) types (requires zstd_version_number to be attached for conditionals)
+    #
+    
+    if zstd_version_number < 600
+      enum :ZSTD_strategy, [:ZSTD_fast, :ZSTD_greedy, :ZSTD_lazy, :ZSTD_lazy2, :ZSTD_btlazy2]
+    elsif zstd_version_number < 800
+      enum :ZSTD_strategy, [:ZSTD_fast, :ZSTD_greedy, :ZSTD_lazy, :ZSTD_lazy2, :ZSTD_btlazy2, :ZSTD_btopt]
+    else
+      enum :ZSTD_strategy, [:ZSTD_fast, :ZSTD_dfast, :ZSTD_greedy, :ZSTD_lazy, :ZSTD_lazy2, :ZSTD_btlazy2, :ZSTD_btopt]
+    end
+
+    # The format of this struct depends on the version of `libzstd` you are using.
+    #
+    # `<= v0.6.x`
+    # ```
+    # typedef struct {
+    #   U64 frameContentSize;
+    #   U32 windowLog;
+    # } ZSTD_frameParams;
+    # ```
+    #
+    # `>= v0.7.x`
+    # ```
+    # typedef struct {
+    #   unsigned long long frameContentSize;
+    #   unsigned windowSize;
+    #   unsigned dictID;
+    #   unsigned checksumFlag;
+    # } ZSTD_frameParams;
+    # ```
+    if Zstandard::FFIBindings.zstd_version_number < 10300
+      class ZSTD_frameParams < FFI::Struct
+        # @!method [](member)
+        if Zstandard::FFIBindings.zstd_version_number < 700
+          # `<= v0.6.x`
+          # @overload [](member)
+          #   @param [:frameContentSize, :windowLog] member
+          layout(
+            frameContentSize: :uint64,
+            windowLog:        :uint32
+          )
+        elsif Zstandard::FFIBindings.zstd_version_number < 800
+          # `>= v0.7.x`
+          # @overload [](member)
+          #   @param [:frameContentSize, :windowSize, :dictID, :checksumFlag] member
+          layout(
+            :frameContentSize, :uint64,
+            :windowSize,       :uint32,
+            :dictID,           :uint32,
+            :checksumFlag,     :uint32
+          )
+        else
+          layout(
+            :frameContentSize, :ulong_long,
+            :windowSize,       :uint,
+            :dictID,           :uint,
+            :checksumFlag,     :uint
+          )
+        end
+      end
+    else
+      class ZSTD_frameHeader < FFI::Struct
+        layout(
+          :frameContentSize, :ulong_long,
+          :windowSize,       :uint,
+          :dictID,           :uint,
+          :checksumFlag,     :uint
+        )
+      end
+    end
+
+    class ZSTD_parameters < FFI::Struct
+      # @!method[](member)
+      if Zstandard::FFIBindings.zstd_version_number < 600
+        # `<= v0.5.x`
+        # @overload [](member)
+        #   @param [:srcSize, :windowLog, :contentLog, :hashLog, :searchLog, :searchLength, :targetLength, :strategy]
+        layout(
+          :srcSize,      :uint64,
+          :windowLog,    :uint32,
+          :contentLog,   :uint32,
+          :hashLog,      :uint32,
+          :searchLog,    :uint32,
+          :searchLength, :uint32,
+          :targetLength, :uint32,
+          :strategy,     :ZSTD_strategy
+        )
+      end
+    end
+  end
+end

data/lib/zstandard/version.rb

@@ -0,0 +1,3 @@
+module Zstandard
+  VERSION = "0.1.0"
+end

data/run_rspec_with_bundled_libraries.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+
+PROCESSOR_TYPE=$(uname -p)
+DISTRIBUTOR_ID=$(lsb_release -i -s|tr '[:upper:]' '[:lower:]')
+RELEASE=$(lsb_release -r -s)
+
+LIBRARIES_DIRECTORY="./spec/libzstd/${PROCESSOR_TYPE}/${DISTRIBUTOR_ID}/${RELEASE}"
+
+if [ -d "$LIBRARIES_DIRECTORY" ]; then
+  for library in ${LIBRARIES_DIRECTORY}/*
+  do
+    bundle exec rake ZSTANDARD_LIBRARY=$library
+    if [ "$?" -ne "0" ]; then
+      exit 1
+    fi
+  done
+else
+  echo "There are no bundled libraries for the current system."
+  exit 1
+fi

data/zstandard.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'zstandard/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "zstandard"
+  spec.version       = Zstandard::VERSION
+  spec.authors       = ["Michael Sievers"]
+  spec.email         = ["michael_sievers@web.de"]
+  spec.summary       = %q{Zstandard compression library bindings}
+  spec.homepage      = "https://github.com/msievers/zstandard"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features|bin|benchmarks|run_rspec_with_bundled_libraries.sh)/})
+  end
+
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "ffi", "~> 1.0"
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: zstandard
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Michael Sievers
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-07-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: 
+email:
+- michael_sievers@web.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- ".yardopts"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/zstandard.rb
+- lib/zstandard/api.rb
+- lib/zstandard/config.rb
+- lib/zstandard/ffi_bindings.rb
+- lib/zstandard/version.rb
+- run_rspec_with_bundled_libraries.sh
+- zstandard.gemspec
+homepage: https://github.com/msievers/zstandard
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: Zstandard compression library bindings
+test_files: []