bit_mask 0.0.1

data/.document

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

data/.rspec

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

data/Gemfile

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

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,89 @@
+= bit_mask
+
+A simple class that allows you to store data in a bit mask. It automagically manages bit sizes and base conversion of binary bitmask.
+
+== Usage
+
+When writing these config maps. Try to put the mose used options first so the string can be shorter.
+
+  require 'rubygems'
+  require 'bit_mask'
+  class SearchParams < BitMask
+
+    # first set base defaults is 62
+    # Integer up to 62
+    set_base 62
+
+    field :air, :values => 2,    # number of options must be 2 or greater
+    field :color, :values => ['blue','green','red']  # bit_mask can map arrays of data, the default setting will be the first value in the array
+    field :body_style,  :values => [:sedan,:mini_van,:suv]  # Array values can be anything that can be found using the Array#index function
+    field :transmission,:values => 6,
+    field :min_price, :values => (50..100).to_a # ( just a way to store ranges of numbers)
+    field :max_price, :values => (1..5).to_a.map {|n| 10000+(n*20)},
+
+    # overwrite default accessors
+
+    def body_style=(value)
+      self.write_attribute(:body_style,value).to_sym
+    end
+
+    def body_style
+      self.read_attribute(:body_style).to_s
+    end
+
+  end
+
+  # initialize
+  @search = SearchParams.new
+
+  # set a single value
+  @search[:color]='red'
+  @search.color = 'red'
+
+  # get a single value
+  @search.color # the same as @search[:color]
+
+  # replace values in config with another hash
+  @search.replace({:air=>1})
+
+  # convert to small compact string
+  @search.to_s
+  @search.to_s(36) # choose base different from default
+  @search.to_s('asldkfjv') # use custom character sets for encoding
+  @search.dump
+
+  # load
+  SearchParams.load(@search.dump)
+  SearchParams.load(@search.to_s(36),36) # load from different base
+  SearchParams.load(@search.to_s('asldkfjv'),'asldkfjv')
+
+
+
+== TODO
+
+* Impliment more tests
+* Storage of strings?
+* If binary options and default 1, user inverse
+* create javascript version for easy communication between ruby and javascript
+
+== Contributing to bit_mask
+
+* 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_mask"
+  gem.homepage = "http://github.com/ryanong/bit_hash"
+  gem.license = "MIT"
+  gem.summary = %Q{bit_mask allows you to serialize/bitmask simple data sets into short compact ascii strings.}
+  gem.description = %Q{bit_mask creates a simple api to create bit mask models. By bit masking dataing you can compress the amount of data that needs to be sent between servers and clients}
+  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_mask #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/bit_mask.gemspec

@@ -0,0 +1,73 @@
+# 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_mask}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = [%q{Ryan Ong}]
+  s.date = %q{2011-07-18}
+  s.description = %q{bit_mask creates a simple api to create bit mask models. By bit masking dataing you can compress the amount of data that needs to be sent between servers and clients}
+  s.email = %q{ryanong@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "bit_mask.gemspec",
+    "lib/bit_mask.rb",
+    "spec/bit_mask_spec.rb",
+    "spec/models/car_search.rb",
+    "spec/models/dealership_search.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/ryanong/bit_hash}
+  s.licenses = [%q{MIT}]
+  s.require_paths = [%q{lib}]
+  s.rubygems_version = %q{1.8.5}
+  s.summary = %q{bit_mask allows you to serialize/bitmask simple data sets into short compact ascii strings.}
+  s.test_files = [
+    "spec/bit_mask_spec.rb",
+    "spec/models/car_search.rb",
+    "spec/models/dealership_search.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<activesupport>, [">= 0"])
+      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<activesupport>, [">= 0"])
+      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<activesupport>, [">= 0"])
+    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_mask.rb

