bson_minihash 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    OWY2OTRlM2MxODljZDQwNjQzNzAzODI4NDEyNGViZGVhYWY3OGMwYQ==
+  data.tar.gz: !binary |-
+    MWJhMWRiZDM5ZjlmNTA5Yzg4MTQ4ZjBjZTM2YjA0ZmM5MTc1MDU1Nw==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    MGNkODE3NWQ5ZWY4ZjU1MzM2NDk2OTdmZGQ1MDlhZjc2YTE1M2E1ZTIwYmZi
+    MmU3NDczNDEyMDRiYWI3NGRhMmExMDY5NjBlMjM5MjFlOGEzZmUxN2Q2MzEw
+    NDkxODUxMTg0YmQ2NWI2N2QzMWQ4YjJiODZkMjg3MmRmMjM5ZjM=
+  data.tar.gz: !binary |-
+    Y2Y2NzY3ZmQ1Y2YyYThkOTVmMDI0NGJkYWFiYzkwMjNhN2I4NjIzOGEyZDg3
+    NzU4NzIxOTY1ZTcxNmMxYzAyNzgzZDlkOGJlZTdjMTc4ZTA3ODE2MmRjYzBh
+    NGJhMjIxNTY2NDI1MGRhZWU2YmU4MzgwNTU3NjBmNzU0NjgzY2U=

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/.rspec

@@ -0,0 +1,3 @@
+--color
+--format documentation
+--tty

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :development, :test do
+  unless ENV["CI"]
+    gem "guard-rspec"
+  end
+end

data/Guardfile

@@ -0,0 +1,9 @@
+# vim:set filetype=ruby:
+guard(
+  "rspec",
+  :all_after_pass => false,
+  :cli => "--fail-fast --tty") do
+
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$}) { |match| "spec/#{match[1]}_spec.rb" }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Michael Shapiro
+
+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,104 @@
+# BSON MiniHash
+
+Compacts cryptographic hashes and other strings of limited charsets into blobs of BSON binary data, to reduce MongoDB storage and index size. Supports the vanilla Mongo driver, MongoMapper and Mongoid.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'bson_minihash'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install bson_minihash
+
+## Usage
+
+You need to require either the 'bson' (Mongo driver/MongoMapper) or 'moped' (Mongoid) libraries before using MiniHash, so it knows which library's binary object type to give you. If you're using MongoMapper or Mongoid, one of those libraries has already been loaded for you.
+
+### Digestion
+
+If you've got some data you want to digest, then pack into a minihash, `BSONMiniHash#digest(data, hash_type)` provides a shortcut to do so.
+
+    require 'mongo'
+    require 'bson_minihash'
+    
+    BSONMiniHash.digest("Geddy Lee", :md5)
+    #=> <BSON::Binary:70301078819340>
+
+`hash_type` can be either `:md5` or `:sha1`
+
+### Packing pre-existing hashes
+
+If you've already got a hash as a string (e.g. passed as a parameter to your web app), you can pack it into a minihash that's suitable for a `#find` operation by using `BSONMiniHash.pack(string, hash_type)`.
+
+    require 'mongo'
+    require 'bson_minihash'
+    
+    BSONMiniHash.pack('99f815bab7703b220c97feeca3ff9769', :md5)
+    #=> <BSON::Binary:70301087948100>
+
+`hash_type` can be `:md5`, `:sha1` or `:hex`
+
+It's best to pass the kind of hash you're using, minihash will do a little validation on the hash to make sure it fits the right character set and length. `:hex` just checks for the hex character range, without a length check, see the Caveats section below before using it.
+
+### Examples
+
+For examples of using minihashes in MongoDB, please see the `examples` direcotry.
+
+## How does it work?
+
+Have you ever wondered what the difference between `Digest::SHA1.digest` and `Digest::SHA1.hexdigest` is?
+
+    str = "Geddy Lee"
+
+    Digest::SHA1.digest(str).length
+    #=> 20
+    
+    Digest::SHA1.hexdigest(str).length
+    #=> 40
+
+They both contain the same information, except `#digest` uses only the space that it needs to represent the hash. SHA1 and MD5 both use different length combinations of only sixteen characters (hex) to represent their hashes. A nibble (half a byte, four bits), is enough room to store one of those character.
+
+`#hexdigest` gives a UTF-8 string, which uses a byte per character when relegated to the ASCII range, double the amount needed.
+
+So we convert each character in the hash to its actual hex value:
+
+    Digest::SHA1.hexdigest(str).split('').collect(&:hex)
+    #=> [3, 14, 10, 10, 12, 14, 9, 0, 14, 5, 5, 2, 6, 14, 5, 10, 12, 12, 9, 6, 15, 1, 13, 6, 13, 11, 1, 4, 6, 11, 0, 14, 13, 4, 0, 1, 12, 2, 15, 14]
+
+Then pack them together into a new string, treating each number as a nibble:
+
+    Digest::SHA1.hexdigest(str).split('').collect(&:hex).in_groups_of(2).collect{|n| (n.first << 4) + n.last }.pack("C*")
+    #=> ">\xAA\xCE\x90\xE5RnZ\xCC\x96\xF1\xD6\xDB\x14k\x0E\xD4\x01\xC2\xFE"
+    
+That's a roundabout way of emulating `#digest` :)
+
+    Digest::SHA1.digest(str)
+    #=> ">\xAA\xCE\x90\xE5RnZ\xCC\x96\xF1\xD6\xDB\x14k\x0E\xD4\x01\xC2\xFE"
+
+Or, we could use the handy "hex" format of `Array#pack`, which is what minihash does.
+
+    [Digest::SHA1.hexdigest(str)].pack('H*')
+    # => ">\xAA\xCE\x90\xE5RnZ\xCC\x96\xF1\xD6\xDB\x14k\x0E\xD4\x01\xC2\xFE"
+
+## Efficiency
+
+In MongoDB, you should see about a factor of two space saving for the minihash fields. Of course, you're spending some CPU power to pack the fields, but it's not much.
+
+## Caveats
+In MongoDB, it's not a great idea to use hashes as unique indexes, since there's always the possiblity of collisions.
+
+If you choose to `#pack` a string with the `:hex` type, beware that an odd-length string will have an extra nibble at the end, since a byte is the smallest unit of allocation.
+
+## 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

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new
+
+task :default => :spec
+task :test => :spec

