splitclient-rb 7.1.4.pre.rc7 → 7.1.4.pre.rc8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7988ad06773770ae355071643b598c07edb6f6d3f70ba2b4ff329f58ef4a99a6
-  data.tar.gz: 2af55b4ae571122cae8fae6fed3ee8bd834b9ef14d7507af58f2ed2bb1148e9d
+  metadata.gz: 43f9703a389acb58ca8982fc62bfc39853a4cb9db03ff25ce479db5353d1cd1e
+  data.tar.gz: 109946a00efbde7b119f92e7c0d6807f9816a97ed41388c3421a5cc3b94c707d
 SHA512:
-  metadata.gz: 2c0ee137065995544630335c58257dada744258b28fb7f66fb1893b576e11ebf679b3c723131f68cb52fb63daa0910aa136971bfca95636bf3c06e970ef593fe
-  data.tar.gz: c4036dd6060961ed7dea153a9d5e25eb791f181d02dde5326f6eac463a3e99ab13f2b5ac99108dd29f15c479969a8bc585186d84f141a7593229c298093916cb
+  metadata.gz: 6bad0bdc17f8dfd9160c2e295bac71799ccf8adadcf15261be27b2a07e30882bce4939cf7864d14edcf8937462b2d39dd03a0cb6c0e12169108ed25dcaa9711b
+  data.tar.gz: 831c75840e0a61ab8b32db9d403fe66aaa730ccb672f5021761f881cbac0da7ccfc6b62894ff2ca70da97ff6ddf7fa9b628693eca566cc50e8ef3e19b458d03e

data/CHANGES.txt

@@ -1,7 +1,7 @@
 CHANGES
 
 7.1.3 (Jul 31, 2020)
-- Updated rake development dependency to ~> 12.3.3
+- Updated rake development dependency to ~> 12.3.3.
 
 7.1.2 (Jun 15, 2020)
 - Fixed uninitialized constant LocalhostSplitStore::YAML for console apps.

data/Rakefile

@@ -11,14 +11,19 @@ RSpec::Core::RakeTask.new(:spec)
 RuboCop::RakeTask.new(:rubocop)
 
 task spec: :compile
-
-if RUBY_PLATFORM == 'java'
+case RUBY_PLATFORM
+when 'java'
   require 'rake/javaextensiontask'
   Rake::JavaExtensionTask.new 'murmurhash' do |ext|
     ext.lib_dir = 'lib/murmurhash'
     ext.target_version = '1.7'
     ext.source_version = '1.7'
   end
+else
+  require 'rake/extensiontask'
+  Rake::ExtensionTask.new 'murmurhash' do |ext|
+    ext.lib_dir = 'lib/murmurhash'
+  end
 end
 
 if !ENV['APPRAISAL_INITIALIZED']

data/ext/murmurhash/3_x64_128.c

