hand_rank 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 30f8feb7d175b7d18eea2d0ec62b0dfc5be18385
+  data.tar.gz: 3dd0df03ee14c44b5c124cfea0e1eeb9b3856446
+SHA512:
+  metadata.gz: 583bb9aa4b113c1869cc47328ea3a69aeee27e0ff9f3df01055cb19adfa23403b5b254cbc979046c3ad60b1018304eb4054ac1478fc961ff6325d6f0b222a46c
+  data.tar.gz: a1757fc164bfce4d8f2292c74a8e820ddec579f5117db0a0d9ab4a529fc479137dcec80e7b50545cfa1aa73fa853a4e168b04495d2122c4493ef889527828484

data/.gitignore

@@ -0,0 +1,10 @@
+/Gemfile.lock
+/coverage/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.DS_Store

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Jonas Schubert Erlandsson
+
+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,175 @@
+# WIP
+
+Please read this entire readme before using the gem, thank you.
+
+[![Gem Version](https://badge.fury.io/rb/hand_rank.svg)](http://badge.fury.io/rb/hand_rank)
+[![Code Climate](https://codeclimate.com/github/replaygaming/hand_rank/badges/gpa.svg)](https://codeclimate.com/github/replaygaming/hand_rank)
+[![Test Coverage](https://codeclimate.com/github/replaygaming/hand_rank/badges/coverage.svg)](https://codeclimate.com/github/replaygaming/hand_rank/coverage)
+
+
+# HandRank
+
+The hand_rank gem is a Ruby, with C extension, implementation of the 2 plus 2 
+hand evaluation algorithm for Texam Hold'em hands (or any hands following the 
+same ranking order).
+
+The algorithm uses a large, 130+MB, lookup table and ranks a hand 5-7 card hand 
+by doing 5-7 jumps in hte table and landing on the cell that represents the hand
+you walked to get there, regardless of the order of the steps.
+
+Each, final, cell contains the Cactus Kev hands equivalence number, a number 
+describing the hand among every possible hand. This number can then be compared 
+to any other hands equivalence number to see who is the winner.
+
+The 2 plus 2 version also reorders the equivalence classes to allow for getting 
+a rank within a category. So you can split the rank into a category and a rank
+within that category.
+
+## Refrence
+
+For some not so light reading on the subject I suggest you check out the 
+original sources for all the pieces as well as a comparison roundup from, the
+now defunct, codingthewheel site:
+
+[Cactus Kev's original Poker Hand Evaluator](http://suffe.cool/poker/evaluator.html)
+describes the ordering of hands in the lookup table and the concept of the hand
+equivalence classes.
+
+[Paul Senzee - "Some Perfect Hash"](http://www.paulsenzee.com/2006/06/some-perfect-hash.html)
+describes a hashing algorithm to improve on the size of the Cactus Kev lookup
+table and is the same that is used for the lookup table to the 2 plus 2 solution.
+
+[The original thread on the 2 plus 2 forums]() where it all came together. It's 
+long and threatens to become a bit flamy at times. But in the end I think it is 
+a great example of what you can accomplich on the internet, with strangers if
+you are all prepared to act for the greater good.
+
+And finally [the poker evaluator roundup from codingthewheel.com](http://web.archive.org/web/20150113024316/http://codingthewheel.com/archives/poker-hand-evaluator-roundup) unfortunately via the 
+waybackmachine since the original site is no longer live :/ Great roundup, with 
+code, of all the relevant approaches. The code from the roundup is still 
+[available on Github](https://github.com/christophschmalhofer/poker/tree/master/XPokerEval)
+so there is that ...
+
+## Installation
+
+ > When the gem is finished this is what you will do. Right now you also need to
+ > manually extract the `ranks.data.zip` in `lib/hand_rank/` to `ranks.data` in 
+ > the same folder. This is the lookup table and without it you get nothing :)
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'hand_rank'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install hand_rank
+
+## Usage
+### Hand and card format
+To create a hand you need the cards absolute values. You somehow have to convert
+your representation of a hand into an array of integers where each integer 
+represents a card following this encoding:
+
+```ruby
+ABSOLUTE_CARD_VALUE_LOOKUP = {
+  #       spacer,  A,  2,  3,  4,  5,  6,  7,  8,  9, 10,  J,  Q,  K,  A
+     club: [ nil, 49,  1,  5,  9, 13, 17, 21, 25, 29, 33, 37, 41, 45, 49 ],
+  diamond: [ nil, 50,  2,  6, 10, 14, 18, 22, 26, 30, 34, 38, 42, 46, 50 ],
+    heart: [ nil, 51,  3,  7, 11, 15, 19, 23, 27, 31, 35, 39, 43, 47, 51 ],
+    spade: [ nil, 52,  4,  8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52 ],
+}
+```
+
+This table allows you to lookup and card by suit and value (from 1 to 14, 
+allowing for both high and low aces). In our implementation the `Card` class has
+an `abs`method and the `Hand` class impersonates an array. Since this gem will 
+actually run `map!(&:abs)` on the input before handing it off to the C code our 
+setup allows us to give it a real `Hand` and just leave it to the magic to 
+transform that into an array of integers.
+
+It will still work fine if you feed it an array of integers though. Arrays 
+respond to `map` and fixnum responds to `abs` so it is golden either way.
+
+### Operations
+
+```ruby
+# A hand of     AH  KH  9D  4C  JS  QD  10H
+cards_array = [ 51, 47, 30,  9, 40, 42, 35 ]
+
+rank = HandRank.get( cards_array )
+# 20490
+
+categories = [
+  "invalid_hand",
+  "high_card",
+  "one_pair",
+  "two_pairs",
+  "three_of_a_kind",
+  "straight",
+  "flush",
+  "full_house",
+  "four_of_a_kind",
+  "straight_flush"
+]
+
+HandRank.category( rank )
+# 5
+
+HandRank.rank_in_category( rank )
+# 10
+
+HandRank.category_key( rank )
+# "straight"
+
+puts HandRank.explain( rank )
+# => The hand is a straight
+#    Rank: 20490 Category: 5 Rank in category: 10
+```
+
+## Timing
+Some simple timing might be in order.
+
+```ruby
+require 'benchmark'
+
+n = 8000000
+a = [1,2,3,4,5,6,7]
+Benchmark.bm(7) do |x|
+  x.report('ranking') do
+    for i in 1..n
+      HandRank.get(a)
+    end
+  end
+  x.report('"s"+"s"') do
+    for i in 1..n
+      "Hello" + "world!"
+    end
+  end
+end
+```
+
+Running on a 2015 MacBook pro gives these results:
+
+```
+              user     system      total        real
+ranking   0.900000   0.000000   0.900000 (  0.907518)
+"s"+"s"   1.850000   0.000000   1.850000 (  1.856820)
+```
+
+So ranking a hand is about twice as fast as a string concatenation. On the test 
+machine it can rank over 8 million hands a second, that is one hand every 8 or 
+so microseconds.
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/hand_rank/fork )
+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 a new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rake/extensiontask"
+
+Rake::ExtensionTask.new "hand_rank" do |ext|
+  ext.lib_dir = "lib/hand_rank"
+end

data/ext/hand_rank/extconf.rb

@@ -0,0 +1,3 @@
+require "mkmf"
+$CFLAGS+=" -O3"
+create_makefile "hand_rank/hand_rank"

data/ext/hand_rank/hand_rank.c

@@ -0,0 +1,200 @@
+#include <ruby.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+// The one and only lookup table.
+int HR[32487834];
+const char * const HAND_CATEGORY_KEYS[] = { "invalid_hand", "high_card", "one_pair", "two_pairs", "three_of_a_kind", "straight", "flush", "full_house", "four_of_a_kind", "straight_flush" };
+
+/******************************************************************************/
+/*  These are pure C functions and should not deal with any Ruby values or    */
+/*  conversions.                                                              */
+/******************************************************************************/
+
+char* concat( char* first, char* second ){
+  size_t first_length = strlen( first );
+  size_t second_length = strlen( second );
+  int both_length = first_length + second_length + 1;
+  char* both = (char*) malloc( both_length * sizeof( char ));
+
+  strcpy( both, first );
+  strcat( both, second );
+
+  return both;
+}
+
+char* with_path( char* file_name ){
+  char* path = get_path_from_ruby();
+
+  return concat( path, file_name );
+}
+
+char* hand_category_key( int index ){
+  size_t length = strlen( HAND_CATEGORY_KEYS[ index ]);
+  char* name = (char*) malloc( length * sizeof( char ));
+
+  strcpy( name, HAND_CATEGORY_KEYS[ index ]);
+
+  return name;
+}
+
+char* c_hand_category_key( int index ){
+  size_t length = strlen( HAND_CATEGORY_KEYS[ index ]);
+  char* key = (char*) malloc( length * sizeof( char ));
+
+  strcpy( key, HAND_CATEGORY_KEYS[ index ]);
+
+  return key;
+}
+
+void convert_ruby_array_to_c_array( VALUE rb_cards, int *c_cards, int length ){
+  int i = 0;
+
+  for( int i = 0; i < length; i++ ){
+    c_cards[ i ] = NUM2INT( rb_ary_entry( rb_cards, i ));
+  }
+}
+
+int c_rank_7_card_hand( int* cards ){
+  int p = HR[53 + *cards++];
+  p = HR[p + *cards++];
+  p = HR[p + *cards++];
+  p = HR[p + *cards++];
+  p = HR[p + *cards++];
+  p = HR[p + *cards++];
+  p = HR[p + *cards++];
+  return p;
+}
+
+int c_rank_6_card_hand( int* cards ){
+  int p = HR[53 + *cards++];
+  p = HR[p + *cards++];
+  p = HR[p + *cards++];
+  p = HR[p + *cards++];
+  p = HR[p + *cards++];
+  p = HR[p + *cards++];
+  return HR[p];
+}
+
+int c_rank_5_card_hand( int* cards ){
+  int p = HR[53 + *cards++];
+  p = HR[p + *cards++];
+  p = HR[p + *cards++];
+  p = HR[p + *cards++];
+  p = HR[p + *cards++];
+  return HR[p];
+}
+
+int c_rank_hand( int* cards, int length ){
+  int result;
+
+  switch( length ){
+    case 5 :
+       result = c_rank_5_card_hand( cards );
+       break;
+    case 6 :
+       result = c_rank_6_card_hand( cards );
+       break;
+    default :
+       result = c_rank_7_card_hand( cards );
+  }
+
+  return result;
+}
+
+int c_load_lut( char* path ){
+  memset( HR, 0, sizeof( HR ));
+
+  FILE * fin = fopen( path, "rb" );
+
+  if( fin == NULL ){
+    return -1;
+  }
+
+  size_t bytesread = fread( HR, sizeof( HR ), 1, fin );
+  fclose( fin );
+
+  return 0;
+}
+
+/******************************************************************************/
+/*  These are Ruby functions, in C, and deal with the convertion of values to */
+/*  and from the two contexts.                                                */
+/******************************************************************************/
+
+VALUE rb_rank( VALUE klass, VALUE rb_num_ary ){
+  int length = RARRAY_LEN( rb_num_ary );
+  int c_cards[ length ];
+
+  convert_ruby_array_to_c_array( rb_num_ary, c_cards, length );
+
+  return INT2NUM( c_rank_hand( c_cards, length ));
+}
+
+VALUE rb_category( VALUE klass, VALUE rb_rank ){
+  int rank = NUM2INT( rb_rank );
+  int category = rank >> 12;
+
+  return INT2NUM( category );
+}
+
+VALUE rb_rank_in_category( VALUE klass, VALUE rb_rank ){
+  int rank = NUM2INT( rb_rank );
+  int rank_in_category = rank & 0x00000FFF;
+
+  return INT2NUM( rank_in_category );
+}
+
+VALUE rb_category_key( VALUE klass, VALUE rb_rank ){
+  int rank = NUM2INT( rb_rank );
+  int category = rank >> 12;
+  
+  char* key = c_hand_category_key( category );
+
+  return rb_str_new2( key );
+}
+
+VALUE rb_explain( VALUE klass, VALUE rb_rank ){
+  int rank = NUM2INT( rb_rank );
+  int category = rank >> 12;
+  int rank_in_category = rank & 0x00000FFF;
+  VALUE category_key = rb_category_key( klass, rb_rank );
+
+  VALUE result = rb_sprintf( "The hand is a %"PRIsVALUE"\nRank: %d Category: %d Rank in category: %d", category_key, rank, category, rank_in_category );
+
+  return result;
+}
+
+char* rb_get_path(){
+  VALUE cHandRank = rb_const_get(rb_cObject, rb_intern("HandRank"));
+  ID sym_mymodule = rb_intern( "HOME" );
+  VALUE home = rb_const_get( cHandRank, sym_mymodule );
+  return StringValueCStr( home );
+}
+
+void rb_load_lut(){
+  with_path("ranks.data")
+  if( c_load_lut() == -1 ){
+    rb_raise( rb_eIOError, "could not open data file.");
+    exit( 1 );
+  }
+}
+
+/******************************************************************************/
+/*  This is the "magical" setup function, the main entry point, that is       */
+/*  responsible for exporting our C function to the Ruby context.             */
+/******************************************************************************/
+
+void Init_hand_rank( void ){
+
+  rb_load_lut();
+
+  VALUE cHandRank = rb_const_get(rb_cObject, rb_intern("HandRank"));
+
+  rb_define_singleton_method( cHandRank, "rank", rb_rank, 1 );
+  rb_define_singleton_method( cHandRank, "category", rb_category, 1 );
+  rb_define_singleton_method( cHandRank, "rank_in_category", rb_rank_in_category, 1 );
+  rb_define_singleton_method( cHandRank, "category_key", rb_category_key, 1 );
+  rb_define_singleton_method( cHandRank, "explain", rb_explain, 1 );
+}

data/hand_rank.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'hand_rank/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "hand_rank"
+  spec.version       = HandRank::VERSION
+  spec.authors       = "Jonas Schubert Erlandsson"
+  spec.email         = "jonas.schubert.erlandsson@my-codeworks.com"
+  spec.summary       = "Implements fast poker hand ranking algorithms in C and exposes them through a Ruby API."
+  spec.description   = "This gem implements the 2 plus 2 forum algorith for ranking \"normal\" poker hands, such that are used in Texas Hold'em for example. Support for more hand types, such as high/low hands, will be added in future versions."
+  spec.homepage      = "https://github.com/replaygaming/hand_rank"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  # spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.extensions    = ["ext/hand_rank/extconf.rb"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake-compiler", "~> 0.9"
+end

data/lib/hand_rank/test.rb

@@ -0,0 +1,221 @@
+root_dir = File.expand_path File.dirname(__FILE__)
+lib_dir = File.join( root_dir, 'lib' )
+$LOAD_PATH << lib_dir
+
+require 'hand_rank'
+
+class Card
+  class SuitError < ArgumentError
+    def to_s
+      "Suit must be one of Replay::Poker::Card::(#{SUIT_NAMES.map{|_,s| s[0..-2].upcase }.join('|') })"
+    end
+  end
+
+  class ValueError < ArgumentError
+    def to_s
+      "Value must be a Fixnum between 1 and 14 or any of the strings: #{ VALUE_NAMES[2..-1].join(', ') }"
+    end
+  end
+
+        AceOfSpades = :"🂡"
+        TwoOfSpades = :"🂢"
+      ThreeOfSpades = :"🂣"
+       FourOfSpades = :"🂤"
+       FiveOfSpades = :"🂥"
+        SixOfSpades = :"🂦"
+      SevenOfSpades = :"🂧"
+      EightOfSpades = :"🂨"
+       NineOfSpades = :"🂩"
+        TenOfSpades = :"🂪"
+       JackOfSpades = :"🂫"
+      QueenOfSpades = :"🂭"
+       KingOfSpades = :"🂮"
+
+        AceOfHearts = :"🂱"
+        TwoOfHearts = :"🂲"
+      ThreeOfHearts = :"🂳"
+       FourOfHearts = :"🂴"
+       FiveOfHearts = :"🂵"
+        SixOfHearts = :"🂶"
+      SevenOfHearts = :"🂷"
+      EightOfHearts = :"🂸"
+       NineOfHearts = :"🂹"
+        TenOfHearts = :"🂺"
+       JackOfHearts = :"🂻"
+      QueenOfHearts = :"🂽"
+       KingOfHearts = :"🂾"
+
+      AceOfDiamonds = :"🃁"
+      TwoOfDiamonds = :"🃂"
+    ThreeOfDiamonds = :"🃃"
+     FourOfDiamonds = :"🃄"
+     FiveOfDiamonds = :"🃅"
+      SixOfDiamonds = :"🃆"
+    SevenOfDiamonds = :"🃇"
+    EightOfDiamonds = :"🃈"
+     NineOfDiamonds = :"🃉"
+      TenOfDiamonds = :"🃊"
+     JackOfDiamonds = :"🃋"
+    QueenOfDiamonds = :"🃍"
+     KingOfDiamonds = :"🃎"
+
+         AceOfClubs = :"🃑"
+         TwoOfClubs = :"🃒"
+       ThreeOfClubs = :"🃓"
+        FourOfClubs = :"🃔"
+        FiveOfClubs = :"🃕"
+         SixOfClubs = :"🃖"
+       SevenOfClubs = :"🃗"
+       EightOfClubs = :"🃘"
+        NineOfClubs = :"🃙"
+         TenOfClubs = :"🃚"
+        JackOfClubs = :"🃛"
+       QueenOfClubs = :"🃝"
+        KingOfClubs = :"🃞"
+
+              Joker = :"🃟"
+
+              SPADE = :"♠"
+              HEART = :"♡"
+            DIAMOND = :"♢"
+               CLUB = :"♣"
+              JOKER = :"🃟"
+
+     SUITS = [ SPADE, HEART, DIAMOND, CLUB, JOKER ]
+    VALUES = [ nil, :"A", :"2", :"3", :"4", :"5", :"6", :"7", :"8", :"9", :"10", :"J", :"Q", :"K", :"A" ]
+    ABSOLUTE_VALUE = {
+         CLUB => [ nil, 49, 1, 5,  9, 13, 17, 21, 25, 29, 33, 37, 41, 45, 49 ],
+      DIAMOND => [ nil, 50, 2, 6, 10, 14, 18, 22, 26, 30, 34, 38, 42, 46, 50 ],
+        HEART => [ nil, 51, 3, 7, 11, 15, 19, 23, 27, 31, 35, 39, 43, 47, 51 ],
+        SPADE => [ nil, 52, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52 ],
+        JOKER => [ nil ],
+    }
+
+     CARDS = {
+         SPADE => [ nil, AceOfSpades, TwoOfSpades, ThreeOfSpades, FourOfSpades, FiveOfSpades, SixOfSpades, SevenOfSpades, EightOfSpades, NineOfSpades, TenOfSpades, JackOfSpades, QueenOfSpades, KingOfSpades, AceOfSpades ],
+         HEART => [ nil, AceOfHearts, TwoOfHearts, ThreeOfHearts, FourOfHearts, FiveOfHearts, SixOfHearts, SevenOfHearts, EightOfHearts, NineOfHearts, TenOfHearts, JackOfHearts, QueenOfHearts, KingOfHearts, AceOfHearts ],
+       DIAMOND => [ nil, AceOfDiamonds, TwoOfDiamonds, ThreeOfDiamonds, FourOfDiamonds, FiveOfDiamonds, SixOfDiamonds, SevenOfDiamonds, EightOfDiamonds, NineOfDiamonds, TenOfDiamonds, JackOfDiamonds, QueenOfDiamonds, KingOfDiamonds, AceOfDiamonds ],
+          CLUB => [ nil, AceOfClubs, TwoOfClubs, ThreeOfClubs, FourOfClubs, FiveOfClubs, SixOfClubs, SevenOfClubs, EightOfClubs, NineOfClubs, TenOfClubs, JackOfClubs, QueenOfClubs, KingOfClubs, AceOfClubs ],
+         JOKER => [ Joker ],
+     }
+
+     SUIT_NAMES = {
+         SPADE => 'spades'.freeze,
+         HEART => 'hearts'.freeze,
+       DIAMOND => 'diamonds'.freeze,
+          CLUB => 'clubs'.freeze,
+         JOKER => 'joker '.freeze, # The trailing space is a hack to work with SuitError as well as to_str
+     }
+
+     VALUE_NAMES = [ nil, 'ace'.freeze, 'two'.freeze, 'three'.freeze, 'four'.freeze, 'five'.freeze, 'six'.freeze, 'seven'.freeze, 'eight'.freeze, 'nine'.freeze, 'ten'.freeze, 'jack'.freeze, 'queen'.freeze, 'king'.freeze, 'ace'.freeze ]
+
+  attr_reader :suit, :value, :s, :str, :sym, :abs
+  alias :to_s :s
+  alias :to_str :str
+  alias :to_sym :sym
+  alias :to_i :abs
+
+  def initialize( value:, suit: )
+    value = normalize_value( value )
+    raise ValueError unless value.instance_of? Fixnum
+    raise ValueError unless (1..14).cover? value
+
+    suit = normalize_suit( suit )
+    raise SuitError unless SUIT_NAMES.keys.include? suit
+
+    value = 0 if suit == JOKER
+
+    @value = value.to_i
+    @suit = suit
+
+    @s = "#{ VALUES[ value ] }#{ suit }"
+
+    @sym = CARDS[ suit ][ value ]
+
+    parts = [ VALUE_NAMES[ value ], SUIT_NAMES[ suit ]]
+    @str = parts.compact.join( ' of ' ).strip
+
+    @abs = ABSOLUTE_VALUE[ suit ][ value ]
+    
+    self.freeze
+  end
+
+private
+
+  def normalize_value( value )
+    return value if value.instance_of? Fixnum
+
+    return VALUE_NAMES.index( value )
+  end
+
+  def normalize_suit( suit )
+    return suit if SUIT_NAMES.keys.include? suit
+
+    suit = suit.to_s
+    tuple = SUIT_NAMES.find{|k,v| v.start_with? suit.to_s.downcase }
+    return suit unless tuple
+    tuple.first
+  end
+
+end
+
+require 'forwardable'
+
+class Hand
+
+  extend Forwardable
+
+  delegate [:map!, :[], :<<, :size, :to_a] => :@cards
+
+  def initialize( *card_strings )
+    @cards = card_strings.map do |string|
+      Card.new(
+        value: value = string.to_i,
+        suit: string.gsub( value.to_s, '' ).to_sym,
+      )
+    end
+  end
+
+  def cards
+    @cards
+  end
+
+  def to_s
+    @cards.map(&:to_s).join(', ')
+  end
+end
+
+# hand = Hand.new( '2C', '2D', '2S', '13D', '8C', '8S', '2H' )
+hand = Hand.new( '2C', '2D', '2S', '13D', '8C', '8S' )
+# hand = Hand.new( '2C', '2D', '2S', '13D', '8C' )
+
+puts hand
+rank = HandRank.get( hand )
+p HandRank.explain( rank )
+
+require 'benchmark'
+
+n = 10#8000000
+a = [1,2,3,4,5,6,7]
+Benchmark.bm(7) do |x|
+  x.report('ranking') do
+    for i in 1..n
+      HandRank.get(a)
+    end
+  end
+  x.report('ranking') do
+    for i in 1..n
+      HandRank.rb_get(a)
+    end
+  end
+  x.report('"s"+"s"') do
+    for i in 1..n
+      "Hello" + "world!"
+    end
+  end
+end
+
+# Test with transformation code in Ruby
+#               user     system      total        real
+# ranking   5.380000   0.000000   5.380000 (  5.388186)
+# "s"+"s"   1.850000   0.010000   1.860000 (  1.858708)

data/lib/hand_rank/version.rb

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

data/lib/hand_rank.rb

@@ -0,0 +1,12 @@
+require "hand_rank/version"
+
+module HandRank
+  HOME = __FILE__.to_s.gsub('.rb','/')
+
+  def self.get( hand )
+    cards = hand.to_a.map{|c| c.to_i }
+    self.rank( cards )
+  end
+end
+
+require "hand_rank/hand_rank"

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: hand_rank
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jonas Schubert Erlandsson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-09-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: This gem implements the 2 plus 2 forum algorith for ranking "normal"
+  poker hands, such that are used in Texas Hold'em for example. Support for more hand
+  types, such as high/low hands, will be added in future versions.
+email: jonas.schubert.erlandsson@my-codeworks.com
+executables: []
+extensions:
+- ext/hand_rank/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- ext/hand_rank/extconf.rb
+- ext/hand_rank/hand_rank.c
+- hand_rank.gemspec
+- lib/hand_rank.rb
+- lib/hand_rank/ranks.data.zip
+- lib/hand_rank/test.rb
+- lib/hand_rank/version.rb
+homepage: https://github.com/replaygaming/hand_rank
+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.4.5
+signing_key: 
+specification_version: 4
+summary: Implements fast poker hand ranking algorithms in C and exposes them through
+  a Ruby API.
+test_files: []