bit_hash 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,14 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+gem "to_insane", ">=0.2.1"
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "shoulda", ">= 0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.2"
+  gem "rcov", ">= 0"
+  gem "rspec"
+end

data/Gemfile.lock

@@ -0,0 +1,32 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.2)
+    git (1.2.5)
+    jeweler (1.5.2)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.8.7)
+    rcov (0.9.9)
+    rspec (2.5.0)
+      rspec-core (~> 2.5.0)
+      rspec-expectations (~> 2.5.0)
+      rspec-mocks (~> 2.5.0)
+    rspec-core (2.5.1)
+    rspec-expectations (2.5.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.5.0)
+    shoulda (2.11.3)
+    to_insane (0.2.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.5.2)
+  rcov
+  rspec
+  shoulda
+  to_insane (>= 0.2.1)

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Ryan Ong
+
+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.rdoc

@@ -0,0 +1,97 @@
+= bit_hash
+
+A simple class that can convert an option hash into a compact string.
+
+== Usage
+
+When writing these config maps. Try to put the mose used options first so the string can be shorter.
+
+  require 'rubygems'
+  require 'bit_hash'
+
+  config_map = [
+    {
+      :name => :air,    # name of option
+      :options => 2,    # number of options must be 2 or greater
+    },
+    {
+      :name => :color, 
+      :options => ['blue','green','red']    # bit_hash can map arrays of data, the default setting will be the first value in the array
+    },
+    {
+      :name => :body_style, 
+      :options => [:sedan,:mini_van,:suv],  # Array values can be anything that can be found using the Array#index function
+      :default => :mini_van                 # for arrays the default is any array value
+    },
+    {
+      :name => :transmission,     # name of option
+      :options => 6,
+      :default => 5               # for numbers the default must be between 0 and the options value
+    },
+    {
+      :name => :min_price,
+      :options => (50..100).to_a, # ( just a way to store ranges of numbers)
+      :default => 60              # basically any default can be used as long as it is a valid option
+    },
+    {
+      :name => :max_price,
+
+      # intervals of 20 starting at 10000 (just a way to store ranges of numbers)
+      :options => (1..5).to_a.map {|n| 10000+(n*20)},
+
+      # you can use :default_index option to reference something in the option arrays but it really isn't suggested, :default take precedence
+      :default_index =>  2
+      }
+  ]
+
+  # initialize
+  @config = BitHash.new(config_map)
+  
+  # set a single value
+  @config[:color]='red'
+
+  # get a value
+  @config[:value]
+  
+  # replace values in config with another hash
+  @config.replace({:air=>1})
+
+  # parse a string without saving
+  @config.parse('e')
+
+  # parse a string and save it
+  @config.save
+
+  # convert to small compact string
+  @config.to_s
+
+== TODO
+
+* Impliment more tests
+* Clone more Hash functions
+* Storage of strings
+* If binary options and default 1, user inverse
+* allow a hash for config_map for ruby 1.9
+* Add some sort of ActiveRecord extender
+
+== Contributing to bit_hash
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Credits
+
+Ryan Ong - ryanong@gmail.com
+
+Developed for and with CarZen[link:http://carzen.com]
+
+== Copyright
+
+Copyright (c) 2011 Ryan Ong. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,49 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "bit_hash"
+  gem.homepage = "http://github.com/ryanong/bit_hash"
+  gem.license = "MIT"
+  gem.summary = %Q{bit_hash allows you to serialize simple set data into short compact URL safe strings.}
+  gem.description = %Q{bit_hash is a useful tool to pass through options through a string. The best usecases would be forms with binary,trinary, etc etc data sets.}
+  gem.email = "ryanong@gmail.com"
+  gem.authors = ["Ryan Ong"]
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "bit_hash #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/bit_hash.gemspec

@@ -0,0 +1,70 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{bit_hash}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Ryan Ong"]
+  s.date = %q{2011-02-16}
+  s.description = %q{bit_hash is a useful tool to pass through options through a string. The best usecases would be forms with binary,trinary, etc etc data sets.}
+  s.email = %q{ryanong@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "bit_hash.gemspec",
+    "lib/bit_hash.rb",
+    "spec/bit_hash_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/ryanong/bit_hash}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.5.0}
+  s.summary = %q{bit_hash allows you to serialize simple set data into short compact URL safe strings.}
+  s.test_files = [
+    "spec/bit_hash_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<to_insane>, [">= 0.2.1"])
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+    else
+      s.add_dependency(%q<to_insane>, [">= 0.2.1"])
+      s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+      s.add_dependency(%q<rspec>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<to_insane>, [">= 0.2.1"])
+    s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+    s.add_dependency(%q<rspec>, [">= 0"])
+  end
+end
+

data/lib/bit_hash.rb

@@ -0,0 +1,272 @@
+require 'to_insane'
+
+class BitHash
+
+  attr_accessor :options, :default
+  # look below at load_config_map for config_map schema
+  # base is the base value you want to use. Defaults to a URL safe character base which is 63
+  # character set can also be changed but not really necessary. read to_insane doc for more details
+  def initialize(config_map=nil, *options)
+    load_options(options)
+    @config = Hash.new
+    @default = Hash.new
+    #validate mapping
+    load_config_map(config_map) if config_map.kind_of? Array
+    @config
+  end
+
+  #Example config_map
+  #
+  #  config_map = [
+  #  {
+  #    :name => :air,    # name of option
+  #    :options => 2,    # number of options must be 2 or greater
+  #  },
+  #  {
+  #    :name => :color, 
+  #    :options => ['blue','green','red']    # bit_hash can map arrays of data, the default setting will be the first value in the array
+  #  },
+  #  {
+  #    :name => :body_style, 
+  #    :options => [:sedan,:mini_van,:suv],  # Array values can be anything that can be found using the Array#index function
+  #    :default => :mini_van                 # for arrays the default is any array value
+  #  },
+  #  {
+  #    :name => :transmission,     # name of option
+  #    :options => 6,
+  #    :default => 5               # for numbers the default must be between 0 and the options value
+  #  },
+  #  {
+  #    :name => :min_price,
+  #    :options => (50..100).to_a, # ( just a way to store ranges of numbers)
+  #    :default => 60              # basically any default can be used as long as it is a valid option
+  #  },
+  #  {
+  #    :name => :max_price,
+
+  #    # intervals of 20 starting at 10000 (just a way to store ranges of numbers)
+  #    :options => (1..5).to_a.map {|n| 10000+(n*20)},
+
+  #    # you can use :default_index option to reference something in the option arrays but it really isn't suggested, :default take precedence
+  #    :default_index =>  2
+  #    }
+  #  ]
+  def load_config_map(config_map)
+    raise ArgumentError, "Config Map must be an Array" unless config_map.kind_of? Array
+    config_array = []
+    new_config = {}
+    config_map.each_index do |index|
+      conf = config_map[index]
+      raise ArgumentError, "#{conf[:name]} is a duplicate" if new_config.keys.index(conf[:name])
+      new_config[conf[:name]] = get_check_config(index,conf)
+      config_array[index] = conf 
+    end
+    @config = new_config.dup
+    @default = new_config.dup
+    @config_map = config_array
+  end
+
+  # Just get a list of keys
+  def keys
+    @config_map.map{ |c| c[:name]}
+  end
+
+  # Set default key
+  def set_default(key)
+    conf = get_options(key)
+    @config[conf[:name]] = 0
+    if !conf[:default].nil?
+      new_config[conf[:name]] = conf[:default]
+    elsif !conf[:default_index].nil?
+      new_config[conf[:name]] = conf[:options][conf.default_index]
+    end
+  end
+
+  # see set
+  def []=(key,value)
+    set(key,value)
+  end
+
+  # sets a key value, returns nil if value is invalid
+  def set(key,value)
+    conf = get_options(key)
+    if conf && check_value(conf,value)
+      @config[key] = value
+    else
+      nil
+    end
+  end
+
+  # sets with critical failure
+  def set!(key,value)
+    conf = get_options(key)
+    if conf && check_value!(conf,value)
+      @config[key] = value
+    else
+      raise ArgumentError, "Key: '#{key}' not found in config"
+    end
+  end
+
+  # fetches values for given key
+  def [](key)
+    @config[key]
+  end
+
+  # replaces internal settings with  any given hash and overwrites values and returns hash. On failure returns nil
+  def replace(hash)
+    cache = @config.dup
+    hash.each do |key, value|
+      if set(key,value).nil?
+        @config = cache
+        return nil
+      end
+    end
+    @config
+  end
+
+  # returns option settings for given key
+  def get_options(key)
+    index = @config_map.index{|x|x[:name]==key}
+    (index) ? @config_map[index].merge({:index => index}) : nil
+  end
+
+  # replaces given option with name of key and replaces with options
+  def replace_options(key, options)
+    @config_map.map! do |conf|
+      if conf[:name] == key
+        options
+      else
+        conf
+      end
+    end
+  end
+  
+  # takes a given config string and returns a mapped hash
+  # please read to_insane doc for info on base and char_set
+  def parse(config_string, *options)
+    load_options(options)
+    raise ArgumentError, "Prefix must be a string" if !@options[:prefix].nil? && !@options[:prefix].kind_of?(String)
+    config_string[0..@options[:prefix].size] = nil unless @options[:prefix].nil?
+    config_string = config_string.from_insane(@options[:base],@options[:char_set]).to_s(2)
+    config_array = config_string.split('')
+    new_config = @default.dup
+    @config_map.each do |conf|
+      value = config_array.pop(conf[:size])
+      break if value.nil?
+      value = value.join('').to_i(2)
+      new_config[conf[:name]] = (conf[:options].kind_of? Array ) ? conf[:options][value] : value
+    end
+    new_config
+  end
+
+  # pareses and saves string into internal hash
+  def save(config_string, *options)
+    @config = parse(config_string, *options)
+  end
+
+  #converts it into a binary string
+  def to_bin
+    bin_config = []
+    @config_map.each do |conf|
+      val = @config[conf[:name]]
+      val = conf[:options].index(val) if conf[:options].kind_of? Array
+      bin = "%0#{conf[:size]}d" % val.to_s(2).to_i
+      bin_config.unshift(bin)
+    end
+    bin_config.join('')
+  end
+  
+  #converts it to an integer, Good for IDs
+  def to_i
+    to_bin.to_i(2)
+  end
+
+  # turns hash into a small compact string.
+  # see to_insane rdoc for base, and char_set definitions
+  def to_s(*options)
+    load_options(options)
+    str = ''
+    str << @options[:prefix] if @options[:prefix].kind_of? String
+    str << to_i.to_insane(@options[:base], @options[:char_set])
+    str
+  end
+
+  #checks key to see if value given is valid
+  def valid_value?(key,val)
+    check_value(get_options(key),val)
+  end
+
+  alias_method :to_hash, :inspect 
+
+  # returns as a hash (alias: inspect)
+  def to_hash
+    @config
+  end
+
+  private
+
+  # checks value against given config
+  def check_value(conf,val)
+    if conf[:options].kind_of?(Array)
+      return false if conf[:options].index(val).nil?
+    elsif conf[:options].kind_of?(Integer) && val.kind_of?(Integer)
+      return false if val < 0 or val > conf[:options]
+    else
+      return false
+    end
+    true
+  end
+
+  # checks values with a bang
+  def check_value!(conf,val)
+    if conf[:options].kind_of? Array
+      raise ArgumentError, "#{conf[:name]} is #{val} and is not a valid value within the stored array. #{conf[:options].to_s}" if conf[:options].index(val).nil?
+    elsif conf[:options].kind_of? Integer
+      raise ArgumentError, "#{conf[:name]} is #{val} and should not be less than 0" if val < 0
+      raise ArgumentError, "#{conf[:name]} is #{val} and value is not less than #{conf[:options]}" if val > conf[:options]
+    else
+      raise ArgumentError, "#{conf[:name]} is not a valid value please associate it with an object in an array or give it an integer value" 
+    end
+    true
+  end
+  
+  def load_options(options)
+    if options.kind_of? Array
+      @options = {:base => options[0], :char_set => options[1]}
+    elsif options.kind_of? Hash
+      @options = options
+    end
+    @options[:base] ||= :url_safe
+    @options[:char_set] ||= nil
+    @options[:prefix] ||= nil
+  end
+
+  def get_check_config(key,conf)
+    raise ArgumentError, "config is not a Hash" unless conf.kind_of? Hash
+    raise ArgumentError, ":name cannot be nil for [#{key}]" if conf[:name].nil?
+    raise ArgumentError, ":options cannot be nil for [#{key}]" if conf[:options].nil?
+    if conf[:options].kind_of? Integer
+      conf[:size] = conf[:options]
+    elsif conf[:options].kind_of? Array
+      conf[:size] = conf[:options].size
+    elsif conf[:options].kind_of? Symbol || conf[:options].kind_of?(String)
+      raise ArgumentError, ":options Character set cannot have duplicate characters" if conf[:options].kind_of?(String) && (conf[:options].size != conf[:options].split(//).uniq.size)
+      raise ArgumentError, ":options"
+      raise ArgumentError, ":size needs to be an integer larger than 0 [#{conf[:name]}]" unless conf[:size].kind_of? Integer and conf[:size] > 0
+    else
+      raise ArgumentError, ":options needs to be an Array or Integer for [#{conf[:name]}]" 
+    end
+    if !conf[:default].nil?
+      raise ArgumentError, "default value of (#{conf[:default]}) is not valid for #{conf[:name]}" unless check_value(conf,conf[:default])
+      default = conf[:default]
+    elsif !conf[:default_index].nil?
+      raise ArgumentError, ":default_index must be an integer #{conf[:name]}" unless conf[:default_index].kind_of? Integer
+      unless default = conf[:options][conf[:default_index]]
+        raise ArgumentError, ":default_index must be a valid option array index #{conf[:name]}"
+      end
+    end
+    conf[:size] = (conf[:size]-1).to_s(2).size
+    default ||= (conf[:options].kind_of? Integer) ? 0 : conf[:options][0]
+  end
+end
+

data/spec/bit_hash_spec.rb

@@ -0,0 +1,104 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe BitHash do
+
+  before(:each) do
+    @config_map = [
+      { :name=> 'min_price_cents', :options => [1000000,1500000,2000000,3000000,3500000,4000000,4500000,5000000,5500000,6000000,6500000,7000000] },
+      { :name=> 'max_price_cents', :options => [1500000,2000000,3000000,3500000,4000000,4500000,5000000,5500000,6000000,6500000,7000000,8000000] },
+      { :name=> 'segment_1', :options => 2},
+      { :name=> 'segment_2', :options => 2},
+      { :name=> 'segment_3', :options => 2},
+      { :name=> 'segment_4', :options => 2},
+      { :name=> 'segment_5', :options => 2},
+      { :name=> 'segment_6', :options => 2},
+      { :name=> 'segment_7', :options => 2},
+      { :name=> 'segment_8', :options => 2},
+      { :name=> 'segment_9', :options => 2},
+      { :name=> 'brand_pref_acura', :options => 3},
+      { :name=> 'brand_pref_aston_martin', :options => 3},
+      { :name=> 'brand_pref_audi', :options => 3},
+      { :name=> 'brand_pref_bentley', :options => 3},
+      { :name=> 'brand_pref_bmw', :options => 3},
+      { :name=> 'brand_pref_buick', :options => 3},
+      { :name=> 'brand_pref_cadillac', :options => 3},
+      { :name=> 'brand_pref_chevrolet', :options => 3},
+      { :name=> 'brand_pref_chrysler', :options => 3},
+      { :name=> 'brand_pref_dodge', :options => 3},
+      { :name=> 'brand_pref_ferrari', :options => 3},
+      {
+      :name => :air,    # name of option
+      :options => 2,    # number of options must be 2 or greater
+    },
+    {
+      :name => :color, 
+      :options => ['blue','green','red']    # bit_hash can map arrays of data, the default setting will be the first value in the array
+    },
+      {
+      :name => :body_style, 
+      :options => [:sedan,:mini_van,:suv],  # Array values can be anything that can be found using the Array#index function
+      :default => :mini_van                 # for arrays the default is any array value
+    },
+      {
+      :name => :transmission,     # name of option
+      :options => 6,
+      :default => 5               # for numbers the default must be between 0 and the options value
+    },
+      {
+      :name => :min_price,
+      :options => (50..100).to_a, # ( just a way to store ranges of numbers)
+      :default => 60              # basically any default can be used as long as it is a valid option
+    },
+      {
+      :name => :max_price,
+      # intervals of 20 starting at 10000 (just a way to store ranges of numbers)
+      :options => (1..5).to_a.map {|n| 10000+(n*20)},
+      # you can use :default_index option to reference something in the option arrays but it really isn't suggested, :default take precedence
+      :default_index =>  2
+    }
+    ]
+    @config = BitHash.new(@config_map)
+  end
+
+  it "should raise an error if config lacks name" do
+    BitHash.new(@config_map).should_not be_nil
+  end
+
+  it "should raise an error if config lacks name" do
+    @config_map[0].delete(:name)
+    lambda { BitHash.new(@config_map) }.should raise_error(ArgumentError)
+  end
+
+  it "should be able to get keys" do
+    @config.keys.should be_a Array
+  end
+
+  it "should have load same config" do
+    @config.parse(@config.to_s).should eql(@config.to_hash)
+  end
+
+  it "should output equal it self after being converted and parsed" do
+    str = @config.to_s
+    bin = @config.to_bin
+    @config.save(str)
+    bin.should eql(@config.to_bin)
+  end
+
+  it "settings should change" do
+    old = @config.to_s
+    @config.set!(:color,'red')
+    @config[:color].should eql('red')
+  end
+
+  it "should have different string if settings change" do
+    @new = BitHash.new(@config_map)
+    @config[:color]= 'red'
+    @config[:body_style]= :suv
+    @config[:air]= 1
+    @new.save(@config.to_s)
+    @new[:body_style].should eql(:suv)
+    @new[:air].should eql(1)
+    @new[:color].should eql('red')
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'bit_hash'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification 
+name: bit_hash
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Ryan Ong
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-16 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: to_insane
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.5.2
+  type: :development
+  prerelease: false
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id006
+description: bit_hash is a useful tool to pass through options through a string. The best usecases would be forms with binary,trinary, etc etc data sets.
+email: ryanong@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- .document
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- bit_hash.gemspec
+- lib/bit_hash.rb
+- spec/bit_hash_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/ryanong/bit_hash
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 59358543
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.0
+signing_key: 
+specification_version: 3
+summary: bit_hash allows you to serialize simple set data into short compact URL safe strings.
+test_files: 
+- spec/bit_hash_spec.rb
+- spec/spec_helper.rb