@@ -0,0 +1,232 @@
+require 'active_support/core_ext/class/attribute'
+
+class BitMask
+  CHARACTER_SET = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ'
+  class_attribute :fields, :defaults, :base
+  def self.inherited(sub)
+    sub.fields = []
+    sub.defaults = {}
+    sub.base = 62
+  end
+
+  def initialize(args = {})
+    self.replace(self.defaults.merge(args))
+  end
+
+  def replace(args)
+    args.each do |field,value|
+      self[field]= value
+    end
+  end
+
+  alias_method :attributes=, :replace
+
+  def [](field)
+    raise "#{field} is an invalid key" unless self.class.keys.include? field.to_sym
+    self.send(field)
+  end
+
+  def []=(field,value)
+    raise "#{field} is an invalid key" unless self.class.keys.include? field.to_sym
+    self.send("#{field}=",value)
+  end
+
+  def read_attribute(key)
+    self.instance_variable_get("@#{key}".to_sym)
+  end
+
+  def write_attribute(key,value)
+    if field = self.fields.assoc(key)
+      if self.class.check_value(field,value)
+        self.instance_variable_set("@#{key}".to_sym,value)
+      else
+        raise "Invalid input for #{key}: #{value}  field: #{field}"
+      end
+    else
+      raise "#{key} is an invalid key"
+    end
+  end
+
+  def to_bin
+    self.fields.reverse.map do |field,conf|
+      val = self.read_attribute(field)
+      val = conf[:values].index(val) if conf[:values].respond_to? :index
+      val.to_i.to_s(2).rjust(conf[:bits],'0')
+    end.join('').sub(/\A0+/,'')
+  end
+
+  #converts it to an integer, Good for IDs
+  def to_i
+    self.to_bin.to_i(2)
+  end
+
+  def to_s(radix=nil)
+    radix ||= self.base
+    characters = CHARACTER_SET
+
+    if radix.kind_of? String
+      characters = radix.dup
+      radix = radix.size
+    elsif !radix.kind_of?(Integer) || radix < 0 || radix > 64
+      raise '#{radix} is and invalid base to convert to. It must be a string or between 0 and 64'
+    end
+
+    dec = self.to_i
+    result = ''
+    while dec != 0
+      result += characters[dec%radix].chr
+      dec /= radix
+    end
+    result.reverse
+  end
+
+  def keys
+    self.class.keys
+  end
+
+  alias_method :dump, :to_s
+
+  def ==(other)
+    self.class == other.class && self.fields == other.fields && self.attributes == other.attributes
+  end
+
+  def attributes
+    fields.inject({}) do |attrs, field|
+      attrs[field.first] = self.send(field.first)
+      attrs
+    end
+  end
+
+  def inspect
+    self.attributes.inspect
+  end
+
+  class << self
+
+    def keys
+      self.fields.map {|f| f[0]}
+    end
+
+    def from_s(string,radix = nil)
+      radix ||= self.base
+      if radix.kind_of? String
+        char_ref = radix
+        radix = radix.size
+      elsif !radix.kind_of?(Integer) || radix < 0 || radix > 64
+        raise '#{radix} is and invalid base to convert to. It must be a string or between 0 and 64'
+      else
+        char_ref = CHARACTER_SET[0..radix]
+      end
+
+      int_val = 0
+      string.reverse.split(//).each_with_index do |char,index|
+        raise ArgumentError, "Character #{char} at index #{index} is not a valid character for to_insane Base #{radix} String." unless char_index = char_ref.index(char)
+        int_val += (char_index)*(radix**(index))
+      end
+      self.from_i(int_val)
+    end
+
+    alias_method :load, :from_s
+
+    def from_i(integer)
+      self.from_bin(integer.to_s(2))
+    end
+
+    def from_bin(binary_string)
+      binary_array = binary_string.split('')
+      bit_hash = self.new
+      self.fields.each do |field,conf|
+        value = (conf[:bits] == -1) ? binary_array : binary_array.pop(conf[:bits])
+        break if value.nil?
+        value = value.join('').to_i(2)
+        if conf[:values].respond_to?(:at)
+          value = conf[:values].at(value)
+        elsif conf[:values].respond_to?(:from_i)
+          value = conf[:values].from_i(value)
+        end
+        bit_hash.write_attribute(field,value)
+      end
+      bit_hash
+    end
+
+    def set_base(base)
+      if base.kind_of? Integer && base <= 36
+        self.base = base
+      end
+    end
+
+    def bit_length
+      bits = 0
+      self.fields.each do |field,opts|
+        bits += opts[:bits]
+      end
+      bits
+    end
+
+    def field(name,opts)
+      name = name.to_sym
+      unless opts[:bits]
+        unless opts[:limit]
+          if opts[:characters]
+            opts[:limit] = opts[:characters].to_i*self.base
+          elsif opts[:values].respond_to? :bit_length
+            opts[:bits] = opts[:values].bit_length
+          elsif opts[:values].kind_of? Integer
+            opts[:limit] = opts[:values]
+          else
+            opts[:limit] = opts[:values].size
+          end
+        end
+        opts[:bits] ||= (opts[:limit].to_i-1).to_s(2).length
+      end
+      raise "value cannot be negative" if opts[:values].class == Integer && opts[:values] < 0
+      options = {:values => opts[:values], :bits => opts[:bits].to_i, :nil => opts[:nil]}
+      if index = self.fields.index{|f| f[0] == name}
+        self.fields[index][1] = options
+      else
+        self.fields << [name, options]
+      end
+      self.defaults[name]=get_default(options)
+
+      define_method name do
+        self.read_attribute(name)
+      end
+
+      define_method "#{name}=" do |*args|
+        self.write_attribute(name,*args)
+      end
+
+    end
+
+    def get_default(opts)
+      return nil if opts[:nil]
+      values = opts[:values]
+      if values.kind_of? Integer
+        0
+      elsif values.respond_to? :first
+        values.first
+      elsif values.respond_to? :defaults
+        values.defaults
+      end
+    end
+
+    def check_value(key,value)
+      field = (key.class == Array) ? key : self.fields.assoc(key)
+
+      if opts = field[1]
+        return true if opts[:nil] && value.nil?
+        if values = opts[:values]
+          if values.kind_of? Integer
+            return false if value < 0
+            return values == -1 || value <= values
+          elsif values.kind_of? BitMask
+            return value.kind_of? BitMask && value.fields.hash == value.fields.hash
+          else
+            return values.include?(value)
+          end
+        end
+      end
+      false
+    end
+  end
+end

data/spec/bit_mask_spec.rb

@@ -0,0 +1,87 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe BitMask do
+
+  it "should have values set at 2" do
+    CarSearch.fields.assoc(:segment_1)[1][:values].should == 2
+  end
+
+  it "should have bits set to 1" do
+    CarSearch.fields.assoc(:segment_1)[1][:bits].should == 1
+  end
+
+  it "should have bits set to 4" do
+    CarSearch.fields.assoc(:min_price_cents)[1][:bits].should == 4
+  end
+
+  it "should raise an error if config lacks name" do
+    CarSearch.new.should_not be_nil
+  end
+
+  it "should be able to get keys" do
+    CarSearch.keys.should be_a Array
+  end
+
+  it "should have load same config" do
+    CarSearch.load(CarSearch.new.dump).inspect.should == CarSearch.new.inspect
+  end
+
+  it "should equal itself" do
+    CarSearch.load(CarSearch.new.dump).should == CarSearch.new
+  end
+
+  it "should output equal it self after being converted and parsed" do
+    str = CarSearch.new.dump
+    bin = CarSearch.new.to_bin
+    CarSearch.load(str).to_bin.should eql(bin)
+  end
+
+  it "settings should change" do
+    old = CarSearch.new
+    new = old.dup
+    new[:body_style]= 'wagon'
+    new[:color].should eql('red')
+  end
+
+  it "should replace setting" do
+    config = CarSearch.new
+    config.replace({:air=>1})
+    config[:air].should eql(1)
+  end
+
+  let(:modified_conf) {
+    config = CarSearch.new
+    config.color= 'red'
+    config.body_style= 'suv'
+    config.air= 1
+    config
+  }
+
+  it "should have binary conversion working" do
+    new = CarSearch.from_bin(modified_conf.to_bin)
+    new.attributes.should == modified_conf.attributes
+  end
+
+  it "should have integer conversion working" do
+    new = CarSearch.from_i(modified_conf.to_i)
+    new.attributes.should == modified_conf.attributes
+  end
+
+  it "should have string conversion working" do
+    modified_conf.to_s(10).should == modified_conf.to_i.to_s(10)
+  end
+
+  it "should have string conversion working" do
+    modified_conf.to_bin == CarSearch.from_s(modified_conf.to_i.to_s(36),36).to_bin
+  end
+
+  it "should have string conversion working" do
+    new = CarSearch.from_s(modified_conf.to_s)
+    new.attributes.should == modified_conf.attributes
+  end
+
+  it "should have string conversion working" do
+    new = CarSearch.from_s(modified_conf.to_s('qwerty'),'qwerty')
+    new.attributes.should == modified_conf.attributes
+  end
+end

data/spec/models/car_search.rb

@@ -0,0 +1,27 @@
+class CarSearch < BitMask
+  field :min_price_cents, :values => [1000000,1500000,2000000,3000000,3500000,4000000,4500000,5000000,5500000,6000000,6500000,7000000]
+  field :max_price_cents, :values => [1500000,2000000,3000000,3500000,4000000,4500000,5000000,5500000,6000000,6500000,7000000,8000000]
+  field :segment_1, :values => 2
+  field :segment_2, :values => 2
+  field :segment_3, :values => 2
+  field :segment_4, :values => 2
+  field :segment_5, :values => 2
+  field :segment_6, :values => 2
+  field :segment_7, :values => 2
+  field :segment_8, :values => 2
+  field :segment_9, :values => 2
+  field :brand_pref_acura, :values => 3
+  field :brand_pref_aston_martin, :values => 3
+  field :brand_pref_audi, :values => 3
+  field :brand_pref_bentley, :values => 3
+  field :brand_pref_bmw, :values => 3
+  field :brand_pref_buick, :values => 3
+  field :brand_pref_cadillac, :values => 3
+  field :brand_pref_chevrolet, :values => 3
+  field :brand_pref_chrysler, :values => 3
+  field :brand_pref_dodge, :values => 3
+  field :brand_pref_ferrari, :values => 3
+  field :air, :values => 2
+  field :body_style, :values => ['sedan','suv','wagon']
+  field :color, :values => ['red','blue','green']
+end

data/spec/models/dealership_search.rb

@@ -0,0 +1,5 @@
+class DealershipSearch < BitMask
+  field :makes, :values => ['honda','toyota','ford']
+  field :zip, :values => 99999
+  field :distance, :values => -1
+end

data/spec/spec_helper.rb

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

metadata

@@ -0,0 +1,138 @@
+--- !ruby/object:Gem::Specification 
+name: bit_mask
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Ryan Ong
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-18 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  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_mask creates a simple api to create bit mask models. By bit masking dataing you can compress the amount of data that needs to be sent between servers and clients
+email: ryanong@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- .document
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- bit_mask.gemspec
+- lib/bit_mask.rb
+- spec/bit_mask_spec.rb
+- spec/models/car_search.rb
+- spec/models/dealership_search.rb
+- spec/spec_helper.rb
+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: -3458846048979533380
+      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.8.5
+signing_key: 
+specification_version: 3
+summary: bit_mask allows you to serialize/bitmask simple data sets into short compact ascii strings.
+test_files: 
+- spec/bit_mask_spec.rb
+- spec/models/car_search.rb
+- spec/models/dealership_search.rb
+- spec/spec_helper.rb