city_hash 0.0.1

data/.gitignore

@@ -0,0 +1,3 @@
+pkg/*
+*.gem
+.bundle

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,18 @@
+PATH
+  remote: .
+  specs:
+    city_hash (0.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    rubyzip (0.9.4)
+    test-unit (2.3.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  city_hash!
+  rubyzip
+  test-unit

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/city_hash.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "city_hash/version"
+
+Gem::Specification.new do |s|
+  s.name        = "city_hash"
+  s.version     = CityHash::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Ashwin Ramaswamy"]
+  s.email       = ["ashwin.raman9@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{CityHash for Ruby}
+  s.description = %q{Google's CityHash Implementation in Ruby}
+
+  s.rubyforge_project = "city_hash"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency('test-unit')
+  s.add_development_dependency('rubyzip')
+end

data/lib/city_hash.rb

@@ -0,0 +1,332 @@
+# All source comments are duplicated from Google's CityHash (1.0.2)
+# implementation at: http://code.google.com/p/cityhash/
+
+module CityHash
+
+  def self.hash64(s, seed0 = nil, seed1 = nil)
+    return CityHash::Internal.hash64(s) if seed0.nil?
+    return CityHash::Internal.hash64WithSeed(s, seed0) if seed1.nil?
+    return CityHash::Internal.hash64WithSeeds(s, seed0, seed1)
+  end
+
+  def self.hash128(s, seed = nil)
+    return CityHash::Internal.hash128(s) if seed.nil?
+    return CityHash::Internal.hash128WithSeed(s, seed)
+  end
+
+  module Internal
+
+    # Some primes between 2^63 and 2^64 for various uses
+    K0 = 0xc3a5c85c97cb3127
+    K1 = 0xb492b66fbe98f273
+    K2 = 0x9ae16a3b2f90404f
+    K3 = 0xc949d7c7509e6557
+
+    def self.lower32(x)
+      x & 0xffffffff
+    end
+
+    def self.lower64(x)
+      x & 0xffffffffffffffff
+    end
+
+    def self.higher64(x)
+      x >> 64
+    end
+
+    # Return the hex-equivalent of byte-string
+    def self.bytes(s)
+      h = 0x0
+      s.reverse.bytes do |b|
+        h <<= 8
+        h |= b
+      end
+      h
+    end
+
+    # Hash 128 input bits down to 64 bits of output.
+    # This is intended to be a reasonably good hash function.
+    def self.hash128To64(x)
+      # Murmur-inspired hashing.
+      kMul = 0x9ddfea08eb382d69
+      a = lower64((lower64(x) ^ higher64(x)) * kMul)
+      a ^= (a >> 47)
+      b = lower64((higher64(x) ^ a) * kMul)
+      b ^= (b >> 47)
+      b = b * kMul
+      lower64(b)
+    end
+
+    # Bitwise right rotate
+    def self.rotate(val, shift)
+      return val if shift == 0
+      (val >> shift) | lower64((val << (64-shift)))
+    end
+
+    # Equivalent to rotate(...), but requires the second arg to be non-zero.
+    def self.rotateByAtleast1(val, shift)
+      (val >> shift) | lower64((val << (64-shift)))
+    end
+
+    def self.shiftMix(val)
+      lower64(val ^ (val >> 47))
+    end
+
+    def self.hashLen16(u, v)
+      uv = (v << 64) | u
+      hash128To64(uv)
+    end
+
+    def self.hashLen0To16(s)
+      len = s.length
+      if len > 8
+        a = bytes(s[0..7])
+        b = bytes(s[-8..-1])
+        return hashLen16(a, rotateByAtleast1(b+len, len)) ^ b
+      elsif len >= 4
+        a = bytes(s[0..3])
+        return hashLen16(len + (a << 3), bytes(s[-4..-1]))
+      elsif len > 0
+        a = bytes(s[0])
+        b = bytes(s[len >> 1])
+        c = bytes(s[len-1])
+        y = lower32(a + (b << 8))
+        z = len + c*4
+        return lower64(shiftMix(lower64(y * K2 ^ z * K3)) * K2)
+      end
+      K2
+    end
+
+    # This probably works well for 16-byte strings as well, but it may be overkill
+    # in that case.
+    def self.hashLen17To32(s)
+      a = lower64(bytes(s[0..7]) * K1)
+      b = bytes(s[8..15])
+      c = lower64(bytes(s[-8..-1]) * K2)
+      d = lower64(bytes(s[-16..-9]) * K0)
+      hashLen16(lower64(rotate(lower64(a-b), 43) + rotate(c, 30) + d),
+      lower64(a + rotate(b ^ K3, 20) - c) + s.length)
+    end
+
+    # Return a 16-byte hash for 48 bytes.  Quick and dirty.
+    # Callers do best to use "random-looking" values for a and b.
+    def self._weakHashLen32WithSeeds(w, x, y, z, a, b)
+      a += w
+      b = rotate(lower64(b+a+z), 21)
+      c = a
+      a += x
+      a = lower64(a+y)
+      b += rotate(a, 44)
+      lower64(a+z) << 64 | lower64(b+c)
+    end
+
+    # Return a 16-byte hash for s[0] ... s[31], a, and b.  Quick and dirty.
+    def self.weakHashLen32WithSeeds(s, a, b)
+      _weakHashLen32WithSeeds(bytes(s[0..7]),
+      bytes(s[8..15]),
+      bytes(s[16..23]),
+      bytes(s[24..31]),
+      a,
+      b)
+    end
+
+    # Return an 8-byte hash for 33 to 64 bytes.
+    def self.hashLen33To64(s)
+      len = s.length
+      z = bytes(s[24..31])
+      a = bytes(s[0..7]) + (len + bytes(s[-16..-9])) * K0
+      a = lower64(a)
+      b = rotate(lower64(a+z), 52)
+      c = rotate(a, 37)
+      a = lower64(a+bytes(s[8..15]))
+      c = lower64(c+rotate(a, 7))
+      a = lower64(a+bytes(s[16..23]))
+      vf = lower64(a+z)
+      vs = lower64(b + rotate(a, 31) + c)
+      a = bytes(s[16..23]) + bytes(s[-32..-25])
+      z = bytes(s[-8..-1])
+      b = rotate(lower64(a+z), 52)
+      c = rotate(a, 37)
+      a = lower64(a+bytes(s[-24..-17]))
+      c = lower64(c+rotate(a, 7))
+      a = lower64(a+bytes(s[-16..-9]))
+      wf = lower64(a+z)
+      ws = lower64(b + rotate(a, 31) + c)
+      r = shiftMix( lower64((vf + ws) * K2  + (wf + vs) * K0) )
+      lower64( shiftMix(lower64(r*K0+vs)) * K2)
+    end
+
+    def self.hashLenAbove64(s)
+      len = s.length
+      # For strings over 64 bytes we hash the end first, and then as we
+      # loop we keep 56 bytes of state: v, w, x, y, and z.
+      x = bytes(s[0..7])
+      y = bytes(s[-16..-9]) ^ K1
+      z = bytes(s[-56..-49]) ^ K0
+      v = weakHashLen32WithSeeds(s[-64..-1], len, y)
+      w = weakHashLen32WithSeeds(s[-32..-1], lower64(len*K1), K0)
+
+      z = lower64(z + shiftMix(lower64(v)) * K1)
+      x = lower64(rotate(lower64(z+x), 39) * K1)
+      y = lower64(rotate(y, 33) * K1)
+
+      # Decrease len to the nearest multiple of 64, and operate on 64-byte chunks.
+      len = (len - 1) & ~63;
+      begin
+        xrv = lower64(x + y + higher64(v) + bytes(s[16..23]))
+        yrv = lower64(y + lower64(v) + bytes(s[48..55]))
+        x = lower64(rotate(xrv, 37) * K1)
+        y = lower64(rotate(yrv, 42) * K1)
+        x ^= lower64(w)
+        y ^= higher64(v)
+        z = rotate(z ^ higher64(w), 33)
+        v = weakHashLen32WithSeeds(s, lower64(lower64(v) * K1), lower64(x + higher64(w)))
+        w = weakHashLen32WithSeeds(s[32..-1], lower64(z + lower64(w)), y)
+        z, x = x, z
+        s = s[64..-1]
+        len -= 64
+      end while len != 0
+
+      hashLen16(lower64(hashLen16(higher64(v), higher64(w)) + shiftMix(y) * K1 + z),
+      lower64(hashLen16(lower64(v), lower64(w)) + x))
+    end
+
+    # A subroutine for CityHash128().  Returns a decent 128-bit hash for strings
+    # of any length representable in ssize_t.  Based on City and Murmur.
+    def self.cityMurmur(s, seed)
+      len = s.length
+      a = lower64(seed)
+      b = higher64(seed)
+      c,d = 0, 0
+      l = s.length - 16
+      if l <=0 then
+        a = lower64(shiftMix(lower64(a * K1)) * K1)
+        c = lower64(b*K1 + hashLen0To16(s))
+        d = shiftMix(lower64(a + (len >=8 ? bytes(s[0..7]) : c)))
+      else
+        c = hashLen16(lower64(bytes(s[-8..-1]) + K1), a)
+        d = hashLen16(lower64(b+len), lower64(c + bytes(s[-16..-9])))
+        a = lower64(a+d)
+        begin
+          a ^= lower64(shiftMix(lower64(bytes(s[0..7]) * K1)) * K1)
+          a = lower64(a*K1)
+          b ^= a
+          c ^= lower64(shiftMix(lower64(bytes(s[8..15]) * K1)) * K1)
+          c = lower64(c*K1)
+          d ^= c
+          s = s[16..-1]
+          l -= 16
+        end while l > 0
+      end
+      a = hashLen16(a, c)
+      b = hashLen16(d, b)
+      ((a^b) << 64) | hashLen16(b, a)
+    end
+
+    def self.hash128WithSeed(s, seed)
+      # Create a copy of the input string
+      orig_s = String.new(s)
+      len = s.length
+      return cityMurmur(s, seed) if len < 128
+
+      # We expect len >= 128 to be the common case.  Keep 56 bytes of state:
+      # v, w, x, y, and z.
+      x = lower64(seed)
+      y = higher64(seed)
+      z = lower64(len * K1)
+      vf = lower64(lower64(rotate(y ^ K1, 49) * K1) + bytes(s[0..7]))
+      vs = lower64(lower64(rotate(vf, 42) * K1) + bytes(s[8..15]))
+      wf = lower64(lower64(rotate(lower64(y+z), 35) * K1) + x)
+      ws = lower64(rotate(lower64(x + bytes(s[88..95])), 53) * K1)
+      v = (vf << 64) | vs
+      w = (wf << 64) | ws
+
+      # This is the same inner loop as CityHash64(), manually unrolled.
+      begin
+        x = lower64(rotate(lower64(x + y + vf + bytes(s[16..23])), 37) * K1)
+        y = lower64(rotate(lower64(y + vs + bytes(s[48..55])), 42) * K1)
+        x ^= ws
+        y ^= vf
+        z = rotate(z ^ wf, 33)
+        v = weakHashLen32WithSeeds(s, lower64(vs * K1), lower64(x+wf))
+        w = weakHashLen32WithSeeds(s[32..-1], lower64(z+ws), y)
+        vf, vs = higher64(v), lower64(v)
+        wf, ws = higher64(w), lower64(w)
+        z,x = x,z
+        s = s[64..-1]
+
+        x = lower64(rotate(lower64(x + y + vf + bytes(s[16..23])), 37) * K1)
+        y = lower64(rotate(lower64(y + vs + bytes(s[48..55])), 42) * K1)
+        x ^= ws
+        y ^= vf
+        z = rotate(z ^ wf, 33)
+        v = weakHashLen32WithSeeds(s, lower64(vs * K1), lower64(x+wf))
+        w = weakHashLen32WithSeeds(s[32..-1], lower64(z+ws), y)
+        vf, vs = higher64(v), lower64(v)
+        wf, ws = higher64(w), lower64(w)
+        z,x = x,z
+        s = s[64..-1]
+        len -= 128
+      end while len >= 128
+
+      y = lower64(y + rotate(wf, 37) * K0 + z)
+      x = lower64(x + rotate(lower64(vf + z), 49) * K0)
+      # If 0 < len < 128, hash up to 4 chunks of 32 bytes each from the end of s.
+      tail_done = 0
+      while tail_done < len do
+        tail_done += 32
+        y = lower64(rotate(lower64(y-x), 42) * K0 + vs)
+        wf = lower64(wf + bytes(orig_s[16-tail_done..23-tail_done]))
+        x = lower64(rotate(x, 49) * K0 + wf)
+        wf = lower64(wf + vf)
+        v = weakHashLen32WithSeeds(orig_s[-tail_done..-1], vf, vs)
+        vf, vs = higher64(v), lower64(v)
+      end
+      # At this point our 48 bytes of state should contain more than
+      # enough information for a strong 128-bit hash.  We use two
+      # different 48-byte-to-8-byte hashes to get a 16-byte final result.
+      x = hashLen16(x, vf)
+      y = hashLen16(y, wf)
+      hf = lower64(hashLen16(lower64(x + vs), ws) + y)
+      hs = lower64(hashLen16(lower64(x + ws), lower64(y + vs)))
+      (hf << 64) | hs
+    end
+
+    # Internal interface routines for CityHash module
+    def self.hash64(s)
+      len = s.length
+      if len <= 16
+        return hashLen0To16(s)
+      elsif len <= 32
+        return hashLen17To32(s)
+      elsif len <= 64
+        return hashLen33To64(s)
+      else
+        return hashLenAbove64(s)
+      end      
+    end
+
+    def self.hash64WithSeed(s, seed)
+      hash64WithSeeds(s, K2, seed)
+    end
+
+    def self.hash64WithSeeds(s, seed0, seed1)
+      hashLen16(lower64(hash64(s) - seed0), seed1)
+    end
+
+    def self.hash128(s)
+      len = s.length
+      if len >=16
+        seed = ((bytes(s[8..15]) << 64) | (bytes(s[0..7]) ^ K3))
+        return hash128WithSeed(s[16..-1], seed)
+      elsif len >= 8
+        seed = (bytes(s[-8..-1]) ^ K1) << 64
+        seed |= (bytes(s[0..7]) ^ lower64(len*K0))
+        return hash128WithSeed("", seed)
+      else
+        return hash128WithSeed(s, (K1<<64) | K0)
+      end
+    end
+
+  end # Module Internal
+end # Module CityHash

data/lib/city_hash/version.rb

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

data/license.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 ashwinr
+
+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,51 @@
+# CityHash for Ruby
+
+This is an implementation of Google's CityHash for Ruby. It supports both 64-bit and 128-bit hashes. The newer CityHashCrc routines have not yet been implemented. Please note that the code has not been optimized for speed.
+
+## Installing CityHash
+
+Installing CityHash is as simple as
+
+	gem install CityHash
+
+## Using CityHash
+
+	require 'CityHash'
+
+	# Calculate a 64-bit hash
+	CityHash.hash64('New York City')
+	
+	# Calculate a 64-bit hash with seed
+	CityHash.hash64('East Village', 0xef23)
+	
+	# Calculate a 64-bit hash with two seeds
+	CityHash.hash64('Meatpacking', 0xba3c, 0x5acd)
+	
+	# Calculate a 128-bit hash
+	CityHash.hash128('SoHo')
+	
+	# Calculate a 128-bit hash with seed
+	CityHash.hash128('Upper West Side', 0x8ad1)
+
+## Testing CityHash
+
+The test functions generate random strings and compare the outputs of both the C and Ruby implementations. The source for these strings is Dostoevsky's 'Crime and Punishment', obtained from Project Gutenberg and compressed within test.zip.
+
+### Prerequisites
+
+Google's implementation of Cityhash must be installed on the test system, since the test routines link against libcityhash.
+
+This 'city_hash' gem must already be installed on the test system.
+
+### Running the tests
+
+	cd test/
+	./run.sh
+
+### Authors
+
+	Ashwin Ramaswamy
+
+### Copyright
+
+Copyright (c) 2011 ashwinr. Please see license.txt for further details.

data/test/Makefile

@@ -0,0 +1,10 @@
+CC= g++
+LOCAL_LIBS= -lcityhash
+OBJS= citymain.o
+OUTPUT= city
+
+city: citymain.o
+	$(CC) $(LOCAL_LIBS) $(OBJS) -o $(OUTPUT)
+
+clean:
+	rm -f $(OUTPUT) $(OBJS)

data/test/citymain.cc

@@ -0,0 +1,97 @@
+#include <iostream>
+#include <string>
+#include <sstream>
+#include <iomanip>
+#include "city.h"
+
+void usage(char** argv)
+{
+  std::cout << "Usage: " << argv[0] << " <hash function> <seed1> <seed2> <hash string>" << std::endl;
+  std::cout << "hashfunction = 1, for CityHash64" << std::endl;
+  std::cout << "             = 2, for CityHash64WithSeed" << std::endl;
+  std::cout << "             = 3, for CityHash64WithSeeds" << std::endl;
+  std::cout << "             = 4, for CityHash128" << std::endl;
+  std::cout << "             = 5, for CityHash128WithSeed" << std::endl;
+  exit(-1);
+}
+
+int main(int argc, char** argv)
+{
+  if(argc < 3)
+    {
+      usage(argv);
+    }
+
+  std::stringstream hss, ss1, ss2;
+  int hashFunction = -1;
+  uint64 seed1, seed2;
+  uint128 seed128;
+  std::string hashString;
+  hss << argv[1], hss >> hashFunction;
+  switch(hashFunction)
+    {
+    case 1:
+    case 4:
+      hashString = argv[2];
+      break;
+
+    case 2:
+      if(argc != 4)
+	usage(argv);
+      ss1 << argv[2], ss1 >> seed1;
+      hashString = argv[3];
+      break;
+
+    case 3:
+    case 5:
+      if(argc != 5)
+	usage(argv);
+      ss1 << argv[2], ss1 >> seed1;
+      ss2 << argv[3], ss2 >> seed2;
+      hashString = argv[4];
+      break;
+    }
+
+  uint64 hash64;
+  uint128 hash128;
+  switch(hashFunction)
+    {
+    case 1:
+      hash64 = CityHash64(hashString.c_str(),
+			  hashString.length());
+      break;
+		
+    case 2:
+      hash64 = CityHash64WithSeed(hashString.c_str(),
+				  hashString.length(), seed1);
+      break;
+			
+    case 3:
+      hash64 = CityHash64WithSeeds(hashString.c_str(),
+				   hashString.length(),
+				   seed1, seed2);
+      break;
+			
+    case 4:
+      hash128 = CityHash128(hashString.c_str(), hashString.length());
+      break;
+			
+    case 5:
+      seed128 = uint128(seed1, seed2);
+      hash128 = CityHash128WithSeed(hashString.c_str(),
+				    hashString.length(), seed128);
+      break;
+    }
+
+  if(hashFunction <= 3)
+    {
+      std::cout << "0x" << std::hex << hash64 << std::endl;
+    }
+  else
+    {
+      std::cout << "0x" << std::hex << hash128.first << std::setfill('0')
+		<< std::setw(16) << hash128.second << std::endl;
+    }
+
+  return 0;
+}

data/test/run.sh

@@ -0,0 +1,18 @@
+#!/bin/sh
+
+# Compile the C version of city
+
+make
+
+# Test whether 'city' exists
+
+if [ ! -f './city' ]
+then
+    echo "./city does not exist. Exiting..."
+    exit -1
+fi
+
+# Run the comparison tests
+
+ruby tc_rcity.rb
+

data/test/tc_rcity.rb

@@ -0,0 +1,96 @@
+#!/usr/local/bin/ruby
+
+require 'city_hash'
+require 'test/unit'
+require 'zip/zip'
+
+=begin
+  Run a gamut of test strings against both Google's C++ and
+  our Ruby implementation, and verify the results.
+  The test verifies both 64 and 128-bit hashes with and without
+  random seeds for strings of length from 1 to 2K.
+  The strings are sourced in randomly from 'Crime and Punishment'
+  obtained from Project Gutenberg.
+=end
+
+class TestCityHash < Test::Unit::TestCase
+  def initialize(testFunction)
+    super testFunction
+    puts 'Unzipping contents of test.zip'
+    @files = []
+    Zip::ZipFile::open('./test.zip') do |zf|
+      zf.each { |file|
+        fpath = File.join('/tmp', file.name)
+        FileUtils.mkdir_p(File.dirname(fpath))
+        zf.extract(file, fpath) unless File.exist?(fpath)
+        @files.push(File.new(fpath)) if fpath =~ /txt$/
+      }
+    end
+  end
+
+  def getRandomString(file, len)
+    size = file.size
+    begin
+      offset = rand(size)
+    end while offset+len >= size
+    file.pos = offset
+    file.read(len)
+  end
+
+  def getHash(function, seed1, seed2, s)
+    hash = -1
+    case function
+    when 1
+      hash = CityHash.hash64(s)
+    when 2
+      hash = CityHash.hash64(s, seed1)
+    when 3
+      hash = CityHash.hash64(s, seed1, seed2)
+    when 4
+      hash = CityHash.hash128(s)
+    else
+      hash = CityHash.hash128(s, (seed2 << 64) | seed1)
+    end
+    hash
+  end
+
+  def test_city_hash
+    max_int_64 = 2**64-1
+    puts 'Running tests'
+    start = Time.now
+    ffile = File.new('failures.txt', 'w')
+    for i in 1..2048 # length of hash string
+      for j in 1..2 # number of iterations
+        for k in 1..5 # all hash functions
+          seed1 = rand(max_int_64)
+          seed2 = rand(max_int_64)
+          file = @files[0] # only a single test file
+          string = getRandomString(file, i)
+          # Remove any unicode characters
+          string.gsub!(/[\x80-\xff]/,"")
+          # Escape a couple of shell characters (anything else missing?)
+          cstring = string.gsub("\"", "\\\"")
+          cstring = cstring.gsub("$", "\\$")
+          # Calculate Google's C++ hash
+          cityArgs = "#{k} "
+          if(k == 1 || k == 4)
+            cityArgs += "\"#{cstring}\""
+          elsif (k == 2)
+            cityArgs += "#{seed1} \"#{cstring}\""
+          else
+            cityArgs += "#{seed1} #{seed2} \"#{cstring}\""
+          end
+          cHex = `./city #{cityArgs}`
+          cHex = cHex.hex
+          # Calculate our Ruby hash
+          rHex = getHash(k, seed1, seed2, string)
+          # Verify hashes
+          ffile.puts "Failed hash function #{k} for string \"#{string}\" with hashes #{cHex} and #{rHex}" if(cHex != rHex)
+          assert(cHex == rHex)
+        end
+      end
+    end
+    elapsed = (Time.now - start)/60.0
+  end
+
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification 
+name: city_hash
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Ashwin Ramaswamy
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-17 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: test-unit
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rubyzip
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: Google's CityHash Implementation in Ruby
+email: 
+- ashwin.raman9@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- Rakefile
+- city_hash.gemspec
+- lib/city_hash.rb
+- lib/city_hash/version.rb
+- license.txt
+- readme.md
+- test/Makefile
+- test/citymain.cc
+- test/run.sh
+- test/tc_rcity.rb
+- test/test.zip
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: city_hash
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: CityHash for Ruby
+test_files: 
+- test/Makefile
+- test/citymain.cc
+- test/run.sh
+- test/tc_rcity.rb
+- test/test.zip