hashman 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f1c21f334159a16a1c366703d22c2459332b8074
+  data.tar.gz: d1b72f68482fb9911dea923e8037ea2a0b04f291
+SHA512:
+  metadata.gz: a63aada8af51e93873e377ed4ab1246ddc20a8f6f29c781ccb15db9c8f2d3b3ee86990d066d39207e62cd95aa0e20d9f04f9ac13e102f1e212bb5389ec5d4155
+  data.tar.gz: 66be8d0cbcf7cd11c65129ca24e56dbaf4def4f5a6241a3aee6e17f28bda3c3b0956be51d0e22f0d6020b6dd9296ce6e27e76242709affca6d51b193fd480a82

data/.document

@@ -0,0 +1,3 @@
+-
+ChangeLog.md
+LICENSE.txt

data/.gitignore

@@ -0,0 +1,7 @@
+/.bundle
+/.idea
+/.yardoc/
+/Gemfile.lock
+/doc/
+/pkg/
+/vendor/cache/*.gem

data/.rspec

@@ -0,0 +1 @@
+--colour --format documentation

data/.yardopts

@@ -0,0 +1 @@
+--markup markdown --title "hashman Documentation" --protected

data/ChangeLog.md

@@ -0,0 +1,4 @@
+### 0.1.0 / 2016-07-27
+
+* Initial release:
+

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :development do
+  gem 'kramdown'
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2016 Evan Surdam
+
+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,119 @@
+# hashman
+
+* [Homepage](https://github.com/esurdam/hashman#readme)
+* [Issues](https://github.com/esurdam/hashman/issues)
+* [Documentation](http://rubydoc.info/gems/hashman/frames)
+* [Email](mailto:es at cosi.io)
+
+## Description
+
+Add some hash magic to your ruby classes.
+
+Use this gem to conceal ids or any integer based array.
+
+Ideally, user a serializer to exlucde ids and include your hash.
+
+Credits on hasher to [Peter Hellberg's Hashid](https://github.com/peterhellberg/hashids.rb)
+
+## Features
+- Hash integer and UUID based ids
+- Reverse hash for lookup
+- Create a hashprint based on an array of integers.
+- Index your hashprint for uniqueness (Useful for payment data!) [EXAMPLE]()
+
+## Examples
+
+### Rails Usage
+    
+Include ```HashMan``` in your model
+```
+class User < ActiveRecord::Base
+  include HashMan
+  # include activuuid only if thats your style
+  include activeuuid
+  
+  # optionally set a hash length minimum
+  # useful for integer based ids
+  hash_length 8 
+end
+```
+
+A typical user will look like:
+```
+user = User.create({ :name => "awesome" })
+user.id 
+ => #<UUID:0x3fe2f1dda1d0 UUID:5604ee6e-c934-44cb-89ff-d2934a708e55> 
+```
+
+Generate a hash for an id (integer or uuid):
+```
+user.hash_id
+ => "rkALRLO3rJyz3vRjx9XJrzlq6" 
+```
+
+Reverse the hash for lookup:
+```
+User.reverse_hash("rkALRLO3rJyz3vRjx9XJrzlq6")
+ => #<UUID:0x3fe2f1d00f70 UUID:5604ee6e-c934-44cb-89ff-d2934a708e55> 
+```
+
+Hashprint sensitive data:
+```
+# secrets are created in userspace
+secrets = {:number => 1234123412341234, :cvv => 701, :zip => 90025 }
+ 
+# hashprint is created before saving to model
+secret_hash = User.create_hashprint = [ secrets[:number], secrets[:cvv], secrets[:zip ]
+=> "evALO3rJyzJrzlq6" 
+ 
+# persist the secret
+user.hashprint = secret_hash
+user.save!
+```
+```
+# Do some cool stuff in your model
+def verify_cvv(cvv)
+    # where [1] is the index of the value
+    # `decoded_hashprint` is a private method form hashman
+    cvv == self.decoded_hashprint[1]
+end
+  
+user.verify_cvv(700)
+ => false
+ 
+user.verify_cvv(701)
+ => true
+```
+Secret data is then hidden from prying eyes!
+
+
+Index hashprint for uniqueness validation! ;)
+
+## Standalone
+
+    require 'hashman'
+
+magic 
+
+```
+HashMan.encode(integer)
+HashMan.create_hashprint(integer_array)
+Hashman.decode(hash)
+
+```
+## Requirements
+
+## Todo
+
+- Auto intercept `find` method on model to allow hash_id
+- I forget the others
+
+## Install
+
+    $ gem install hashman
+
+## Copyright
+
+Copyright (c) 2016 Evan Surdam
+
+See {file:LICENSE.txt} for details.

data/Rakefile

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require 'rubygems'
+
+begin
+  require 'bundler/setup'
+rescue LoadError => e
+  abort e.message
+end
+
+require 'rake'
+
+require 'rubygems/tasks'
+Gem::Tasks.new
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+
+task :test    => :spec
+task :default => :spec
+
+require 'yard'
+YARD::Rake::YardocTask.new  
+task :doc => :yard
+
+task :console do
+  exec "irb -r hashman -I ./lib"
+end

data/gemspec.yml

@@ -0,0 +1,19 @@
+name: hashman
+summary: "add some hash magic to your classes"
+description: "HashMan takes any number (or uuid) and converts it to a unique hash. Includes methods on your class
+              to access and reverse hash"
+license: MIT
+authors: Evan Surdam
+email: es@cosi.io
+homepage: https://github.com/esurdam/hashman#readme
+
+dependencies:
+  activeuuid: ~> 0.6
+  activesupport: ~> 4.0
+
+development_dependencies:
+  bundler: ~> 1.10
+  rake: ~> 10.0
+  rspec: ~> 3.0
+  rubygems-tasks: ~> 0.2
+  yard: ~> 0.8

data/hashman.gemspec

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+require 'yaml'
+
+Gem::Specification.new do |gem|
+  gemspec = YAML.load_file('gemspec.yml')
+
+  gem.name    = gemspec.fetch('name')
+  gem.version = gemspec.fetch('version') do
+                  lib_dir = File.join(File.dirname(__FILE__),'lib')
+                  $LOAD_PATH << lib_dir unless $LOAD_PATH.include?(lib_dir)
+
+                  require 'hashman/version'
+                  HashMan::VERSION
+                end
+
+  gem.summary     = gemspec['summary']
+  gem.description = gemspec['description']
+  gem.licenses    = Array(gemspec['license'])
+  gem.authors     = Array(gemspec['authors'])
+  gem.email       = gemspec['email']
+  gem.homepage    = gemspec['homepage']
+
+  glob = lambda { |patterns| gem.files & Dir[*patterns] }
+
+  gem.files = `git ls-files`.split($/)
+  gem.files = glob[gemspec['files']] if gemspec['files']
+
+  gem.executables = gemspec.fetch('executables') do
+    glob['bin/*'].map { |path| File.basename(path) }
+  end
+  gem.default_executable = gem.executables.first if Gem::VERSION < '1.7.'
+
+  gem.extensions       = glob[gemspec['extensions'] || 'ext/**/extconf.rb']
+  gem.test_files       = glob[gemspec['test_files'] || '{test/{**/}*_test.rb']
+  gem.extra_rdoc_files = glob[gemspec['extra_doc_files'] || '*.{txt,md}']
+
+  gem.require_paths = Array(gemspec.fetch('require_paths') {
+    %w[ext lib].select { |dir| File.directory?(dir) }
+  })
+
+  gem.requirements              = Array(gemspec['requirements'])
+  gem.required_ruby_version     = gemspec['required_ruby_version']
+  gem.required_rubygems_version = gemspec['required_rubygems_version']
+  gem.post_install_message      = gemspec['post_install_message']
+
+  split = lambda { |string| string.split(/,\s*/) }
+
+  if gemspec['dependencies']
+    gemspec['dependencies'].each do |name,versions|
+      gem.add_dependency(name,split[versions])
+    end
+  end
+
+  if gemspec['development_dependencies']
+    gemspec['development_dependencies'].each do |name,versions|
+      gem.add_development_dependency(name,split[versions])
+    end
+  end
+end

