activerecord-postgres-hstore-core 0.0.3

data/.gitignore

@@ -0,0 +1,8 @@
+*.log
+*.sqlite3
+/pkg/*
+.bundle
+.rvmrc
+Gemfile.lock
+spec/database.yml
+tmp

data/Gemfile

@@ -0,0 +1,3 @@
+source 'http://rubygems.org'
+gemspec
+

data/Rakefile

@@ -0,0 +1,13 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup :default, :development
+
+desc 'Default: run specs'
+task :default => :spec  
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = "spec/**/*_spec.rb"
+end
+
+Bundler::GemHelper.install_tasks

data/activerecord-postgres-hstore-core.gemspec

@@ -0,0 +1,26 @@
+$:.push File.dirname(__FILE__) + '/lib'
+require 'activerecord-postgres-hstore-core/version'
+
+Gem::Specification.new do |gem|
+  gem.name = %q{activerecord-postgres-hstore-core}
+  gem.authors = ["Jt Gleason"]
+  gem.date = %q{2012-02-29}
+  gem.description = %q{Allows you to use active record with databases that already have an hstore type}
+  gem.summary = "Hstore AR for Hstore DB"
+  gem.email = %q{jt@twitch.tv}
+  gem.homepage      = ''
+
+  gem.add_dependency 'rails', '~> 3.0'
+  gem.add_development_dependency 'rspec', '~> 2.6'
+  gem.add_development_dependency 'ammeter', '~> 0.1.3'
+  gem.add_development_dependency 'pg'
+  gem.add_development_dependency 'guard'
+  gem.add_development_dependency 'guard-rspec'
+
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.require_paths = ['lib']
+  gem.version       = ActiveRecordPostgresHstore::VERSION
+end

data/lib/activerecord-postgres-hstore-core.rb

@@ -0,0 +1,9 @@
+require 'rails'
+require 'pg'
+require "active_record"
+
+require "activerecord_postgres_hstore_core/string"
+require "activerecord_postgres_hstore_core/hash"
+
+require "activerecord_postgres_hstore_core/activerecord"
+

data/lib/activerecord-postgres-hstore-core/version.rb

@@ -0,0 +1,3 @@
+module ActiveRecordPostgresHstore
+  VERSION = '0.0.3'
+end

data/lib/activerecord_postgres_hstore_core/activerecord.rb

