xxhash 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,7 @@
+source "http://rubygems.org"
+
+gemspec
+
+gem 'rake'
+gem 'rake-compiler'
+gem 'minitest', '~> 4.1'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Vasiliy Ermolovich
+
+MIT License
+
+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,31 @@
+## xxHash
+
+Ruby wrapper for [xxHash](http://code.google.com/p/xxhash/)
+
+### Install
+
+    gem install xxhash
+
+### Usage
+
+```ruby
+require 'xxhash'
+
+text = "test"
+seed = 12345
+
+XXhash.xxh32(text, seed) # => 3834992036
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+### Copyright
+
+Copyright (c) 2012 Vasiliy Ermolovich. See LICENSE.txt for
+further details.

data/Rakefile

@@ -0,0 +1,20 @@
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+require 'rake/clean'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = 'test/*_test.rb'
+  t.verbose = true
+end
+
+desc "Run tests"
+task :default => :test
+
+require 'rake/extensiontask'
+Rake::ExtensionTask.new('xxhash') do |ext|
+  ext.lib_dir = 'lib/xxhash'
+end
+
+Rake::Task[:test].prerequisites << :compile

data/ext/xxhash/extconf.rb

@@ -0,0 +1,8 @@
+require 'mkmf'
+
+%w{g O3 Wall}.each do |flag|
+  flag = "-#{flag}"
+  $CPPFLAGS += " #{flag}" unless $CPPFLAGS.split.include? flag
+end
+
+create_makefile('xxhash/xxhash')

data/ext/xxhash/libxxhash.c

@@ -0,0 +1,342 @@
+/*
+   xxHash - Fast Hash algorithm
+   Copyright (C) 2012, Yann Collet.
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+  You can contact the author at :
+  - xxHash source repository : http://code.google.com/p/xxhash/
+*/
+
+
+
+//**************************************
+// Tuning parameters
+//**************************************
+// FORCE_NATIVE_FORMAT :
+// By default, xxHash library provides endian-independant Hash values.
+// Results are therefore identical for big-endian and little-endian CPU.
+// This comes at a  performance cost for big-endian CPU, since some swapping is required to emulate little-endian format.
+// Should endian-independance be of no importance to your application, you may uncomment the #define below
+// It will improve speed for Big-endian CPU.
+// This option has no impact on Little_Endian CPU.
+//#define FORCE_NATIVE_FORMAT 1
+
+
+
+//**************************************
+// Includes
+//**************************************
+#include <stdlib.h>    // for malloc(), free()
+#include <string.h>    // for memcpy()
+#include "libxxhash.h"
+
+
+
+//**************************************
+// CPU Feature Detection
+//**************************************
+// Little Endian or Big Endian ?
+// You can overwrite the #define below if you know your architecture endianess
+#if defined(FORCE_NATIVE_FORMAT) && (FORCE_NATIVE_FORMAT==1)
+// Force native format. The result will be endian dependant.
+#  define XXH_BIG_ENDIAN 0
+#elif defined (__GLIBC__)
+#  include <endian.h>
+#  if (__BYTE_ORDER == __BIG_ENDIAN)
+#     define XXH_BIG_ENDIAN 1
+#  endif
+#elif (defined(__BIG_ENDIAN__) || defined(__BIG_ENDIAN) || defined(_BIG_ENDIAN)) && !(defined(__LITTLE_ENDIAN__) || defined(__LITTLE_ENDIAN) || defined(_LITTLE_ENDIAN))
+#  define XXH_BIG_ENDIAN 1
+#elif defined(__sparc) || defined(__sparc__) \
+   || defined(__ppc__) || defined(_POWER) || defined(__powerpc__) || defined(_ARCH_PPC) || defined(__PPC__) || defined(__PPC) || defined(PPC) || defined(__powerpc__) || defined(__powerpc) || defined(powerpc) \
+   || defined(__hpux)  || defined(__hppa) \
+   || defined(_MIPSEB) || defined(__s390__)
+#  define XXH_BIG_ENDIAN 1
+#endif
+
+#if !defined(XXH_BIG_ENDIAN)
+// Little Endian assumed. PDP Endian and other very rare endian format are unsupported.
+#  define XXH_BIG_ENDIAN 0
+#endif
+
+
+
+//**************************************
+// Compiler-specific Options & Functions
+//**************************************
+#define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
+
+// Note : under GCC, it may sometimes be faster to enable the (2nd) macro definition, instead of using win32 intrinsic
+#if defined(_WIN32)
+#  define XXH_rotl32(x,r) _rotl(x,r)
+#else
+#  define XXH_rotl32(x,r) ((x << r) | (x >> (32 - r)))
+#endif
+
+#if defined(_MSC_VER)     // Visual Studio
+#  define XXH_swap32 _byteswap_ulong
+#elif GCC_VERSION >= 403
+#  define XXH_swap32 __builtin_bswap32
+#else
+static inline unsigned int XXH_swap32 (unsigned int x) {
+                        return  ((x << 24) & 0xff000000 ) |
+                                ((x <<  8) & 0x00ff0000 ) |
+                                ((x >>  8) & 0x0000ff00 ) |
+                                ((x >> 24) & 0x000000ff );
+                 }
+#endif
+
+
+
+//**************************************
+// Constants
+//**************************************
+#define PRIME32_1   2654435761U
+#define PRIME32_2   2246822519U
+#define PRIME32_3   3266489917U
+#define PRIME32_4    668265263U
+#define PRIME32_5    374761393U
+
+
+
+//**************************************
+// Macros
+//**************************************
+#define XXH_LE32(p)  (XXH_BIG_ENDIAN ? XXH_swap32(*(unsigned int*)(p)) : *(unsigned int*)(p))
+
+
+
+//****************************
+// Simple Hash Functions
+//****************************
+
+unsigned int XXH32(const void* input, int len, unsigned int seed)
+{
+#if 0
+  // Simple version, good for code maintenance, but unfortunately slow for small inputs
+  void* state = XXH32_init(seed);
+  XXH32_feed(state, input, len);
+  return XXH32_result(state);
+#else
+
+  const unsigned char* p = (const unsigned char*)input;
+  const unsigned char* const bEnd = p + len;
+  unsigned int h32;
+
+  if (len>=16)
+  {
+    const unsigned char* const limit = bEnd - 16;
+    unsigned int v1 = seed + PRIME32_1 + PRIME32_2;
+    unsigned int v2 = seed + PRIME32_2;
+    unsigned int v3 = seed + 0;
+    unsigned int v4 = seed - PRIME32_1;
+
+    do
+    {
+      v1 += XXH_LE32(p) * PRIME32_2; v1 = XXH_rotl32(v1, 13); v1 *= PRIME32_1; p+=4;
+      v2 += XXH_LE32(p) * PRIME32_2; v2 = XXH_rotl32(v2, 13); v2 *= PRIME32_1; p+=4;
+      v3 += XXH_LE32(p) * PRIME32_2; v3 = XXH_rotl32(v3, 13); v3 *= PRIME32_1; p+=4;
+      v4 += XXH_LE32(p) * PRIME32_2; v4 = XXH_rotl32(v4, 13); v4 *= PRIME32_1; p+=4;
+    } while (p<=limit) ;
+
+    h32 = XXH_rotl32(v1, 1) + XXH_rotl32(v2, 7) + XXH_rotl32(v3, 12) + XXH_rotl32(v4, 18);
+  }
+  else
+  {
+    h32  = seed + PRIME32_5;
+  }
+
+  h32 += (unsigned int) len;
+
+  while (p<=bEnd-4)
+  {
+    h32 += XXH_LE32(p) * PRIME32_3;
+    h32 = XXH_rotl32(h32, 17) * PRIME32_4 ;
+    p+=4;
+  }
+
+  while (p<bEnd)
+  {
+    h32 += (*p) * PRIME32_5;
+    h32 = XXH_rotl32(h32, 11) * PRIME32_1 ;
+    p++;
+  }
+
+  h32 ^= h32 >> 15;
+  h32 *= PRIME32_2;
+  h32 ^= h32 >> 13;
+  h32 *= PRIME32_3;
+  h32 ^= h32 >> 16;
+
+  return h32;
+
+#endif
+}
+
+
+//****************************
+// Advanced Hash Functions
+//****************************
+
+struct XXH_state32_t
+{
+  unsigned int seed;
+  unsigned int v1;
+  unsigned int v2;
+  unsigned int v3;
+  unsigned int v4;
+  unsigned long long total_len;
+  char memory[16];
+  int memsize;
+};
+
+
+void* XXH32_init (unsigned int seed)
+{
+  struct XXH_state32_t * state = (struct XXH_state32_t *) malloc ( sizeof(struct XXH_state32_t));
+  state->seed = seed;
+  state->v1 = seed + PRIME32_1 + PRIME32_2;
+  state->v2 = seed + PRIME32_2;
+  state->v3 = seed + 0;
+  state->v4 = seed - PRIME32_1;
+  state->total_len = 0;
+  state->memsize = 0;
+
+  return (void*)state;
+}
+
+
+int   XXH32_feed (void* state_in, const void* input, int len)
+{
+  struct XXH_state32_t * state = state_in;
+  const unsigned char* p = (const unsigned char*)input;
+  const unsigned char* const bEnd = p + len;
+
+  state->total_len += len;
+
+  if (state->memsize + len < 16)   // fill in tmp buffer
+  {
+    memcpy(state->memory + state->memsize, input, len);
+    state->memsize +=  len;
+    return 0;
+  }
+
+  if (state->memsize)   // some data left from previous feed
+  {
+    memcpy(state->memory + state->memsize, input, 16-state->memsize);
+    {
+      const unsigned int* p32 = (const unsigned int*)state->memory;
+      state->v1 += XXH_LE32(p32) * PRIME32_2; state->v1 = XXH_rotl32(state->v1, 13); state->v1 *= PRIME32_1; p32++;
+      state->v2 += XXH_LE32(p32) * PRIME32_2; state->v2 = XXH_rotl32(state->v2, 13); state->v2 *= PRIME32_1; p32++;
+      state->v3 += XXH_LE32(p32) * PRIME32_2; state->v3 = XXH_rotl32(state->v3, 13); state->v3 *= PRIME32_1; p32++;
+      state->v4 += XXH_LE32(p32) * PRIME32_2; state->v4 = XXH_rotl32(state->v4, 13); state->v4 *= PRIME32_1; p32++;
+    }
+    p += 16-state->memsize;
+    state->memsize = 0;
+  }
+
+  {
+    const unsigned char* const limit = bEnd - 16;
+    unsigned int v1 = state->v1;
+    unsigned int v2 = state->v2;
+    unsigned int v3 = state->v3;
+    unsigned int v4 = state->v4;
+
+    while (p<=limit)
+    {
+      v1 += XXH_LE32(p) * PRIME32_2; v1 = XXH_rotl32(v1, 13); v1 *= PRIME32_1; p+=4;
+      v2 += XXH_LE32(p) * PRIME32_2; v2 = XXH_rotl32(v2, 13); v2 *= PRIME32_1; p+=4;
+      v3 += XXH_LE32(p) * PRIME32_2; v3 = XXH_rotl32(v3, 13); v3 *= PRIME32_1; p+=4;
+      v4 += XXH_LE32(p) * PRIME32_2; v4 = XXH_rotl32(v4, 13); v4 *= PRIME32_1; p+=4;
+    }
+
+    state->v1 = v1;
+    state->v2 = v2;
+    state->v3 = v3;
+    state->v4 = v4;
+  }
+
+  if (p < bEnd)
+  {
+    memcpy(state->memory, p, bEnd-p);
+    state->memsize = bEnd-p;
+  }
+
+  return 0;
+}
+
+
+unsigned int XXH32_getIntermediateResult (void* state_in)
+{
+  struct XXH_state32_t * state = state_in;
+  unsigned char * p   = (unsigned char*)state->memory;
+  unsigned char* bEnd = (unsigned char*)state->memory + state->memsize;
+  unsigned int h32;
+
+
+  if (state->total_len >= 16)
+  {
+    h32 = XXH_rotl32(state->v1, 1) + XXH_rotl32(state->v2, 7) + XXH_rotl32(state->v3, 12) + XXH_rotl32(state->v4, 18);
+  }
+  else
+  {
+    h32  = state->seed + PRIME32_5;
+  }
+
+  h32 += (unsigned int) state->total_len;
+
+  while (p<=bEnd-4)
+  {
+    h32 += XXH_LE32(p) * PRIME32_3;
+    h32 = XXH_rotl32(h32, 17) * PRIME32_4 ;
+    p+=4;
+  }
+
+  while (p<bEnd)
+  {
+    h32 += (*p) * PRIME32_5;
+    h32 = XXH_rotl32(h32, 11) * PRIME32_1 ;
+    p++;
+  }
+
+  h32 ^= h32 >> 15;
+  h32 *= PRIME32_2;
+  h32 ^= h32 >> 13;
+  h32 *= PRIME32_3;
+  h32 ^= h32 >> 16;
+
+  return h32;
+}
+
+
+unsigned int XXH32_result (void* state_in)
+{
+    unsigned int h32 = XXH32_getIntermediateResult(state_in);
+
+  free(state_in);
+
+  return h32;
+}

data/ext/xxhash/libxxhash.h

@@ -0,0 +1,128 @@
+/*
+   xxHash - Fast Hash algorithm
+   Header File
+   Copyright (C) 2012, Yann Collet.
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+  You can contact the author at :
+  - xxHash source repository : http://code.google.com/p/xxhash/
+*/
+
+/* Notice extracted from xxHash homepage :
+
+xxHash is an extremely fast Hash algorithm, running at RAM speed limits.
+It also successfully passes all tests from the SMHasher suite.
+
+Comparison (single thread, Windows Seven 32 bits, using SMHasher on a Core 2 Duo @3GHz)
+
+Name            Speed       Q.Score   Author
+xxHash          5.4 GB/s     10
+CrapWow         3.2 GB/s      2       Andrew
+MumurHash 3a    2.7 GB/s     10       Austin Appleby
+SpookyHash      2.0 GB/s     10       Bob Jenkins
+SBox            1.4 GB/s      9       Bret Mulvey
+Lookup3         1.2 GB/s      9       Bob Jenkins
+SuperFastHash   1.2 GB/s      1       Paul Hsieh
+CityHash64      1.05 GB/s    10       Pike & Alakuijala
+FNV             0.55 GB/s     5       Fowler, Noll, Vo
+CRC32           0.43 GB/s     9
+MD5-32          0.33 GB/s    10       Ronald L. Rivest
+SHA1-32         0.28 GB/s    10
+
+Q.Score is a measure of quality of the hash function.
+It depends on successfully passing SMHasher test set.
+10 is a perfect score.
+*/
+
+#pragma once
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+//****************************
+// Simple Hash Functions
+//****************************
+
+unsigned int XXH32 (const void* input, int len, unsigned int seed);
+
+/*
+XXH32() :
+  Calculate the 32-bits hash of "input", of length "len"
+  "seed" can be used to alter the result
+  This function successfully passes all SMHasher tests.
+  Speed on Core 2 Duo @ 3 GHz (single thread, SMHasher benchmark) : 5.4 GB/s
+  Note that "len" is type "int", which means it is limited to 2^31-1.
+  If your data is larger, use the advanced functions below.
+*/
+
+
+
+//****************************
+// Advanced Hash Functions
+//****************************
+
+void*        XXH32_init   (unsigned int seed);
+int          XXH32_feed   (void* state, const void* input, int len);
+unsigned int XXH32_result (void* state);
+
+/*
+These functions calculate the xxhash of an input provided in several small packets,
+as opposed to an input provided as a single block.
+
+You must start with :
+void* XXH32_init()
+The function returns a pointer which holds the state of calculation.
+
+This pointer must be provided as "void* state" parameter for XXH32_feed().
+XXH32_feed() can be called as many times as necessary.
+The function returns an error code, with 0 meaning OK, and all other values meaning there is an error.
+Note that "len" is type "int", which means it is limited to 2^31-1.
+If your data is larger, it is recommended
+to chunk your data into blocks of size 2^30 (1GB) to avoid any "int" overflow issue.
+
+Finally, you can end the calculation anytime, by using XXH32_result().
+This function returns the final 32-bits hash.
+You must provide the same "void* state" parameter created by XXH32_init().
+
+Memory will be freed by XXH32_result().
+*/
+
+
+unsigned int XXH32_getIntermediateResult (void* state);
+/*
+This function does the same as XXH32_result(), generating a 32-bit hash,
+but preserve memory context.
+This way, it becomes possible to generate intermediate hashes, and then continue feeding data with XXH32_feed().
+To free memory context, use XXH32_result().
+*/
+
+
+
+#if defined (__cplusplus)
+}
+#endif

data/ext/xxhash/xxhash.cc

@@ -0,0 +1,19 @@
+#include <ruby.h>
+#include "libxxhash.h"
+
+// Use this typedef to make the compiler happy when
+// calling rb_define_method()
+typedef VALUE (ruby_method)(...);
+
+extern "C" VALUE xxhash_xxh32(VALUE mod, VALUE input, VALUE seed)
+{
+  return ULL2NUM(XXH32(StringValuePtr(input), RSTRING_LEN(input), NUM2ULL(seed)));
+}
+
+extern "C" void Init_xxhash()
+{
+  VALUE mXXhash = rb_define_module("XXhash");
+  VALUE mInternal = rb_define_module_under(mXXhash, "Internal");
+
+  rb_define_singleton_method(mInternal, "xxh32", (ruby_method*) &xxhash_xxh32, 2);
+}

data/lib/xxhash.rb

@@ -0,0 +1,8 @@
+require 'xxhash/version'
+require 'xxhash/xxhash'
+
+module XXhash
+  def self.xxh32(input, seed)
+    Internal.xxh32(input, seed)
+  end
+end

data/lib/xxhash/version.rb

@@ -0,0 +1,3 @@
+module XXhash
+  VERSION = "0.0.1"
+end

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+require 'minitest/autorun'
+require 'minitest/spec'
+
+require 'xxhash'

data/test/xxhash_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+describe XXhash do
+  it 'returns hash' do
+    assert_equal 2758658570, XXhash.xxh32('test', 123)
+  end
+end

data/xxhash.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'xxhash/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "xxhash"
+  gem.version       = XXhash::VERSION
+  gem.authors       = ["Vasiliy Ermolovich"]
+  gem.email         = ["younash@gmail.com"]
+  gem.description   = %q{Ruby wrapper for xxHash lib}
+  gem.summary       = %q{Ruby wrapper for xxHash lib}
+  gem.homepage      = "http://github.com/nashby/xxhash"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+  gem.extensions    = ["ext/xxhash/extconf.rb"]
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: xxhash
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Vasiliy Ermolovich
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-23 00:00:00.000000000 Z
+dependencies: []
+description: Ruby wrapper for xxHash lib
+email:
+- younash@gmail.com
+executables: []
+extensions:
+- ext/xxhash/extconf.rb
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- ext/xxhash/extconf.rb
+- ext/xxhash/libxxhash.c
+- ext/xxhash/libxxhash.h
+- ext/xxhash/xxhash.cc
+- lib/xxhash.rb
+- lib/xxhash/version.rb
+- test/test_helper.rb
+- test/xxhash_test.rb
+- xxhash.gemspec
+homepage: http://github.com/nashby/xxhash
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -2742825382786216064
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -2742825382786216064
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Ruby wrapper for xxHash lib
+test_files:
+- test/test_helper.rb
+- test/xxhash_test.rb