@@ -0,0 +1,117 @@
+/*
+ * MurmurHash3_x64_128 (C) Austin Appleby
+ */
+
+#include "murmurhash.h"
+
+void
+murmur_hash_process3_x64_128(const char * key, uint32_t len, uint32_t seed, void *out)
+{
+  const uint8_t * data = (const uint8_t*)key;
+  const int nblocks = len / 16;
+
+  uint64_t h1 = seed;
+  uint64_t h2 = seed;
+
+  const uint64_t c1 = (uint64_t)BIG_CONSTANT(0x87c37b91114253d5);
+  const uint64_t c2 = (uint64_t)BIG_CONSTANT(0x4cf5ad432745937f);
+
+  //----------
+  // body
+
+  const uint64_t * blocks = (const uint64_t *)(data);
+
+  int i;
+
+  for(i = 0; i < nblocks; i++)
+  {
+    uint64_t k1 = getblock64(blocks,i*2+0);
+    uint64_t k2 = getblock64(blocks,i*2+1);
+
+    k1 *= c1; k1  = ROTL64(k1,31); k1 *= c2; h1 ^= k1;
+
+    h1 = ROTL64(h1,27); h1 += h2; h1 = h1*5+0x52dce729;
+
+    k2 *= c2; k2  = ROTL64(k2,33); k2 *= c1; h2 ^= k2;
+
+    h2 = ROTL64(h2,31); h2 += h1; h2 = h2*5+0x38495ab5;
+  }
+
+  //----------
+  // tail
+
+  const uint8_t * tail = (const uint8_t*)(data + nblocks*16);
+
+  uint64_t k1 = 0;
+  uint64_t k2 = 0;
+
+  switch(len & 15)
+  {
+  case 15: k2 ^= ((uint64_t)tail[14]) << 48;
+  case 14: k2 ^= ((uint64_t)tail[13]) << 40;
+  case 13: k2 ^= ((uint64_t)tail[12]) << 32;
+  case 12: k2 ^= ((uint64_t)tail[11]) << 24;
+  case 11: k2 ^= ((uint64_t)tail[10]) << 16;
+  case 10: k2 ^= ((uint64_t)tail[ 9]) << 8;
+  case  9: k2 ^= ((uint64_t)tail[ 8]) << 0;
+           k2 *= c2; k2  = ROTL64(k2,33); k2 *= c1; h2 ^= k2;
+
+  case  8: k1 ^= ((uint64_t)tail[ 7]) << 56;
+  case  7: k1 ^= ((uint64_t)tail[ 6]) << 48;
+  case  6: k1 ^= ((uint64_t)tail[ 5]) << 40;
+  case  5: k1 ^= ((uint64_t)tail[ 4]) << 32;
+  case  4: k1 ^= ((uint64_t)tail[ 3]) << 24;
+  case  3: k1 ^= ((uint64_t)tail[ 2]) << 16;
+  case  2: k1 ^= ((uint64_t)tail[ 1]) << 8;
+  case  1: k1 ^= ((uint64_t)tail[ 0]) << 0;
+           k1 *= c1; k1  = ROTL64(k1,31); k1 *= c2; h1 ^= k1;
+  };
+
+  //----------
+  // finalization
+
+  h1 ^= len; h2 ^= len;
+
+  h1 += h2;
+  h2 += h1;
+
+  h1 = fmix64(h1);
+  h2 = fmix64(h2);
+
+  h1 += h2;
+  h2 += h1;
+
+  ((uint64_t*)out)[0] = h1;
+  ((uint64_t*)out)[1] = h2;
+}
+
+VALUE
+murmur3_x64_128_finish(VALUE self)
+{
+  uint8_t digest[16];
+  uint64_t out[2];
+
+  _murmur_finish128(self, out, murmur_hash_process3_x64_128);
+  assign_by_endian_128(digest, out);
+  return rb_str_new((const char*) digest, 16);
+}
+
+VALUE
+murmur3_x64_128_s_digest(int argc, VALUE *argv, VALUE klass)
+{
+  uint8_t digest[16];
+  uint64_t out[2];
+
+  _murmur_s_digest128(argc, argv, klass, (void*)out, murmur_hash_process3_x64_128);
+  assign_by_endian_128(digest, out);
+  return rb_str_new((const char*) digest, 16);
+}
+
+VALUE
+murmur3_x64_128_s_rawdigest(int argc, VALUE *argv, VALUE klass)
+{
+  uint64_t out[2];
+
+  _murmur_s_digest128(argc, argv, klass, (void*)out, murmur_hash_process3_x64_128);
+  return rb_assoc_new(ULL2NUM(out[0]), ULL2NUM(out[1]));
+}

data/ext/murmurhash/3_x86_32.c