@@ -0,0 +1,150 @@
+require 'active_record/connection_adapters/postgresql_adapter'
+# Extends AR to add Hstore functionality.
+module ActiveRecord
+
+  # Adds methods for deleting keys in your hstore columns
+  class Base
+
+    # Deletes all keys from a specific column in a model. E.g.
+    #   Person.delete_key(:info, :father)
+    # The SQL generated will be:
+    #   UPDATE "people" SET "info" = delete("info",'father');
+    def self.delete_key attribute, key
+      raise "invalid attribute #{attribute}" unless column_names.include?(attribute.to_s)
+      update_all([%(#{attribute} = delete("#{attribute}",?)),key])
+    end
+
+    # Deletes many keys from a specific column in a model. E.g.
+    #   Person.delete_key(:info, :father, :mother)
+    # The SQL generated will be:
+    #   UPDATE "people" SET "info" = delete(delete("info",'father'),'mother');
+    def self.delete_keys attribute, *keys
+      raise "invalid attribute #{attribute}" unless column_names.include?(attribute.to_s)
+      delete_str = "delete(#{attribute},?)"
+      (keys.count-1).times{ delete_str = "delete(#{delete_str},?)" }
+      update_all(["#{attribute} = #{delete_str}", *keys])
+    end
+
+    # Deletes a key in a record. E.g.
+    #   witt = Person.find_by_name("Ludwig Wittgenstein")
+    #   witt.destroy_key(:info, :father)
+    # It does not save the record, so you'll have to do it.
+    def destroy_key attribute, key
+      raise "invalid attribute #{attribute}" unless self.class.column_names.include?(attribute.to_s)
+      new_value = send(attribute)
+      new_value.delete(key.to_s)
+      send("#{attribute}=", new_value)
+      self
+    end
+
+    # Deletes a key in a record. E.g.
+    #   witt = Person.find_by_name("Ludwig Wittgenstein")
+    #   witt.destroy_key(:info, :father)
+    # It does save the record.
+    def destroy_key! attribute, key
+      destroy_key(attribute, key).save
+    end
+
+    # Deletes many keys in a record. E.g.
+    #   witt = Person.find_by_name("Ludwig Wittgenstein")
+    #   witt.destroy_keys(:info, :father, :mother)
+    # It does not save the record, so you'll have to do it.
+    def destroy_keys attribute, *keys
+      for key in keys
+        new_value = send(attribute)
+        new_value.delete(key.to_s)
+        send("#{attribute}=", new_value)
+      end
+      self
+    end
+
+    # Deletes many keys in a record. E.g.
+    #   witt = Person.find_by_name("Ludwig Wittgenstein")
+    #   witt.destroy_keys!(:info, :father, :mother)
+    # It does save the record.
+    def destroy_keys! attribute, *keys
+      raise "invalid attribute #{attribute}" unless self.class.column_names.include?(attribute.to_s)
+      destroy_keys(attribute, *keys).save
+    end
+
+    # This method is replaced for Rails 3 compatibility.
+    # All I do is add the condition when the field is a hash that converts the value
+    # to hstore format.
+    # IMHO this should be delegated to the column, so it won't be necessary to rewrite all
+    # this method.
+    def arel_attributes_values(include_primary_key = true, include_readonly_attributes = true, attribute_names = @attributes.keys)
+      attrs = {}
+      attribute_names.each do |name|
+        if (column = column_for_attribute(name)) && (include_primary_key || !column.primary)
+          if include_readonly_attributes || (!include_readonly_attributes && !self.class.readonly_attributes.include?(name))
+            value = read_attribute(name)
+            if self.class.columns_hash[name].type == :hstore && value && value.is_a?(Hash)
+              value = value.to_hstore # Done!
+            elsif value && self.class.serialized_attributes.has_key?(name) && (value.acts_like?(:date) || value.acts_like?(:time) || value.is_a?(Hash) || value.is_a?(Array))
+              value = value.to_yaml
+            end
+            attrs[self.class.arel_table[name]] = value
+          end
+        end
+      end
+      attrs
+    end
+  end
+  # This erro class is used when the user passes a wrong value to a hstore column.
+  # Hstore columns accepts hashes or hstore valid strings. It is validated with
+  # String#valid_hstore? method.
+  class HstoreTypeMismatch < ActiveRecord::ActiveRecordError
+  end
+
+  module ConnectionAdapters
+
+    class TableDefinition
+
+      # Adds hstore type for migrations. So you can add columns to a table like:
+      #   create_table :people do |t|
+      #     ...
+      #     t.hstore :info
+      #     ...
+      #   end
+      def hstore(*args)
+        options = args.extract_options!
+        column_names = args
+        column_names.each { |name| column(name, 'hstore', options) }
+      end
+
+    end
+
+    class PostgreSQLColumn < Column
+      # Does the type casting from hstore columns using String#from_hstore or Hash#from_hstore.
+      def type_cast_code_with_hstore(var_name)
+        type == :hstore ? "#{var_name}.from_hstore" : type_cast_code_without_hstore(var_name)
+      end
+
+      # Adds the hstore type for the column.
+      def simplified_type_with_hstore(field_type)
+        field_type == 'hstore' ? :hstore : simplified_type_without_hstore(field_type)
+      end
+      alias_method_chain :type_cast_code, :hstore
+      alias_method_chain :simplified_type, :hstore
+    end
+
+    class PostgreSQLAdapter < AbstractAdapter
+
+      def native_database_types_with_hstore
+        native_database_types_without_hstore.merge({:hstore => { :name => "hstore" }})
+      end
+
+      # Quotes correctly a hstore column value.
+      def quote_with_hstore(value, column = nil)
+        if value && column && column.sql_type == 'hstore'
+          raise HstoreTypeMismatch, "#{column.name} must have a Hash or a valid hstore value (#{value})" unless value.kind_of?(Hash) || value.valid_hstore?          
+          return quote_without_hstore(value.to_hstore, column)
+        end
+        quote_without_hstore(value,column)
+      end
+      
+      alias_method_chain :quote, :hstore
+      alias_method_chain :native_database_types, :hstore 
+    end
+  end
+end

data/lib/activerecord_postgres_hstore_core/hash.rb

@@ -0,0 +1,39 @@
+class Hash
+  HSTORE_ESCAPED = /[,\s=>\\]/
+
+  # Escapes values such that they will work in an hstore string
+  def hstore_escape(str)
+    if str.nil?
+      return 'NULL'
+    end
+    
+    str = str.to_s.dup
+    # backslash is an escape character for strings, and an escape character for gsub, so you need 6 backslashes to get 2 in the output.
+    # see http://stackoverflow.com/questions/1542214/weird-backslash-substitution-in-ruby for the gory details
+    str.gsub!(/\\/, '\\\\\\')
+    # escape backslashes before injecting more backslashes
+    str.gsub!(/"/, '\"')
+    
+    if str =~ HSTORE_ESCAPED or str.empty?
+      str = '"%s"' % str
+    end
+    
+    return str
+  end
+
+  # Generates an hstore string format. This is the format used
+  # to insert or update stuff in the database.
+  def to_hstore
+    return "" if empty?
+
+    map do |idx, val| 
+      "%s=>%s" % [hstore_escape(idx), hstore_escape(val)]
+    end * ","
+  end
+
+  # If the method from_hstore is called in a Hash, it just returns self.
+  def from_hstore
+    self
+  end
+
+end

data/lib/activerecord_postgres_hstore_core/string.rb

@@ -0,0 +1,43 @@
+class String
+
+  # If the value os a column is already a String and it calls to_hstore, it
+  # just returns self. Validation occurs afterwards.
+  def to_hstore
+    self
+  end
+
+  # Validates the hstore format. Valid formats are:
+  # * An empty string
+  # * A string like %("foo"=>"bar"). I'll call it a "double quoted hstore format".
+  # * A string like %(foo=>bar). Postgres doesn't emit this but it does accept it as input, we should accept any input Postgres does
+
+  def valid_hstore?
+    pair = hstore_pair
+    !!match(/^\s*(#{pair}\s*(,\s*#{pair})*)?\s*$/)
+  end
+
+  # Creates a hash from a valid double quoted hstore format, 'cause this is the format
+  # that postgresql spits out.
+  def from_hstore
+    token_pairs = (scan(hstore_pair)).map { |k,v| [k,v =~ /^NULL$/i ? nil : v] }
+    token_pairs = token_pairs.map { |k,v|
+      [k,v].map { |t| 
+        case t
+        when nil then t
+        when /^"(.*)"$/ then $1.gsub(/\\(.)/, '\1')
+        else t.gsub(/\\(.)/, '\1')
+        end
+      }
+    }
+    Hash[ token_pairs ]
+  end
+
+  private
+
+  def hstore_pair
+    quoted_string = /"[^"\\]*(?:\\.[^"\\]*)*"/
+    unquoted_string = /[^\s=,][^\s=,\\]*(?:\\.[^\s=,\\]*|=[^,>])*/
+    string = /(#{quoted_string}|#{unquoted_string})/
+    /#{string}\s*=>\s*#{string}/
+  end
+end

data/rails/init.rb

@@ -0,0 +1 @@
+require 'activerecord-posgres-hstore-core'

data/spec/activerecord_postgres_hstore_core/activerecord_posgres_hstore_database_spec.rb

@@ -0,0 +1,48 @@
+require File.expand_path('../../spec_helper', __FILE__)
+describe "Direct DB Changes for Hstore" do 
+  before(:each) do
+    clean_database!
+    @hstore = HstoreModel.new(:name => "Bob Jones")
+    @normal = NormalModel.new(:name => "Jane Smith")
+  end
+
+  it "should be an hstore sql type" do
+    @hstore.class.columns_hash['key_value'].sql_type.should =="hstore"
+  end
+
+  it "should be an hstore type" do
+    @hstore.class.columns_hash['key_value'].type.should == :hstore
+  end
+
+  it "should take a hash" do
+    @hstore.key_value = {"test" => 1}
+    @hstore.save
+  end
+
+  it "should not take a number" do
+    @hstore.key_value = 2
+    expect{ @hstore.save }.to raise_error(NoMethodError)
+  end
+
+  it "should not save an ilformatted string" do
+    @hstore.key_value = "test"
+    @hstore.save
+    @hstore.key_value.should == {}
+  end
+
+  it "should take and save a hash" do
+    @hstore.key_value = {"test" => 1, "t2" => 2}
+    @hstore.save
+  end
+
+  it "should overwrite correclty in db" do
+    @hstore.key_value = {"a" => 1, "a" => 2}
+    @hstore.save
+    db_hstore = HstoreModel.find_by_name(@hstore.name)
+    db_hstore.key_value.should == {"a" => "2"}
+    
+  end
+
+
+
+end

data/spec/activerecord_postgres_hstore_core/activerecord_postgres_hstore_datatype_spec.rb

@@ -0,0 +1,96 @@
+require File.expand_path('../../spec_helper', __FILE__)
+describe "Datatypes Changes for Hstore" do 
+    it "should recognize a valid hstore string" do
+    "".valid_hstore?.should be_true
+    "a=>b".valid_hstore?.should be_true
+    '"a"=>"b"'.valid_hstore?.should be_true
+    '"a" => "b"'.valid_hstore?.should be_true
+    '"a"=>"b","c"=>"d"'.valid_hstore?.should be_true
+    '"a"=>"b", "c"=>"d"'.valid_hstore?.should be_true
+    '"a" => "b", "c"=>"d"'.valid_hstore?.should be_true
+    '"a"=>"b","c" => "d"'.valid_hstore?.should be_true
+    'k => v'.valid_hstore?.should be_true
+    'foo => bar, baz => whatever'.valid_hstore?.should be_true
+    '"1-a" => "anything at all"'.valid_hstore?.should be_true
+    'key => NULL'.valid_hstore?.should be_true
+    %q(c=>"}", "\"a\""=>"b \"a b").valid_hstore?.should be_true
+  end
+
+  it "should not recognize an invalid hstore string" do
+    '"a"=>"b",Hello?'.valid_hstore?.should be_false
+  end
+
+  it "should convert hash to hstore string and back (sort of)" do
+    {:a => 1, :b => 2}.to_hstore.from_hstore.should eq({"a" => "1", "b" => "2"})
+  end
+
+  it "should convert hstore string to hash" do
+    '"a"=>"1", "b"=>"2"'.from_hstore.should eq({'a' => '1', 'b' => '2'})
+  end
+ 
+  it "should quote correctly" do
+    {:a => "'a'"}.to_hstore.should eq(%q(a=>'a'))
+  end
+
+  it "should quote keys correctly" do
+    {"'a'" => "a"}.to_hstore.should eq(%q('a'=>a))
+  end
+
+  it "should preserve null values on store" do
+    # NULL=>b will be interpreted as the string pair "NULL"=>"b"
+
+    {'a' => nil,nil=>'b'}.to_hstore.should eq(%q(a=>NULL,NULL=>b))
+  end
+
+  it "should preserve null values on load" do
+    'a=>null,b=>NuLl,c=>"NuLl",null=>c'.from_hstore.should eq({'a'=>nil,'b'=>nil,'c'=>'NuLl','null'=>'c'})
+  end
+
+  it "should quote tokens with nothing space comma equals or greaterthan" do
+    {' '=>''}.to_hstore.should eq(%q(" "=>""))
+    {','=>''}.to_hstore.should eq(%q(","=>""))
+    {'='=>''}.to_hstore.should eq(%q("="=>""))
+    {'>'=>''}.to_hstore.should eq(%q(">"=>""))
+  end
+
+  it "should unquote keys correctly with single quotes" do
+    "\"'a'\"=>\"a\"". from_hstore.should eq({"'a'" => "a"})
+    '\=a=>q=w'.       from_hstore.should eq({"=a"=>"q=w"})
+    '"=a"=>q\=w'.     from_hstore.should eq({"=a"=>"q=w"});
+    '"\"a"=>q>w'.     from_hstore.should eq({"\"a"=>"q>w"});
+    '\"a=>q"w'.       from_hstore.should eq({"\"a"=>"q\"w"})
+  end
+
+  it "should quote keys and values correctly with combinations of single and double quotes" do
+    { %q("a') => %q(b "a' b) }.to_hstore.should eq(%q("\"a'"=>"b \"a' b"))
+  end
+
+  it "should unquote keys and values correctly with combinations of single and double quotes" do
+    %q("\"a'"=>"b \"a' b").from_hstore.should eq({%q("a') => %q(b "a' b)})
+  end
+
+  it "should quote keys and values correctly with backslashes" do
+    { %q(\\) => %q(\\) }.to_hstore.should eq(%q("\\\\"=>"\\\\"))
+  end
+  
+  it "should unquote keys and values correctly with backslashes" do
+    %q("\\\\"=>"\\\\").from_hstore.should eq({ %q(\\) => %q(\\) })
+  end
+
+  it "should quote keys and values correctly with combinations of backslashes and quotes" do
+    { %q(' \\ ") => %q(" \\ ') }.to_hstore.should eq(%q("' \\\\ \""=>"\" \\\\ '"))
+  end
+
+  it "should unquote keys and values correctly with combinations of backslashes and quotes" do
+    %q("' \\\\ \""=>"\" \\\\ '").from_hstore.should eq({ %q(' \\ ") => %q(" \\ ') })
+  end
+
+  it "should convert empty hash" do
+    {}.to_hstore.should eq("")
+  end
+
+  it "should convert empty string" do
+    ''.from_hstore.should eq({})
+    '         '.from_hstore.should eq({})
+  end
+end

data/spec/database.yml.sample

@@ -0,0 +1,7 @@
+postgresql:
+  adapter: postgresql
+  hostname: localhost
+  username: postgres
+  password:
+  database: activerecord_postgres_hstore
+  encoding: utf8

data/spec/models.rb

@@ -0,0 +1,5 @@
+class HstoreModel < ActiveRecord::Base
+end
+
+class NormalModel < ActiveRecord::Base
+end

data/spec/schema.rb

@@ -0,0 +1,14 @@
+ActiveRecord::Schema.define :version => 0 do
+
+  create_table :hstore_models, :force => true do |t|
+    t.column :name, :string
+    t.column :key_value, :hstore
+  end
+
+  execute "create index concurrently idx_hstore_model_key_value on hstore_models using gist (key_value)"
+
+  create_table :normal_models, :force => true do |t|
+    t.column :name, :string
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,61 @@
+$LOAD_PATH << "." unless $LOAD_PATH.include?(".")
+require 'logger'
+
+begin
+  require "rubygems"
+  require "bundler"
+  require 'active_record'
+
+  if Gem::Version.new(Bundler::VERSION) <= Gem::Version.new("0.9.5")
+    raise RuntimeError, "Your bundler version is too old." +
+     "Run `gem install bundler` to upgrade."
+  end
+
+  # Set up load paths for all bundled gems
+  Bundler.setup
+rescue Bundler::GemNotFound
+  raise RuntimeError, "Bundler couldn't find some gems." +
+    "Did you run \`bundlee install\`?"
+end
+
+Bundler.require
+#require File.expand_path('../../lib/activerecord-postgres-hstore-core', __FILE__)
+
+db_name = 'postgresql'
+database_yml = File.expand_path('../database.yml', __FILE__)
+
+if File.exists?(database_yml)
+  active_record_configuration = YAML.load_file(database_yml)
+
+  ActiveRecord::Base.configurations = active_record_configuration
+  config = ActiveRecord::Base.configurations[db_name]
+  
+  begin
+    ActiveRecord::Base.establish_connection(db_name)
+    ActiveRecord::Base.connection
+  rescue
+    ActiveRecord::Base.establish_connection(config.merge('database' => 'postgres', 'schema_search_path' => 'public'))
+    ActiveRecord::Base.connection.create_database(config['database'], config.merge('encoding' => 'utf8'))
+  end
+    
+  ActiveRecord::Base.logger = Logger.new(File.join(File.dirname(__FILE__), "debug.log"))
+  ActiveRecord::Base.default_timezone = :utc
+  
+  ActiveRecord::Base.silence do
+    ActiveRecord::Migration.verbose = false
+    
+    load(File.dirname(__FILE__) + '/schema.rb')
+    load(File.dirname(__FILE__) + '/models.rb')
+  end
+else
+  raise "Please create #{database_yml} first to configure your database. Take a look at: #{database_yml}.sample"
+end
+
+def clean_database!
+  models = [HstoreModel, NormalModel]
+  models.each do |model|
+    ActiveRecord::Base.connection.execute "DELETE FROM #{model.table_name}"
+  end
+end
+
+clean_database!

metadata

@@ -0,0 +1,172 @@
+--- !ruby/object:Gem::Specification 
+name: activerecord-postgres-hstore-core
+version: !ruby/object:Gem::Version 
+  hash: 25
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 3
+  version: 0.0.3
+platform: ruby
+authors: 
+- Jt Gleason
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-02-29 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        version: "3.0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 2
+        - 6
+        version: "2.6"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: ammeter
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 29
+        segments: 
+        - 0
+        - 1
+        - 3
+        version: 0.1.3
+  type: :development
+  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: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: guard
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: guard-rspec
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id006
+description: Allows you to use active record with databases that already have an hstore type
+email: jt@twitch.tv
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Rakefile
+- activerecord-postgres-hstore-core.gemspec
+- lib/activerecord-postgres-hstore-core.rb
+- lib/activerecord-postgres-hstore-core/version.rb
+- lib/activerecord_postgres_hstore_core/activerecord.rb
+- lib/activerecord_postgres_hstore_core/hash.rb
+- lib/activerecord_postgres_hstore_core/string.rb
+- rails/init.rb
+- spec/activerecord_postgres_hstore_core/activerecord_posgres_hstore_database_spec.rb
+- spec/activerecord_postgres_hstore_core/activerecord_postgres_hstore_datatype_spec.rb
+- spec/database.yml.sample
+- spec/models.rb
+- spec/schema.rb
+- spec/spec_helper.rb
+homepage: ""
+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: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Hstore AR for Hstore DB
+test_files: 
+- spec/activerecord_postgres_hstore_core/activerecord_posgres_hstore_database_spec.rb
+- spec/activerecord_postgres_hstore_core/activerecord_postgres_hstore_datatype_spec.rb
+- spec/database.yml.sample
+- spec/models.rb
+- spec/schema.rb
+- spec/spec_helper.rb