data/bson_minihash.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'bson_minihash/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "bson_minihash"
+  spec.version       = BSONMiniHash::VERSION
+  spec.authors       = ["Michael Shapiro"]
+  spec.email         = ["koudelka@ryoukai.org"]
+  spec.summary       = "Stores hashes in a BSON 'packed' format."
+  spec.description   = "Saves space by storing strings with limited character sets as packed BSON BinData."
+  spec.homepage      = 'https://github.com/koudelka/bson_minihash'
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+
+  spec.add_development_dependency "mongo"
+  spec.add_development_dependency "bson_ext"
+  spec.add_development_dependency "moped"
+end

data/examples/mongo.rb

@@ -0,0 +1,21 @@
+require 'mongo'
+require 'bson_minihash'
+
+collection = Mongo::Connection.new('127.0.0.1', 27017).db('test').collection('artists')
+
+# Digestion
+mini_hash = BSONMiniHash.digest("Syd Vicious", :md5)
+p mini_hash
+collection.insert(name: "Syd Vicious", hash: mini_hash)
+doc = collection.find_one(hash: mini_hash)
+p doc
+
+# Packing a hash you already have
+mini_hash = BSONMiniHash.pack("3eaace90e5526e5acc96f1d6db146b0ed401c2fe", :sha1)
+collection.insert(name: "Geddy Lee", hash: mini_hash)
+doc = collection.find_one(hash: mini_hash)
+p doc
+
+
+# Unpacking a mini hash
+p BSONMiniHash.unpack(doc['hash'])

data/examples/moped.rb

@@ -0,0 +1,21 @@
+require 'moped'
+require 'bson_minihash'
+
+session = Moped::Session.new([ "127.0.0.1:27017" ])
+session.use "test"
+
+# Digestion
+mini_hash = BSONMiniHash.digest("Syd Vicious", :md5)
+session[:artists].insert(name: "Syd Vicious", hash: mini_hash)
+doc = session[:artists].find(hash: mini_hash).first
+p doc
+
+# Packing a hash you already have
+mini_hash = BSONMiniHash.pack("3eaace90e5526e5acc96f1d6db146b0ed401c2fe", :sha1)
+session[:artists].insert(name: "Geddy Lee", hash: mini_hash)
+doc = session[:artists].find(hash: mini_hash).first
+p doc
+
+
+# Unpacking a mini hash
+p BSONMiniHash.unpack(doc['hash'])

data/lib/bson_minihash/hex.rb