@@ -0,0 +1,88 @@
+/*
+ * MurmurHash3_x86_32 (C) Austin Appleby
+ */
+
+#include "murmurhash.h"
+
+uint32_t
+murmur_hash_process3_x86_32(const char * key, uint32_t len, uint32_t seed)
+{
+  const uint8_t * data = (const uint8_t*)key;
+  const int nblocks = len / 4;
+  int i;
+
+  uint32_t h1 = seed;
+
+  const uint32_t c1 = 0xcc9e2d51;
+  const uint32_t c2 = 0x1b873593;
+
+  //----------
+  // body
+
+  const uint32_t * blocks = (const uint32_t *)(data + nblocks*4);
+
+  for(i = -nblocks; i; i++)
+  {
+    uint32_t k1 = getblock32(blocks,i);
+
+    k1 *= c1;
+    k1 = ROTL32(k1,15);
+    k1 *= c2;
+
+    h1 ^= k1;
+    h1 = ROTL32(h1,13);
+    h1 = h1*5+0xe6546b64;
+  }
+
+  //----------
+  // tail
+
+  const uint8_t * tail = (const uint8_t*)(data + nblocks*4);
+
+  uint32_t k1 = 0;
+
+  switch(len & 3)
+  {
+  case 3: k1 ^= tail[2] << 16;
+  case 2: k1 ^= tail[1] << 8;
+  case 1: k1 ^= tail[0];
+          k1 *= c1; k1 = ROTL32(k1,15); k1 *= c2; h1 ^= k1;
+  };
+
+  //----------
+  // finalization
+
+  h1 ^= len;
+
+  h1 = fmix32(h1);
+
+  return h1;
+}
+
+VALUE
+murmur3_x86_32_finish(VALUE self)
+{
+  uint8_t digest[4];
+  uint32_t h;
+
+  h = _murmur_finish32(self, murmur_hash_process3_x86_32);
+  assign_by_endian_32(digest, h);
+  return rb_str_new((const char*) digest, 4);
+}
+
+VALUE
+murmur3_x86_32_s_digest(int argc, VALUE *argv, VALUE klass)
+{
+  uint8_t digest[4];
+  uint32_t h;
+
+  h = _murmur_s_digest32(argc, argv, klass, murmur_hash_process3_x86_32);
+  assign_by_endian_32(digest, h);
+  return rb_str_new((const char*) digest, 4);
+}
+
+VALUE
+murmur3_x86_32_s_rawdigest(int argc, VALUE *argv, VALUE klass)
+{
+  return ULL2NUM(_murmur_s_digest32(argc, argv, klass, murmur_hash_process3_x86_32));
+}

data/ext/murmurhash/extconf.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'mkmf'
+
+create_makefile('murmurhash/murmurhash')

data/ext/murmurhash/murmurhash.c