data/lib/hashman.rb

@@ -0,0 +1,7 @@
+require 'hashman/hasher'
+require 'hashman/inclusion'
+require 'hashman/version'
+
+module HashMan
+  # include HashMan::Inclusion
+end

data/lib/hashman/hasher.rb

@@ -0,0 +1,297 @@
+module HashMan
+  class Hasher
+    # VERSION = "1.0.2"
+
+    MIN_ALPHABET_LENGTH = 16
+    SEP_DIV             = 3.5
+    GUARD_DIV           = 12.0
+
+    DEFAULT_SEPS        = "cfhistuCFHISTU"
+
+    DEFAULT_ALPHABET    = "abcdefghijklmnopqrstuvwxyz" +
+        "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +
+        "1234567890"
+
+    attr_reader :salt, :min_hash_length, :alphabet, :seps, :guards
+
+    def initialize(salt = "", min_hash_length = 0, alphabet = DEFAULT_ALPHABET)
+      @salt             = salt
+      @min_hash_length  = min_hash_length
+      @alphabet         = alphabet
+
+      setup_alphabet
+    end
+
+    def encode(*numbers)
+      numbers.flatten! if numbers.length == 1
+
+      if numbers.empty? || numbers.reject { |n| Integer(n) && n >= 0 }.any?
+        ""
+      else
+        internal_encode(numbers)
+      end
+    end
+
+    def encode_hex(str)
+      return "" unless hex_string?(str)
+
+      numbers = str.scan(/[\w\W]{1,12}/).map do |num|
+        "1#{num}".to_i(16)
+      end
+
+      encode(numbers)
+    end
+
+    def decode(hash)
+      return [] if hash.nil? || hash.empty?
+
+      internal_decode(hash, @alphabet)
+    end
+
+    def decode_hex(hash)
+      ret = ""
+      numbers = decode(hash)
+
+      numbers.length.times do |i|
+        ret += numbers[i].to_s(16)[1 .. -1]
+      end
+
+      ret.upcase
+    end
+
+    protected
+
+    def internal_encode(numbers)
+      ret = ""
+
+      alphabet = @alphabet
+      length   = numbers.length
+      hash_int = 0
+
+      length.times do |i|
+        hash_int += (numbers[i] % (i + 100))
+      end
+
+      lottery = ret = alphabet[hash_int % alphabet.length]
+
+      length.times do |i|
+        num = numbers[i]
+        buf = lottery + salt + alphabet
+
+        alphabet = consistent_shuffle(alphabet, buf[0, alphabet.length])
+        last     = hash(num, alphabet)
+
+        ret += last
+
+        if (i + 1) < length
+          num %= (last.ord + i)
+          ret += seps[num % seps.length]
+        end
+      end
+
+      if ret.length < min_hash_length
+        ret = guards[(hash_int + ret[0].ord) % guards.length] + ret
+
+        if ret.length < min_hash_length
+          ret += guards[(hash_int + ret[2].ord) % guards.length]
+        end
+      end
+
+      half_length = alphabet.length.div(2)
+
+      while(ret.length < min_hash_length)
+        alphabet = consistent_shuffle(alphabet, alphabet)
+        ret = alphabet[half_length .. -1] + ret + alphabet[0, half_length]
+
+        excess = ret.length - min_hash_length
+        ret = ret[excess / 2, min_hash_length] if excess > 0
+      end
+
+      ret
+    end
+
+    def internal_decode(hash, alphabet)
+      ret = []
+
+      breakdown = hash.gsub(/[#{@guards}]/, " ")
+      array     = breakdown.split(" ")
+
+      i = [3,2].include?(array.length) ? 1 : 0
+
+      if breakdown = array[i]
+        lottery   = breakdown[0]
+        breakdown = breakdown[1 .. -1].gsub(/[#{@seps}]/, " ")
+        array     = breakdown.split(" ")
+
+        array.length.times do |i|
+          sub_hash = array[i]
+          buffer   = lottery + salt + alphabet
+          alphabet = consistent_shuffle(alphabet, buffer[0, alphabet.length])
+
+          ret.push unhash(sub_hash, alphabet)
+        end
+
+        if encode(ret) != hash
+          ret = []
+        end
+      end
+
+      ret
+    end
+
+    def consistent_shuffle(alphabet, salt)
+      return alphabet if salt.nil? || salt.empty?
+
+      v = 0
+      p = 0
+
+      (alphabet.length-1).downto(1) do |i|
+        v  = v % salt.length
+        p += n = salt[v].ord
+        j  = (n + v + p) % i
+
+        tmp_char = alphabet[j]
+
+        alphabet = alphabet[0, j] + alphabet[i] + alphabet[j + 1..-1]
+        alphabet = alphabet[0, i] + tmp_char    + alphabet[i + 1..-1]
+
+        v += 1
+      end
+
+      alphabet
+    end
+
+    def hash(input, alphabet)
+      num = input.to_i
+      len = alphabet.length
+      res   = ""
+
+      begin
+        res = "#{alphabet[num % len]}#{res}"
+        num = num.div(alphabet.length)
+      end while num > 0
+
+      res
+    end
+
+    def unhash(input, alphabet)
+      num = 0
+
+      input.length.times do |i|
+        pos = alphabet.index(input[i])
+
+        raise InputError, "unable to unhash" unless pos
+
+        num += pos * alphabet.length ** (input.length - i - 1)
+      end
+
+      num
+    end
+
+    private
+
+    def setup_alphabet
+      validate_attributes
+
+      @alphabet = uniq_characters(alphabet)
+
+      validate_alphabet
+
+      setup_seps
+      setup_guards
+    end
+
+    def setup_seps
+      @seps = DEFAULT_SEPS
+
+      seps.length.times do |i|
+        # Seps should only contain characters present in alphabet,
+        # and alphabet should not contains seps
+        if j = alphabet.index(seps[i])
+          @alphabet = pick_characters(alphabet, j)
+        else
+          @seps = pick_characters(seps, i)
+        end
+      end
+
+      alphabet.delete!(' ')
+      seps.delete!(' ')
+
+      @seps = consistent_shuffle(seps, salt)
+
+      if seps.length == 0 || (alphabet.length / seps.length.to_f) > SEP_DIV
+        seps_length = (alphabet.length / SEP_DIV).ceil
+        seps_length = 2 if seps_length == 1
+
+        if seps_length > seps.length
+          diff = seps_length - seps.length;
+
+          @seps    += alphabet[0, diff]
+          @alphabet = alphabet[diff .. -1]
+        else
+          @seps = seps[0, seps_length]
+        end
+      end
+
+      @alphabet = consistent_shuffle(alphabet, salt)
+    end
+
+    def setup_guards
+      gc = (alphabet.length / GUARD_DIV).ceil
+
+      if alphabet.length < 3
+        @guards = seps[0, gc]
+        @seps   = seps[gc .. -1]
+      else
+        @guards   = alphabet[0, gc]
+        @alphabet = alphabet[gc .. -1]
+      end
+    end
+
+    SaltError       = Class.new(ArgumentError)
+    MinLengthError  = Class.new(ArgumentError)
+    AlphabetError   = Class.new(ArgumentError)
+    InputError      = Class.new(ArgumentError)
+
+    def validate_attributes
+      unless salt.kind_of?(String)
+        raise SaltError, "The salt must be a String"
+      end
+
+      unless min_hash_length.kind_of?(Fixnum)
+        raise MinLengthError, "The min length must be a Fixnum"
+      end
+
+      unless min_hash_length >= 0
+        raise MinLengthError, "The min length must be 0 or more"
+      end
+
+      unless alphabet.kind_of?(String)
+        raise AlphabetError, "The alphabet must be a String"
+      end
+
+      if alphabet.include?(' ')
+        raise AlphabetError, "The alphabet can’t include spaces"
+      end
+    end
+
+    def validate_alphabet
+      unless alphabet.length >= MIN_ALPHABET_LENGTH
+        raise AlphabetError, "Alphabet must contain at least " +
+            "#{MIN_ALPHABET_LENGTH} unique characters."
+      end
+    end
+
+    def hex_string?(string)
+      string.to_s.match(/\A[0-9a-fA-F]+\Z/)
+    end
+
+    def pick_characters(array, index)
+      array[0, index] + " " + array[index + 1 .. -1]
+    end
+
+    def uniq_characters(string)
+      string.split('').uniq.join('')
+    end
+  end
+end

data/lib/hashman/inclusion.rb

@@ -0,0 +1,62 @@
+require 'hashman/version'
+require 'active_support'
+
+module HashMan
+  module Inclusion
+    extend ActiveSupport::Concern
+
+    def hash_id
+      self.class.generate_hash_id(id)
+    end
+
+    # extend methods for class
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+
+      # generate the hash_id using the @magic_number declared in class
+      # id class === String || UUIDTools::UUID || Fixnum
+
+      def hash_length(number)
+        @magic_number = number
+      end
+
+      def generate_hash_id(id)
+        hasher.encode(rinse_id(id))
+      end
+
+      # reverse the has to get the original id
+      # if UUID, parse it and return the UUID object
+
+      def reverse_hash(hash)
+        id = hasher.decode(hash).try(:first)
+        (self.include? Dynamoid::Document) || (self.columns_hash["id"].type == :uuid) ? UUIDTools::UUID.parse_int(id) : id
+      end
+
+      private
+
+      def hasher
+        Hashman::Hasher.new("#{Rails.application.secrets.magic_number}", @magic_number || 4)
+      end
+
+      # standardize the id integer
+      # we do not specify UUIDTools since comparisons break!
+      # String (activeUUID tables), FixNum (normal ids), UUID (dynamoid/VideoClips)
+
+      def rinse_id(id)
+        case
+          when id.class == String
+            return UUIDTools::UUID.parse(id).to_i
+          when id.class == Fixnum
+            return id
+          else
+            return id.to_i
+        end
+      end
+
+    end
+
+  end
+end

data/lib/hashman/version.rb

@@ -0,0 +1,4 @@
+module HashMan
+  # hashman version
+  VERSION = "0.1.0"
+end

data/spec/hashman_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+require 'hashman'
+
+describe Hashman do
+  it "should have a VERSION constant" do
+    expect(subject.const_get('VERSION')).to_not be_empty
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'rspec'
+require 'hashman/version'
+
+include HashMan
+

metadata

@@ -0,0 +1,163 @@
+--- !ruby/object:Gem::Specification
+name: hashman
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Evan Surdam
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-07-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activeuuid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubygems-tasks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+description: HashMan takes any number (or uuid) and converts it to a unique hash.
+  Includes methods on your class to access and reverse hash
+email: es@cosi.io
+executables: []
+extensions: []
+extra_rdoc_files:
+- ChangeLog.md
+- LICENSE.txt
+- README.md
+files:
+- ".document"
+- ".gitignore"
+- ".rspec"
+- ".yardopts"
+- ChangeLog.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- gemspec.yml
+- hashman.gemspec
+- lib/.DS_Store
+- lib/hashman.rb
+- lib/hashman/hasher.rb
+- lib/hashman/inclusion.rb
+- lib/hashman/version.rb
+- spec/hashman_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/esurdam/hashman#readme
+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.5.1
+signing_key: 
+specification_version: 4
+summary: add some hash magic to your classes
+test_files: []