activerecord2-hstore 1.0.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/Gemfile

@@ -0,0 +1,7 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in activerecord2-hstore.gemspec
+gemspec
+
+gem "activerecord", "~> 2.3.0", :require => "active_record"
+gem "activesupport", "~> 2.3.0", :require => "active_support"

data/README.markdown

@@ -0,0 +1,162 @@
+activerecord2-hstore
+====================
+
+What is this?
+-------------
+This is a gem that provides some very basic functionality for working with 
+Postgresql's Hstore columns in ActiveRecord 2.
+
+Documentation about the Postgresql Hstore feature can be found 
+**[here](http://www.postgresql.org/docs/9.1/static/hstore.html)**.
+
+Requirements (aka boring stuff)
+-------------------------------
+This gem requires:
+
+*   ActiveRecord and ActiveSupport 2.3.x
+*   pg gem
+*   rspec (for running tests, duh)
+*   Ruby (Tested on 1.8.7 MRI, 1.9.2, and REE)
+*   Postgresql (Tested on 9.1)
+
+Setup (aka more boring stuff)
+-----------------------------
+Install the gem like you would normally install any gem.
+
+Enable the hstore extension on the postgres database(s) you wish to use.
+Ether by creating a migration in your project that runs this SQL statement
+or manually running it directly in psql console...
+
+    CREATE EXTENSION IF NOT EXISTS hstore;
+
+Instead of me trying to hack ActiveRecord to add an actual hstore column type,
+and risk breaking the universe, just manually write a migration that adds a 
+hstore column to your table. Here, I'll even give you an example:
+
+    ALTER TABLE my_table ADD COLUMN some_field hstore;
+
+I recommend you add an index to that column. Supported indexes are BTREE, HASH, 
+GIST, and GIN. I'll leave you to handle that on your own.
+
+Usage (aka the stuff you care about)
+------------------------------------
+Now that the boring stuff is out of the way, you need to tell your model that
+you have a hstore column.
+
+Assume you have the following table:
+    
+    peeps
+    id: integer
+    name: string
+    infos: hstore
+
+You can tell your model infos is a hstore column thusly...
+
+    class Peep < ActiveRecord::Base
+      hstore_column :infos
+    end
+
+What does that one line get you?
+
+*   A getter that returns the hstore column as a hash...
+
+        @peep.infos
+        >> {"age" => "25", "haircolor" => "black", "height" => "5'3\"", "likes" => "Cuddling while watching TV"}
+
+*   A setter that takes a hash and converts it to a hstore string (or the method can just take a hstore string)
+
+        @peeps.infos = some_hash
+
+*   These name scopes:
+    *   infos\_has\_key (takes a string)
+    *   infos\_has\_all\_keys (takes a string or an array of strings)
+    *   infos\_has\_any\_keys (takes a string or an array of strings) 
+
+So what about querying the data in that colum? Well, you can always use the 
+standard condisions key in ActiveRecord's find method and use the proper 
+syntax from the Postgresql documentation. But if you're like me and like 
+using searchlogic, that's not an option. So in the same line in your model,
+you can specifiy some keys you'd want to filter by...
+
+    class Peep < ActiveRecord::Base
+      hstore_column :infos, [:age, :haircolor, :likes]
+    end
+
+Passing in an array of hstore keys will give you the following named scopes
+to play with...
+
+*   infos\_age\_eq
+*   infos\_age\_neq
+*   infos\_age\_eq\_any
+*   infos\_age\_neq\_any
+*   infos\_age\_like
+*   infos\_age\_beigns\_with
+*   infos\_age\_ends\_with
+*   (Repeat list for "haircolor" and "likes")
+
+Which means you can then do...
+
+    Peep.infos_likes_eq("Cuddling while watching TV")
+    Peep.searchlogic(:infos_age_neq => "23")
+
+But Wait, There's More!
+-----------------------
+
+The gem also adds a helper method to the Hash and String objects for converting
+hashes to hstore strings and back again.
+
+These methods were originally implemented in a gem by 
+[softa](https://github.com/softa/activerecord-postgres-hstore) to add hstore
+to ActiveReocord 3 and tweaked slightly for this gem.
+
+Converting a hash into a hstore string that can be used to direclty store data
+in a query...
+
+    {"something something" => "something", :dark => "side"}.to_hstore
+    >> "\"something something\"=>something,dark=>side"
+
+Converting a hstore string that is returned from the database into a hash so
+you can actually do something with it...
+
+    "\"something something\"=>something,dark=>side".from_hstore
+    >> {"something something" => "something", "dark" => "side"}
+
+Note that taking a string from hstore into a hash will produce a hash where its
+keys and values are all strings.
+    
+
+Running Tests
+-------------
+For the tests to run, it's assumed there is a Postgres database called
+activerecord2\_hstore\_test. The specs will create a test table and populate
+it with data for you. If you want to use a different database, then edit
+spec/hstore\_spec.rb to your liking.
+
+Then just run...
+
+    rake spec
+
+Background / Why make this? / Me Rambling
+-----------------------------------------
+At my current employor, I'm helping to support a rather large Rails 2.3 app 
+(that unfortunatly will be stuck in 2.3 for quite some time) that runs on 
+Postgresql. The app's primary purpose is reporting on data from its data 
+warehouse of well... data. Because it's on Postgresql, the development team
+was interested in using some of Postgresql's special features such as array
+columns and hstore datatypes. We need the ability to easily take a hash 
+and store that as a hstore and read the column out as a hash. Also because
+we're big on reporting and use searchlogic for filtering out data, we need
+some way to search a hstore field for key with certain values.
+
+To accomplish the first goal, I first needed a way to convert a Postgresql
+hstore string into a Ruby hash and back to a string. I'm using the hash and
+string methods from **[softa's gem](https://github.com/softa/activerecord-postgres-hstore)**
+that provides hstore support for ActiveRecord 3. With those methods, I created
+a way for you to tell ActiveRecord what columns are hstore columns and this 
+gem will override the default column getter method to return a hash and the
+setter method to accept a hash which it then converts into a hstore string.
+
+Part two of this gem is determining a way to query a hstore field. I decided
+to have the gem generate searchlogic-like named scopes by sepcifying in the
+model what keys in the hstore column you'll want to filter on. The gem will 
+create scopes in the style of "mycolumn\_key\_eq", "mycolumn\_key\_like", etc.

data/Rakefile

@@ -0,0 +1,4 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')

data/activerecord2-hstore.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "activerecord2-hstore/version"
+
+Gem::Specification.new do |s|
+  s.name        = "activerecord2-hstore"
+  s.version     = Activerecord2::Hstore::VERSION
+  s.authors     = ["Tony Drake"]
+  s.email       = ["t27duck@gmail.com"]
+  s.homepage    = "https://github.com/t27duck/activerecord2-hstore"
+  s.summary     = %q{Some basic support to help integrate Postgresql's HStore into a Rails 2.3 app}
+  s.description = %q{Allows you to mark a column in a model as a HStore column letting you pass in a hash for its setter and retrieve a hash from its getter method. Also provides a series to named scopes for easy querying of data.}
+
+  s.rubyforge_project = "activerecord2-hstore"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rspec", ">=2.0.0"
+  s.add_runtime_dependency "activerecord", "~> 2.3.0"
+  s.add_runtime_dependency "activesupport", "~> 2.3.0"
+  s.add_runtime_dependency "pg"
+end

data/lib/activerecord2-hstore/hash.rb

@@ -0,0 +1,24 @@
+class Hash
+  # Generates an hstore string format. This is the format used to insert or update stuff in the database.
+  #
+  # Original implementation from:
+  # https://github.com/softa/activerecord-postgres-hstore/blob/master/lib/activerecord-postgres-hstore/hash.rb
+  def to_hstore
+    return "" if empty?
+
+    map { |key, value| 
+      pair = [key, value].map { |element| 
+        item = element.to_s.gsub(/"/, '\"')
+        if element.nil?
+          'NULL'
+        elsif item =~ /[,\s=>]/ || item.blank?
+          '"%s"' % item
+        else
+          item
+        end
+      }
+
+      "%s=>%s" % pair
+    } * ","
+  end
+end

data/lib/activerecord2-hstore/hstore.rb

@@ -0,0 +1,78 @@
+module Hstore
+  module ActiveRecord
+    # Called when included in ActiveRecord. Extends the Extensions module.
+    def self.included(base)
+      base.extend Extensions
+    end
+    
+    module Extensions
+      # Creates a series of methods and named scopes for a hstore column. This is the primary
+      # method you should use to invoke this gem in a model.
+      #
+      # USAGE IN A MODEL:
+      # class Foo < ActiveRecord::Base
+      #   hstore_column :some_column, [:array_of_possible_keys, :you_may_want, :to_query_on]
+      # end
+      def hstore_column(column, keys=[])
+        create_getter_and_setter(column)
+        create_hstore_key_availability_scopes(column)
+        Array(keys).each{ |key| create_hstore_key_search_scopes(column, key) }
+      end
+
+      # Creates and overrides ActiveRecord's getter and setter methods for the hstore column.
+      # The getter returns a hash. The setter accepts and converts either a hash or a valid
+      # hstore string.
+      def create_getter_and_setter(column)
+        define_method column.to_sym do
+          read_attribute(column.to_sym).to_s.from_hstore
+        end
+
+        define_method "#{column}=".to_sym do |value|
+          value = value.is_a?(String) ? value : value.to_hstore
+          write_attribute(column.to_sym, value)
+        end
+      end
+
+      # Creates named scopes for the hstore column allowing you to determine if the column
+      # contains a given key or set of keys.
+      def create_hstore_key_availability_scopes(column)
+        named_scope "#{column}_has_key".to_sym, Proc.new{ |key|
+          { :conditions => ["#{column} ? :key", {:key => key}] }
+        }
+        named_scope "#{column}_has_all_keys".to_sym, Proc.new{ |keys|
+          { :conditions => ["#{column} ?& ARRAY[:keys]", {:keys => Array(keys)}] }
+        }
+        named_scope "#{column}_has_any_key".to_sym, Proc.new{ |keys|
+          { :conditions => ["#{column} ?| ARRAY[:keys]", {:keys => Array(keys)}] }
+        }
+      end
+
+      # Creates a slew of searchlogic-like named scopes to query for a key on a hstore column
+      def create_hstore_key_search_scopes(column, key)
+        named_scope "#{column}_#{key}_eq".to_sym, Proc.new{ |value|
+          { :conditions => ["#{column} -> '#{key}' = ?", value.to_s] }
+        }
+        named_scope "#{column}_#{key}_neq".to_sym, Proc.new{ |value|
+          { :conditions => ["#{column} -> '#{key}' != ?", value.to_s] }
+        }
+        named_scope "#{column}_#{key}_eq_any".to_sym, Proc.new{ |value|
+          { :conditions => ["#{column} -> '#{key}' IN(?)", value.map{|v| v.to_s} ] }
+        }
+        named_scope "#{column}_#{key}_neq_any".to_sym, Proc.new{ |value|
+          { :conditions => ["#{column} -> '#{key}' NOT IN(?)", value.map{|v| v.to_s} ] }
+        }
+        named_scope "#{column}_#{key}_like".to_sym, Proc.new{ |value|
+          { :conditions => ["#{column} -> '#{key}' ILIKE(?)", "%#{value.to_s}%"] }
+        }
+        named_scope "#{column}_#{key}_begins_with".to_sym, Proc.new{ |value|
+          { :conditions => ["#{column} -> '#{key}' ILIKE(?)", "#{value.to_s}%"] }
+        }
+        named_scope "#{column}_#{key}_ends_with".to_sym, Proc.new{ |value|
+          { :conditions => ["#{column} -> '#{key}' ILIKE(?)", "%#{value.to_s}"] }
+        }
+      end
+    end
+  end
+end
+
+

data/lib/activerecord2-hstore/string.rb

@@ -0,0 +1,24 @@
+class String
+  # Generates a hash from an hstore string format.
+  #
+  # Original implementation from:
+  # https://github.com/softa/activerecord-postgres-hstore/blob/master/lib/activerecord-postgres-hstore/string.rb
+  def from_hstore
+    quoted_string = /"[^"\\]*(?:\\.[^"\\]*)*"/
+    unquoted_string = /[^\s=,][^\s=,\\]*(?:\\.[^\s=,\\]*|=[^,>])*/
+    string = /(#{quoted_string}|#{unquoted_string})/
+    hstore_pair = /#{string}\s*=>\s*#{string}/
+
+    token_pairs = (scan(hstore_pair)).map { |key, value| [key, value =~ /^NULL$/i ? nil : value] }
+    token_pairs = token_pairs.map { |key, value|
+      [key, value].map { |element| 
+        case element
+        when nil then element
+        when /^"(.*)"$/ then $1.gsub(/\\(.)/, '\1')
+        else element.gsub(/\\(.)/, '\1')
+        end
+      }
+    }
+    Hash[ token_pairs ]
+  end
+end

data/lib/activerecord2-hstore/version.rb

@@ -0,0 +1,5 @@
+module Activerecord2
+  module Hstore
+    VERSION = "1.0.0"
+  end
+end

data/lib/activerecord2-hstore.rb

@@ -0,0 +1,12 @@
+require "activerecord2-hstore/version"
+require "activerecord2-hstore/string"
+require "activerecord2-hstore/hash"
+require "activerecord2-hstore/hstore"
+
+module Activerecord2
+  module Hstore
+    # Your code goes here...
+  end
+end
+
+ActiveRecord::Base.send(:include, Hstore::ActiveRecord)

data/spec/hash_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+describe Hash do
+  describe "Converting a hash to a hstore string" do
+    it "#to_hstore" do
+      {:a=>"b"}.to_hstore.should == "a=>b"
+      {"a"=>"b"}.to_hstore.should == "a=>b"
+      {:a=>:b}.to_hstore.should == "a=>b"
+      {"a"=>"2"}.to_hstore.should == "a=>2"
+      {:a=>2}.to_hstore.should == "a=>2"
+      {2=>2}.to_hstore.should == "2=>2"
+      {"a b"=>"b"}.to_hstore.should == "\"a b\"=>b"
+      {"a b"=>"b c"}.to_hstore.should == "\"a b\"=>\"b c\""
+      {"a"=>"b c"}.to_hstore.should == "a=>\"b c\""
+    end
+    
+    it "converts a multiball hash to a hstore string" do
+      all_should_match({"a"=>"b", "c"=>"d"}, [/a=>b/, /c=>d/])
+      all_should_match({:a=>"b", "c"=>:d}, [/a=>b/, /c=>d/])
+      all_should_match({"a 1"=>"b 1", "c"=>"d"}, [/\"a 1\"=>\"b 1\"/, /c=>d/])
+      all_should_match({"a"=>"b", "c"=>"d 1"}, [/a=>b/, /c=>\"d 1\"/])
+      all_should_match({"a"=>"b", "c 1"=>"d"}, [/a=>b/, /\"c 1\"=>d/])
+      all_should_match({:a=>:b, "c 1"=>:"d 1"}, [/a=>b/, /\"c 1\"=>\"d 1\"/])
+      all_should_match({"a"=>"b", :c=>:d, "e 1"=>"f 1"}, [/a=>b/, /c=>d/, /\"e 1\"=>\"f 1\"/])
+    end
+
+    def all_should_match(hash, expects)
+      expects.each do |e|
+        hash.to_hstore.should match(e)
+      end
+    end
+  end
+end

data/spec/hstore_spec.rb

@@ -0,0 +1,179 @@
+require "spec_helper"
+
+ActiveRecord::Base.establish_connection(
+  :adapter => "postgresql",
+  :database => "activerecord2_hstore_test",
+  :encoding => "unicode"
+)
+
+ActiveRecord::Base.connection.execute("DROP TABLE IF EXISTS my_hstores")
+ActiveRecord::Base.connection.create_table(:my_hstores) do |t|
+  t.string :label
+end
+ActiveRecord::Base.connection.execute("CREATE EXTENSION IF NOT EXISTS hstore")
+ActiveRecord::Base.connection.execute("ALTER TABLE my_hstores ADD COLUMN some_field hstore")
+
+class MyHstore < ActiveRecord::Base
+  hstore_column :some_field, [:key]
+end
+
+describe Hstore do
+  before(:each) do
+    ActiveRecord::Base.connection.increment_open_transactions
+    ActiveRecord::Base.connection.begin_db_transaction
+  end
+
+  after(:each) do
+    ActiveRecord::Base.connection.rollback_db_transaction
+    ActiveRecord::Base.connection.decrement_open_transactions
+  end
+
+  it "creates the correct named scopes" do
+    %w(eq neq eq_any neq_any like begins_with ends_with).each do |predicate|
+      MyHstore.should respond_to("some_field_key_#{predicate}")
+    end
+  end
+
+  describe "available methods" do
+    let(:subject) do
+      MyHstore.new
+    end
+  
+    it "creates a getter and setter for the some_field" do
+      subject.should respond_to(:some_field)
+      subject.should respond_to(:some_field=)
+    end
+
+    it "uses ActiveRecord's read_attribute for the getter method" do
+      subject.should_receive(:read_attribute).with(:some_field).and_return("a=>b")
+      subject.some_field
+    end
+
+    describe "setter method" do
+      it "uses ActiveRecord's write_attribute" do
+        subject.should_receive(:write_attribute)
+        subject.some_field = {:a => :b}
+      end
+
+      it "can also accept a hstore string instead of a hash" do
+        subject.stub(:write_attribute)
+        subject.some_field = "a=>b"
+      end
+    end
+  end
+
+  describe "querying data" do
+    before(:each) do
+      MyHstore.create( :label=> "A", :some_field => {"key" => "1"}.to_hstore )
+      MyHstore.create( :label=> "B", :some_field => {:key => 1, "a" => "b"}.to_hstore )
+      MyHstore.create( :label=> "C", :some_field => {"key" => "2"}.to_hstore )
+      MyHstore.create( :label=> "D", :some_field => {"key" => "3"}.to_hstore )
+      MyHstore.create( :label=> "E", :some_field => {"key" => "123456789"}.to_hstore )
+      MyHstore.create( :label=> "F", :some_field => {"c" => "x"}.to_hstore )
+    end
+
+    it "queries for the records containing a specific key" do
+      result = MyHstore.some_field_has_key("a")
+      result.map(&:label).should include "B"
+      %w(A C D E F).each do |key|
+        result.map(&:label).should_not include key
+      end
+    end
+
+    it "queries for the records containing a set keys" do
+      result = MyHstore.some_field_has_all_keys(["a", "key"])
+      result.map(&:label).should include "B"
+      %w(A C D E F).each do |key|
+        result.map(&:label).should_not include key
+      end
+      
+      result = MyHstore.some_field_has_all_keys("a")
+      result.map(&:label).should include "B"
+      %w(A C D E F).each do |key|
+        result.map(&:label).should_not include key
+      end
+    end
+
+    it "queries for the records containing any set keys" do
+      result = MyHstore.some_field_has_any_key(["a", "c"])
+      %w(B F).each do |key|
+        result.map(&:label).should include key
+      end
+      %w(A C D E).each do |key|
+        result.map(&:label).should_not include key
+      end
+      
+      result = MyHstore.some_field_has_any_key("a")
+      result.map(&:label).should include "B"
+      %w(A C D E F).each do |key|
+        result.map(&:label).should_not include key
+      end
+    end
+
+    it "queries the right data for the named scope *_eq" do
+      result = MyHstore.some_field_key_eq("1")
+      %w(A B).each do |key|
+        result.map(&:label).should include key
+      end
+      %w(C D E F).each do |key|
+        result.map(&:label).should_not include key
+      end
+    end
+
+    it "queries the right data for the named scope *_neq" do
+      result = MyHstore.some_field_key_neq("1")
+      %w(A B F).each do |key|
+        result.map(&:label).should_not include key
+      end
+      %w(C D E).each do |key|
+        result.map(&:label).should include key
+      end
+    end
+
+    it "queries the right data for the named scope *_eq_any" do
+      result = MyHstore.some_field_key_eq_any(["2", "3"])
+      %w(A B E F).each do |key|
+        result.map(&:label).should_not include key
+      end
+      %w(C D).each do |key|
+        result.map(&:label).should include key
+      end
+    end
+
+    it "queries the right data for the named scope *_neq_any" do
+      result = MyHstore.some_field_key_neq_any(["2", "3"])
+      %w(A B E).each do |key|
+        result.map(&:label).should include key
+      end
+      %w(C D F).each do |key|
+        result.map(&:label).should_not include key
+      end
+    end
+
+    it "queries the right data for the named scope *_like" do
+      result = MyHstore.some_field_key_like("456")
+      result.map(&:label).should include "E"
+      %w(A B C D F).each do |key|
+        result.map(&:label).should_not include key
+      end
+    end
+    
+    it "queries the right data for the named scope *_begins_with" do
+      result = MyHstore.some_field_key_begins_with("123")
+      result.map(&:label).should include "E"
+      %w(A B C D F).each do |key|
+        result.map(&:label).should_not include key
+      end
+    end
+    
+    it "queries the right data for the named scope *_ends_with" do
+      result = MyHstore.some_field_key_ends_with("789")
+      result.map(&:label).should include "E"
+      %w(A B C D F).each do |key|
+        result.map(&:label).should_not include key
+      end
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require "rubygems"
+require "bundler/setup"
+
+require "active_support"
+require "active_record"
+require "activerecord2-hstore"
+
+RSpec.configure do |config|
+  # some (optional) config here
+end

data/spec/string_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe String do
+  describe "#from_hstore" do
+    it "handles a single key value pair" do
+      "a=>b".from_hstore.should == {"a" => "b"}
+      "\"a\"=>\"b\"".from_hstore.should == {"a" => "b"}
+      "\"a 1\"=>b".from_hstore.should == {"a 1" => "b"}
+      "\"a 1\"=>\"b 1\"".from_hstore.should == {"a 1" => "b 1"}
+      "1=>b".from_hstore.should == {"1" => "b"}
+      "1=>1".from_hstore.should == {"1" => "1"}
+    end
+
+    it "converts a multikeyed hstore string to a hash" do
+      "a=>b,c=>d".from_hstore.should == {"a" => "b", "c" => "d"}
+      "\"a\"=>\"b\",\"c\"=>\"d\"".from_hstore.should == {"a" => "b", "c" => "d"}
+      "\"a 1\"=>b,c=>d".from_hstore.should == {"a 1" => "b", "c" => "d"}
+      "\"a 1\"=>b,c=>\"d 1\"".from_hstore.should == {"a 1" => "b", "c" => "d 1"}
+      "\"a 1\"=>\"b 1\",c=>\"d 1\"".from_hstore.should == {"a 1" => "b 1", "c" => "d 1"}
+      "1=>b,c=>\"d 1\"".from_hstore.should == {"1" => "b", "c" => "d 1"}
+    end
+  end
+end

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification 
+name: activerecord2-hstore
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Tony Drake
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-02-16 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 2
+        - 0
+        - 0
+        version: 2.0.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 3
+        - 0
+        version: 2.3.0
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 3
+        - 0
+        version: 2.3.0
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: pg
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id004
+description: Allows you to mark a column in a model as a HStore column letting you pass in a hash for its setter and retrieve a hash from its getter method. Also provides a series to named scopes for easy querying of data.
+email: 
+- t27duck@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rspec
+- Gemfile
+- README.markdown
+- Rakefile
+- activerecord2-hstore.gemspec
+- lib/activerecord2-hstore.rb
+- lib/activerecord2-hstore/hash.rb
+- lib/activerecord2-hstore/hstore.rb
+- lib/activerecord2-hstore/string.rb
+- lib/activerecord2-hstore/version.rb
+- spec/hash_spec.rb
+- spec/hstore_spec.rb
+- spec/spec_helper.rb
+- spec/string_spec.rb
+homepage: https://github.com/t27duck/activerecord2-hstore
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: activerecord2-hstore
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Some basic support to help integrate Postgresql's HStore into a Rails 2.3 app
+test_files: 
+- spec/hash_spec.rb
+- spec/hstore_spec.rb
+- spec/spec_helper.rb
+- spec/string_spec.rb