@@ -0,0 +1,255 @@
+#include "murmurhash.h"
+
+ID id_DEFAULT_SEED;
+ID iv_seed;
+ID iv_buffer;
+
+
+inline uint32_t rotl32 ( uint32_t x, int8_t r )
+{
+  return (x << r) | (x >> (32 - r));
+}
+inline uint64_t rotl64 ( uint64_t x, int8_t r )
+{
+  return (x << r) | (x >> (64 - r));
+}
+
+FORCE_INLINE uint32_t getblock32 ( const uint32_t * p, int i )
+{
+  return p[i];
+}
+
+FORCE_INLINE uint64_t getblock64 ( const uint64_t * p, int i )
+{
+  return p[i];
+}
+
+FORCE_INLINE uint32_t fmix32 ( uint32_t h )
+{
+  h ^= h >> 16;
+  h *= 0x85ebca6b;
+  h ^= h >> 13;
+  h *= 0xc2b2ae35;
+  h ^= h >> 16;
+
+  return h;
+}
+
+FORCE_INLINE uint64_t fmix64 ( uint64_t k )
+{
+  k ^= k >> 33;
+  k *= BIG_CONSTANT(0xff51afd7ed558ccd);
+  k ^= k >> 33;
+  k *= BIG_CONSTANT(0xc4ceb9fe1a85ec53);
+  k ^= k >> 33;
+
+  return k;
+}
+
+void
+assign_by_endian_32(uint8_t *digest, uint32_t h)
+{
+  if (BIGENDIAN_P()) {
+    digest[0] = h >> 24;
+    digest[1] = h >> 16;
+    digest[2] = h >> 8;
+    digest[3] = h;
+  }
+  else {
+    digest[3] = h >> 24;
+    digest[2] = h >> 16;
+    digest[1] = h >> 8;
+    digest[0] = h;
+  }
+}
+
+void
+assign_by_endian_64(uint8_t *digest, uint64_t h)
+{
+  if (BIGENDIAN_P()) {
+    digest[0] = h >> 56;
+    digest[1] = h >> 48;
+    digest[2] = h >> 40;
+    digest[3] = h >> 32;
+    digest[4] = h >> 24;
+    digest[5] = h >> 16;
+    digest[6] = h >> 8;
+    digest[7] = h;
+  }
+  else {
+    digest[7] = h >> 56;
+    digest[6] = h >> 48;
+    digest[5] = h >> 40;
+    digest[4] = h >> 32;
+    digest[3] = h >> 24;
+    digest[2] = h >> 16;
+    digest[1] = h >> 8;
+    digest[0] = h;
+  }
+}
+
+void
+assign_by_endian_128(uint8_t *digest, void *out)
+{
+  int i;
+
+  if (BIGENDIAN_P()) {
+    for (i = 0; i < 4; i++) {
+      digest[(i*4)  ] = ((uint32_t*)out)[i] >> 24;
+      digest[(i*4)+1] = ((uint32_t*)out)[i] >> 16;
+      digest[(i*4)+2] = ((uint32_t*)out)[i] >> 8;
+      digest[(i*4)+3] = ((uint32_t*)out)[i];
+    }
+  }
+  else {
+    for (i = 0; i < 4; i++) {
+      digest[16-(i*4)-1] = ((uint32_t*)out)[i] >> 24;
+      digest[16-(i*4)-2] = ((uint32_t*)out)[i] >> 16;
+      digest[16-(i*4)-3] = ((uint32_t*)out)[i] >> 8;
+      digest[16-(i*4)-4] = ((uint32_t*)out)[i];
+    }
+  }
+}
+
+static uint32_t
+rstring2uint32_t(VALUE str)
+{
+  long len = RSTRING_LEN(str);
+  if (UINT32_MAX < len) {
+    rb_raise(rb_eRangeError, "String length=%ld will overflow from long to uint32_t", len);
+  }
+  return (uint32_t)len;
+}
+
+uint32_t
+_murmur_finish32(VALUE self, uint32_t (*process)(const char*, uint32_t, uint32_t))
+{
+  const char *seed = RSTRING_PTR(rb_ivar_get(self, iv_seed));
+  VALUE buffer = rb_ivar_get(self, iv_buffer);
+  return process(RSTRING_PTR(buffer), rstring2uint32_t(buffer), *(uint32_t*)seed);
+}
+
+uint64_t
+_murmur_finish64(VALUE self, uint64_t (*process)(const char*, uint32_t, uint64_t))
+{
+  const char *seed = RSTRING_PTR(rb_ivar_get(self, iv_seed));
+  VALUE buffer = rb_ivar_get(self, iv_buffer);
+  return process(RSTRING_PTR(buffer), rstring2uint32_t(buffer), *(uint64_t*)seed);
+}
+
+void
+_murmur_finish128(VALUE self, void *out, void (*process)(const char*, uint32_t, uint32_t, void*))
+{
+  const char *seed = RSTRING_PTR(rb_ivar_get(self, iv_seed));
+  VALUE buffer = rb_ivar_get(self, iv_buffer);
+  process(RSTRING_PTR(buffer), rstring2uint32_t(buffer), *(uint32_t*)seed, out);
+}
+
+uint32_t
+_murmur_s_digest32(int argc, VALUE *argv, VALUE klass, uint32_t (*process)(const char *, uint32_t, uint32_t))
+{
+  VALUE str;
+  const char *seed;
+
+  if (argc < 1)
+    rb_raise(rb_eArgError, "no data given");
+
+  str = *argv;
+
+  StringValue(str);
+
+  if (1 < argc) {
+    StringValue(argv[1]);
+    if (RSTRING_LEN(argv[1]) != 4) {
+      rb_raise(rb_eArgError, "seed string should be 4 length");
+    }
+    seed = RSTRING_PTR(argv[1]);
+  } else {
+    seed = RSTRING_PTR(rb_const_get(klass, id_DEFAULT_SEED));
+  }
+
+  return process(RSTRING_PTR(str), rstring2uint32_t(str), *(uint32_t*)seed);
+}
+
+uint64_t
+_murmur_s_digest64(int argc, VALUE *argv, VALUE klass, uint64_t (*process)(const char *, uint32_t, uint64_t))
+{
+  VALUE str;
+  const char *seed;
+
+  if (argc < 1)
+    rb_raise(rb_eArgError, "no data given");
+
+  str = *argv;
+
+  StringValue(str);
+
+  if (1 < argc) {
+    StringValue(argv[1]);
+    if (RSTRING_LEN(argv[1]) != 8) {
+      rb_raise(rb_eArgError, "seed string should be 8 length");
+    }
+    seed = RSTRING_PTR(argv[1]);
+  } else {
+    seed = RSTRING_PTR(rb_const_get(klass, id_DEFAULT_SEED));
+  }
+
+  return process(RSTRING_PTR(str), rstring2uint32_t(str), *(uint64_t*)seed);
+}
+
+void
+_murmur_s_digest128(int argc, VALUE *argv, VALUE klass, void *out, void (*process)(const char *, uint32_t, uint32_t, void *))
+{
+  VALUE str;
+  const char *seed;
+  int seed_length = 4;
+
+  if (argc < 1)
+    rb_raise(rb_eArgError, "no data given");
+
+  str = *argv;
+
+  StringValue(str);
+
+  if (1 < argc) {
+    StringValue(argv[1]);
+    if (RSTRING_LEN(argv[1]) != seed_length) {
+      rb_raise(rb_eArgError, "seed string should be %d length", seed_length);
+    }
+    seed = RSTRING_PTR(argv[1]);
+  } else {
+    seed = RSTRING_PTR(rb_const_get(klass, id_DEFAULT_SEED));
+  }
+
+  process(RSTRING_PTR(str), rstring2uint32_t(str), *(uint32_t*)seed, out);
+}
+
+
+void
+Init_murmurhash(void)
+{
+  VALUE cDigest_MurmurHash1,
+        cDigest_MurmurHash2,
+        cDigest_MurmurHash2A,
+        cDigest_MurmurHash64A,
+        cDigest_MurmurHash64B,
+        cDigest_MurmurHashNeutral2,
+        cDigest_MurmurHashAligned2,
+        cDigest_MurmurHash3_x86_32,
+        cDigest_MurmurHash3_x86_128,
+        cDigest_MurmurHash3_x64_128;
+
+  id_DEFAULT_SEED = rb_intern("DEFAULT_SEED");
+  iv_seed = rb_intern("@seed");
+  iv_buffer = rb_intern("@buffer");
+
+  cDigest_MurmurHash3_x86_32 = rb_path2class("Digest::MurmurHashMRI3_x86_32");
+  rb_define_singleton_method(cDigest_MurmurHash3_x86_32, "digest", murmur3_x86_32_s_digest, -1);
+  rb_define_singleton_method(cDigest_MurmurHash3_x86_32, "rawdigest", murmur3_x86_32_s_rawdigest, -1);
+  rb_define_private_method(cDigest_MurmurHash3_x86_32, "finish", murmur3_x86_32_finish, 0);
+
+  cDigest_MurmurHash3_x64_128 = rb_path2class("Digest::MurmurHashMRI3_x64_128");
+  rb_define_singleton_method(cDigest_MurmurHash3_x64_128, "digest", murmur3_x64_128_s_digest, -1);
+  rb_define_singleton_method(cDigest_MurmurHash3_x64_128, "rawdigest", murmur3_x64_128_s_rawdigest, -1);
+  rb_define_private_method(cDigest_MurmurHash3_x64_128, "finish", murmur3_x64_128_finish, 0);
+}