@@ -0,0 +1,40 @@
+require 'digest'
+
+module BSONMiniHash
+  module Hex
+    FORMAT = 'H*'.freeze
+    TYPES = [:md5, :sha1, :hex].freeze
+
+    def self.pack(str, type = :hex)
+      Hex.validate(str, type)
+      [str].pack(FORMAT)
+    end
+
+    def self.unpack(packed_str)
+      packed_str.unpack(FORMAT).first
+    end
+
+    def self.validate(str, type)
+      raise ArgumentError, "Hex strings must comprise of characters between a-f and 0-9" unless str.match /^[a-f0-9]+$/i
+
+      case type
+        when :md5
+          raise ArgumentError, "MD5 strings must be 32 characters in length" unless str.length == 32
+        when :sha1
+          raise ArgumentError, "SHA1 strings must be 40 characters in length" unless str.length == 40
+      end
+      true
+    end
+
+    def self.digest(data, type)
+      case type
+        when :md5
+          Digest::MD5.digest(data)
+        when :sha1
+          Digest::SHA1.digest(data)
+        else
+          raise ArgumentError, "type #{type} not supported"
+      end
+    end
+  end
+end

data/lib/bson_minihash/version.rb

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

data/lib/bson_minihash.rb

@@ -0,0 +1,73 @@
+module BSONMiniHash
+
+  def self.bson_lib
+    case
+      when Kernel.const_defined?(:Moped) # Mongoid
+        :moped
+      when Kernel.const_defined?(:BSON) # Mongo driver (incliding MongoMapper)
+        :bson
+      else 
+        raise "In order to use BSONMiniHash, you need to have either the 'bson' or 'moped' gem loaded"
+    end
+  end
+
+  #
+  # Beware, if you're not using SHA1, MD5 or any other hash with a length divisible by two,
+  # you'll get a zero padded string when doing a round trip as the packed string will have
+  # an extra nibble of space at the end.
+  #
+  def self.pack(str, type = :hex)
+    str = str.downcase.strip
+
+    packed_str = \
+      case
+        when Hex::TYPES.include?(type)
+          Hex.pack(str, type)
+        else
+          raise ArgumentError, "type #{type} not supported"
+      end
+
+    bson_obj(packed_str)
+  end
+
+  def self.digest(data, type)
+    packed_str = \
+      case
+        when Hex::TYPES.include?(type)
+          Hex.digest(data, type)
+        else
+          raise ArgumentError, "type #{type} not supported"
+      end
+
+    bson_obj(packed_str)
+  end
+
+  def self.unpack(packed_obj, type = :hex)
+    #
+    # Both BSON and Moped give the right thing for to_s
+    #
+    packed_str = packed_obj.to_s
+
+    case
+      when Hex::TYPES.include?(type)
+        Hex.unpack(packed_str)
+      else
+        raise ArgumentError, "type #{type} not supported"
+    end
+  end
+
+  private
+
+    def self.bson_obj(packed_str)
+      case self.bson_lib
+        when :bson
+          BSON::Binary.new(packed_str)
+        when :moped
+          Moped::BSON::Binary.new(:user, packed_str)
+      end
+    end
+
+end
+
+require "bson_minihash/version"
+require "bson_minihash/hex"

data/spec/bson_minihash/bson_minihash_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe BSONMiniHash do
+
+  #
+  # These test only pass becauseof the order in which they're writting. It sucks.
+  #
+  # I don't see another way to do this, since there's no way to remove a module
+  # from the global namespace once it's been added.
+  #
+
+  context "No BSON Library" do
+    it "should throw an error" do
+      expect {
+        BSONMiniHash.pack('a')
+      }.to raise_error(RuntimeError)
+    end
+  end
+
+  context "BSON" do
+    it "should detect when the BSON library (mongo driver / mongomapper) is in use" do
+      require 'bson'
+      BSONMiniHash.bson_lib.should == :bson
+    end
+
+    context "packing" do
+      it "should create a binary object of the right class" do
+        BSONMiniHash.pack('a').class.should == BSON::Binary
+      end
+    end
+
+    it "should have the same value through a pack/unpack roundtrip" do
+      str = "abcdef1234567890"
+      BSONMiniHash.unpack(BSONMiniHash.pack(str)).should == str
+    end
+
+    context "digestion" do
+      it "should create a binary object of the right class" do
+        BSONMiniHash.digest('a', :md5).class.should == BSON::Binary
+      end
+
+      it "should properly digest" do
+        str = 'abcdefghijklmnop1235'
+        BSONMiniHash.digest(str, :md5).to_s.should == Digest::MD5.digest(str)
+      end
+
+      it "should have the right value through a digest/unpack roundtrip" do
+        str = "abcdef1234567890"
+        BSONMiniHash.unpack(BSONMiniHash.digest(str, :sha1)).should == Digest::SHA1.hexdigest(str)
+      end
+    end
+  end
+
+  context "Moped" do
+    it "should detect when the Moped library (mongoid) is in use" do
+      require 'moped'
+      BSONMiniHash.bson_lib.should == :moped
+    end
+
+    context "packing" do
+      it "should create a binary object of the right class" do
+        BSONMiniHash.pack('a').class.should == Moped::BSON::Binary
+      end
+    end
+
+    it "should have the same value through a pack/unpack roundtrip" do
+      str = "abcdef1234567890"
+      BSONMiniHash.unpack(BSONMiniHash.pack(str)).should == str
+    end
+
+    context "digestion" do
+      it "should create a binary object of the right class" do
+        BSONMiniHash.digest('a', :md5).class.should == Moped::BSON::Binary
+      end
+
+      it "should properly digest" do
+        str = 'abcdefghijklmnop1235'
+        BSONMiniHash.digest(str, :md5).to_s.should == Digest::MD5.digest(str)
+      end
+
+      it "should have the right value through a digest/unpack roundtrip" do
+        str = "abcdef1234567890"
+        BSONMiniHash.unpack(BSONMiniHash.digest(str, :sha1)).should == Digest::SHA1.hexdigest(str)
+      end
+    end
+  end
+
+end

data/spec/bson_minihash/hex_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe BSONMiniHash::Hex do
+
+  context "Packing" do
+    it "should correctly pack a hex string" do
+      str = "7e240de74fb1ed08fa08d38063f6a6a91462a815"
+      packed_str = "~$\r\xE7O\xB1\xED\b\xFA\b\xD3\x80c\xF6\xA6\xA9\x14b\xA8\x15"
+      BSONMiniHash::Hex.pack(str).should == packed_str
+    end
+
+    it "should correctly unpack a hex string" do
+      str = "7e240de74fb1ed08fa08d38063f6a6a91462a815"
+      packed_str = "~$\r\xE7O\xB1\xED\b\xFA\b\xD3\x80c\xF6\xA6\xA9\x14b\xA8\x15"
+      BSONMiniHash::Hex.unpack(packed_str).should == str
+    end
+
+    it "should correctly roundtrip a hex string" do
+      unpacked_str = "7e240de74fb1ed08fa08d38063f6a6a91462a815"
+      BSONMiniHash::Hex.unpack(BSONMiniHash::Hex.pack(unpacked_str)).should == unpacked_str
+
+      packed_str = "~$\r\xE7O\xB1\xED\b\xFA\b\xD3\x80c\xF6\xA6\xA9\x14b\xA8\x15"
+      BSONMiniHash::Hex.pack(BSONMiniHash::Hex.unpack(packed_str)).should == packed_str
+    end
+  end
+
+  context "Validation" do
+    it "should fail when the character set isn't in hex" do
+      str = Digest::MD5.hexdigest("a")
+      str[0] = 'g'
+      expect { BSONMiniHash::Hex.validate(str, :md5) }.to raise_error(ArgumentError)
+    end
+
+    context "MD5" do
+      it "should pass for a correctly formatted MD5" do
+        BSONMiniHash::Hex.validate(Digest::MD5.hexdigest("a"), :md5).should be_true
+      end
+
+      it "should fail when the length is other than 32" do
+        str = Digest::MD5.hexdigest("a")
+        expect { BSONMiniHash::Hex.validate(str[1..-1], :md5) }.to raise_error(ArgumentError)
+      end
+    end
+
+    context "SHA1" do
+      it "should pass for a correctly formatted SHA1" do
+        BSONMiniHash::Hex.validate(Digest::SHA1.hexdigest("a"), :sha1).should be_true
+      end
+
+      it "should fail when the length is other than 40" do
+        str = Digest::SHA1.hexdigest("a")
+        expect { BSONMiniHash::Hex.validate(str[1..-1], :sha1) }.to raise_error(ArgumentError)
+      end
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+require 'bson_minihash'
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  #config.order = 'random'
+end

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: bson_minihash
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Michael Shapiro
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mongo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bson_ext
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: moped
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Saves space by storing strings with limited character sets as packed
+  BSON BinData.
+email:
+- koudelka@ryoukai.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bson_minihash.gemspec
+- examples/mongo.rb
+- examples/moped.rb
+- lib/bson_minihash.rb
+- lib/bson_minihash/hex.rb
+- lib/bson_minihash/version.rb
+- spec/bson_minihash/bson_minihash_spec.rb
+- spec/bson_minihash/hex_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/koudelka/bson_minihash
+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.0.3
+signing_key: 
+specification_version: 4
+summary: Stores hashes in a BSON 'packed' format.
+test_files:
+- spec/bson_minihash/bson_minihash_spec.rb
+- spec/bson_minihash/hex_spec.rb
+- spec/spec_helper.rb