activerecord-postgres-hstore 0.0.1

data/.document

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

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Juan Maiz
+
+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.textile

@@ -0,0 +1,109 @@
+.h2 Goodbye serialize, hello hstore.
+
+You need dynamic columns in your tables. What do you do?
+
+ * Create lots of tables to handle it.
+   Nice, now you'll need more models and lots of additional sqls. Insertion and selection will be slow as hell.
+
+ * Use a noSQL database just for this issue.
+   Good luck.
+
+ * Create a serialized column.
+   Nice, insertion will be fine, and reading data from a record too. But, what if you have a condition in your select that includes serialized data? Yeah, regular expressions.
+
+!https://spreadsheets.google.com/oimg?key=0AoQcKrACYfGjdGRVV3cyTDZYQkJMa255VkxxQW9LTHc&oid=1&zx=ksfsz3-j87df5!
+
+|action|serialize|hstore|serialize sql|hstore sql|
+|count all with condition|10114,575|1830,444|SELECT count(*) FROM foos WHERE data ~ 'foo: bar';|SELECT count(*) FROM bars WHERE data @> 'foo=>bar';|
+|count all with negative condition|18722,149|1677,948|SELECT count(*) FROM foos WHERE data !~ 'another key: 9999990';|SELECT count(*) FROM bars WHERE not data @> '"another key"=>9999990';|
+|find one with condition|17740,307|130,227|SELECT count(*) FROM foos WHERE data ~ 'another key: 9999990';|SELECT * FROM bars WHERE data @> '"another key"=>9999990'|
+
+Benchmarks made in my local machine, time in milliseconds.
+
+.h2 Requirements
+
+Postgresql 8.4 with contrib and Rails 3. (It might work on 2.3.x with minor patches...)
+
+.h2 Install
+
+Hstore is a postgres contrib type. Check it out first:
+
+http://www.postgresql.org/docs/8.4/static/hstore.html
+
+Then, just add this to your Gemfile:
+
+gem 'activerecord-postgres-hstore'
+
+And run your bundler:
+
+bundle install
+
+Now you need to create a migration that adds hstore support for your postgresql database:
+
+rails g railtie:hstore
+
+Run it:
+
+rake db:migrate
+
+Finally you can create your own tables using hstore type. It's easy:
+
+rails g model Person name:string data:hstore
+
+You're done.
+
+Well, not yet. Don't forget to add indexes. Like this:
+
+CREATE INDEX people_gist_data ON people USING GIST(data);
+-- or
+CREATE INDEX people_gin_data ON people USING GIN(data);
+
+To my experience GIN is faster for searching records.
+
+.h2 Usage
+
+Once you have it installed, you just need to learn a little bit of new sqls for selecting stuff (creting and updating is transparent).
+
+Find records that contains a key named 'foo':
+
+Person.where("data ? 'foo'")
+
+Find records where 'foo' is equal to 'bar':
+
+Person.where("data -> 'foo' = 'bar'")
+
+This same sql is at least twice as fast (using indexes) if you do it that way:
+
+Person.where("data @> 'foo=>bar'")
+
+Find records where 'foo' is not equal to 'bar':
+
+Person.where("data -> 'foo' <> 'bar'")
+# or
+Person.where("not data @> 'foo=>bar'")
+
+Find records where 'foo' is like 'bar':
+
+Person.where("data -> 'foo' LIKE '%bar%'")
+# or something like ...
+Person.where("data -> 'foo' ILIKE '%bar%'")
+
+Have fun.
+
+.h2 Help
+
+You can use issues in github for that. Or else you can reach me at twitter: @joaomilho
+
+.h2 Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+.h2 Copyright
+
+Copyright (c) 2010 Juan Maiz. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,44 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "activerecord-postgres-hstore"
+    gem.summary = %Q{Goodbye serialize, hello hstore}
+    gem.description = %Q{This gem adds support for the postgres hstore type. It is the _just right_ alternative for storing hashes instead of using seralization or dynamic tables.}
+    gem.email = "juanmaiz@gmail.com"
+    gem.homepage = "http://github.com/softa/activerecord-postgres-hstore"
+    gem.authors = ["Juan Maiz"]
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    gem.files = FileList['.document', '.gitignore', 'LICENSE', 'README.rdoc', 'Rakefile', 'VERSION', 'spec/**/*_spec.rb', 'lib/**/*.rb'].to_a
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "activerecord-postgres-hstore #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

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

data/lib/activerecord-postgres-hstore.rb

@@ -0,0 +1,42 @@
+#raise ActiveRecord::ConnectionAdapters::Column.inspect
+require 'rails'
+require 'rails/generators'
+require 'rails/generators/migration'
+class Railtie < Rails::Railtie
+  initializer 'activerecord-postgres-hstore' do
+    ActiveSupport.on_load :active_record do
+      require "activerecord-postgres-hstore/activerecord"
+    end
+  end
+  #rake_tasks do
+  #  load "lib/tasks/hstore.rake"
+  #end
+  class HstoreGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+
+    def self.source_root
+      @source_root ||= File.join(File.dirname(__FILE__), 'templates')
+    end
+
+    def self.next_migration_number(dirname)
+      if ActiveRecord::Base.timestamped_migrations
+        Time.now.utc.strftime("%Y%m%d%H%M%S")
+      else
+        "%.3d" % (current_migration_number(dirname) + 1)
+      end
+    end
+
+    def create_migration_file
+      migration_template 'setup_hstore.rb', 'db/migrate/setup_hstore.rb'
+    end
+
+  end
+end
+
+
+
+
+
+require "activerecord-postgres-hstore/hstore"
+require "activerecord-postgres-hstore/string"
+require "activerecord-postgres-hstore/hash"

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

@@ -0,0 +1,68 @@
+# ActiveRecord::ConnectionAdapters::PostgreSQLColumn.new('data','','hstore').type
+module ActiveRecord
+  class Base
+    # For Rails 3 compat :D
+    #alias :old_arel_attributes_values :arel_attributes_values
+    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 value && ((self.class.serialized_attributes.has_key?(name) && (value.acts_like?(:date) || value.acts_like?(:time))) || value.is_a?(Hash) || value.is_a?(Array))
+              if self.class.columns_hash[name].type == :hstore
+                value = value.to_hstore # Done!
+              else
+                value = value.to_yaml
+              end
+            end
+            attrs[self.class.arel_table[name]] = value
+          end
+        end
+      end
+      attrs
+    end
+  end
+  class HstoreTypeMismatch < ActiveRecord::ActiveRecordError
+  end
+  module ConnectionAdapters
+  
+    class TableDefinition
+      # Adds hstore type for migrations
+      def hstore(*args)
+        options = args.extract_options!
+        column_names = args
+        column_names.each { |name| column(name, 'hstore', options) }
+      end
+    end
+
+    class PostgreSQLColumn < Column
+      alias :old_type_cast_code :type_cast_code
+      alias :old_simplified_type :simplified_type
+      alias :old_klass :klass
+      def type_cast_code(var_name)
+        type == :hstore ? "#{var_name}.from_hstore" : old_type_cast_code(var_name)
+      end
+      def simplified_type(field_type)
+        field_type =~ /^hstore$/ ? :hstore : old_simplified_type(field_type)
+      end
+      def klass
+        type == :hstore ? Hstore : old_klass   
+      end
+    end
+    class PostgreSQLAdapter < AbstractAdapter
+      alias :old_quote :quote
+      def quote(value, column = nil)
+        if value && column && column.sql_type =~ /^hstore$/
+          if ! value.kind_of?(Hash) and ! value.valid_hstore?
+            raise HstoreTypeMismatch, "#{column.name} must have a Hash or a valid hstore value (#{value})"
+          end
+          return value.to_hstore
+        end
+        old_quote(value,column)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+class Hash
+
+  def to_hstore
+    #@todo DIOGO! Check security issues with this quoting pleaz
+    map{|idx,val| "('#{idx}'=>'#{val.to_s.gsub(/'/,"''")}')"  }.join(' || ')
+  end
+
+  def from_hstore
+    self
+  end
+
+end

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

@@ -0,0 +1,2 @@
+class Hstore < Hash
+end

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

@@ -0,0 +1,22 @@
+class String
+
+  def to_hstore
+    self
+  end
+
+  def valid_hstore?
+    # This is what comes from the database
+    dbl_quotes_re = /"([^"]+)"=>"([^"]+)"/
+    # TODO
+    # This is what comes from the plugin
+    # this is a big problem, 'cause regexes does not know how to count...
+    # how should i very values quoted with two single quotes? using .+ sux.
+    sngl_quotes_re = /'(.+)'=>'(.+)'/
+    self.match(dbl_quotes_re) || self.match(sngl_quotes_re)
+  end
+
+  def from_hstore
+    Hash[ scan(/"([^"]+)"=>"([^"]+)"/) ]
+  end
+
+end

data/lib/templates/setup_hstore.rb

@@ -0,0 +1,277 @@
+class SetupHstore < ActiveRecord::Migration
+  def self.up
+    sql = <<-HSTORE_SQL
+/* $PostgreSQL: pgsql/contrib/hstore/hstore.sql.in,v 1.11 2009/06/11 18:30:03 tgl Exp $ */
+
+-- Adjust this setting to control where the objects get created.
+SET search_path = public;
+
+CREATE TYPE hstore;
+
+CREATE OR REPLACE FUNCTION hstore_in(cstring)
+RETURNS hstore
+AS '$libdir/hstore'
+LANGUAGE C STRICT;
+
+CREATE OR REPLACE FUNCTION hstore_out(hstore)
+RETURNS cstring
+AS '$libdir/hstore'
+LANGUAGE C STRICT;
+
+CREATE TYPE hstore (
+        INTERNALLENGTH = -1,
+        INPUT = hstore_in,
+        OUTPUT = hstore_out,
+        STORAGE = extended
+);
+
+CREATE OR REPLACE FUNCTION fetchval(hstore,text)
+RETURNS text
+AS '$libdir/hstore'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OPERATOR -> (
+	LEFTARG = hstore,
+	RIGHTARG = text,
+	PROCEDURE = fetchval
+);
+
+CREATE OR REPLACE FUNCTION isexists(hstore,text)
+RETURNS bool
+AS '$libdir/hstore','exists'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION exist(hstore,text)
+RETURNS bool
+AS '$libdir/hstore','exists'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OPERATOR ? (
+	LEFTARG = hstore,
+	RIGHTARG = text,
+	PROCEDURE = exist,
+	RESTRICT = contsel,
+	JOIN = contjoinsel
+);
+
+CREATE OR REPLACE FUNCTION isdefined(hstore,text)
+RETURNS bool
+AS '$libdir/hstore','defined'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION defined(hstore,text)
+RETURNS bool
+AS '$libdir/hstore','defined'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION delete(hstore,text)
+RETURNS hstore
+AS '$libdir/hstore','delete'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION hs_concat(hstore,hstore)
+RETURNS hstore
+AS '$libdir/hstore'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OPERATOR || (
+	LEFTARG = hstore,
+	RIGHTARG = hstore,
+	PROCEDURE = hs_concat
+);
+
+CREATE OR REPLACE FUNCTION hs_contains(hstore,hstore)
+RETURNS bool
+AS '$libdir/hstore'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION hs_contained(hstore,hstore)
+RETURNS bool
+AS '$libdir/hstore'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OPERATOR @> (
+	LEFTARG = hstore,
+	RIGHTARG = hstore,
+	PROCEDURE = hs_contains,
+	COMMUTATOR = '<@',
+	RESTRICT = contsel,
+	JOIN = contjoinsel
+);
+
+CREATE OPERATOR <@ (
+	LEFTARG = hstore,
+	RIGHTARG = hstore,
+	PROCEDURE = hs_contained,
+	COMMUTATOR = '@>',
+	RESTRICT = contsel,
+	JOIN = contjoinsel
+);
+
+-- obsolete:
+CREATE OPERATOR @ (
+	LEFTARG = hstore,
+	RIGHTARG = hstore,
+	PROCEDURE = hs_contains,
+	COMMUTATOR = '~',
+	RESTRICT = contsel,
+	JOIN = contjoinsel
+);
+
+CREATE OPERATOR ~ (
+	LEFTARG = hstore,
+	RIGHTARG = hstore,
+	PROCEDURE = hs_contained,
+	COMMUTATOR = '@',
+	RESTRICT = contsel,
+	JOIN = contjoinsel
+);
+
+CREATE OR REPLACE FUNCTION tconvert(text,text)
+RETURNS hstore
+AS '$libdir/hstore'
+LANGUAGE C IMMUTABLE; -- not STRICT
+
+CREATE OPERATOR => (
+	LEFTARG = text,
+	RIGHTARG = text,
+	PROCEDURE = tconvert
+);
+
+CREATE OR REPLACE FUNCTION akeys(hstore)
+RETURNS _text
+AS '$libdir/hstore'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION avals(hstore)
+RETURNS _text
+AS '$libdir/hstore'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION skeys(hstore)
+RETURNS setof text
+AS '$libdir/hstore'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION svals(hstore)
+RETURNS setof text
+AS '$libdir/hstore'
+LANGUAGE C STRICT IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION each(IN hs hstore,
+    OUT key text,
+    OUT value text)
+RETURNS SETOF record
+AS '$libdir/hstore'
+LANGUAGE C STRICT IMMUTABLE;
+
+
+
+-- define the GiST support methods
+
+CREATE TYPE ghstore;
+
+CREATE OR REPLACE FUNCTION ghstore_in(cstring)
+RETURNS ghstore
+AS '$libdir/hstore'
+LANGUAGE C STRICT;
+
+CREATE OR REPLACE FUNCTION ghstore_out(ghstore)
+RETURNS cstring
+AS '$libdir/hstore'
+LANGUAGE C STRICT;
+
+CREATE TYPE ghstore (
+        INTERNALLENGTH = -1,
+        INPUT = ghstore_in,
+        OUTPUT = ghstore_out
+);
+
+CREATE OR REPLACE FUNCTION ghstore_compress(internal)
+RETURNS internal
+AS '$libdir/hstore'
+LANGUAGE C IMMUTABLE STRICT;
+
+CREATE OR REPLACE FUNCTION ghstore_decompress(internal)
+RETURNS internal
+AS '$libdir/hstore'
+LANGUAGE C IMMUTABLE STRICT;
+
+CREATE OR REPLACE FUNCTION ghstore_penalty(internal,internal,internal)
+RETURNS internal
+AS '$libdir/hstore'
+LANGUAGE C IMMUTABLE STRICT;
+
+CREATE OR REPLACE FUNCTION ghstore_picksplit(internal, internal)
+RETURNS internal
+AS '$libdir/hstore'
+LANGUAGE C IMMUTABLE STRICT;
+
+CREATE OR REPLACE FUNCTION ghstore_union(internal, internal)
+RETURNS internal
+AS '$libdir/hstore'
+LANGUAGE C IMMUTABLE STRICT;
+
+CREATE OR REPLACE FUNCTION ghstore_same(internal, internal, internal)
+RETURNS internal
+AS '$libdir/hstore'
+LANGUAGE C IMMUTABLE STRICT;
+
+CREATE OR REPLACE FUNCTION ghstore_consistent(internal,internal,int,oid,internal)
+RETURNS bool
+AS '$libdir/hstore'
+LANGUAGE C IMMUTABLE STRICT;
+
+-- register the opclass for indexing (not as default)
+CREATE OPERATOR CLASS gist_hstore_ops
+DEFAULT FOR TYPE hstore USING gist
+AS
+       	OPERATOR        7       @> ,
+       	OPERATOR        9       ?(hstore,text) ,
+        --OPERATOR        8       <@ ,
+        OPERATOR        13      @ ,
+        --OPERATOR        14      ~ ,
+        FUNCTION        1       ghstore_consistent (internal, internal, int, oid, internal),
+        FUNCTION        2       ghstore_union (internal, internal),
+        FUNCTION        3       ghstore_compress (internal),
+        FUNCTION        4       ghstore_decompress (internal),
+        FUNCTION        5       ghstore_penalty (internal, internal, internal),
+        FUNCTION        6       ghstore_picksplit (internal, internal),
+        FUNCTION        7       ghstore_same (internal, internal, internal),
+        STORAGE         ghstore;
+
+-- define the GIN support methods
+
+CREATE OR REPLACE FUNCTION gin_extract_hstore(internal, internal)
+RETURNS internal
+AS '$libdir/hstore'
+LANGUAGE C IMMUTABLE STRICT;
+
+CREATE OR REPLACE FUNCTION gin_extract_hstore_query(internal, internal, int2, internal, internal)
+RETURNS internal
+AS '$libdir/hstore'
+LANGUAGE C IMMUTABLE STRICT;
+
+CREATE OR REPLACE FUNCTION gin_consistent_hstore(internal, int2, internal, int4, internal, internal)
+RETURNS bool
+AS '$libdir/hstore'
+LANGUAGE C IMMUTABLE STRICT;
+
+CREATE OPERATOR CLASS gin_hstore_ops
+DEFAULT FOR TYPE hstore USING gin
+AS
+	OPERATOR        7       @> ,
+	OPERATOR        9       ?(hstore,text),
+	FUNCTION        1       bttextcmp(text,text),
+	FUNCTION        2       gin_extract_hstore(internal, internal),
+	FUNCTION        3       gin_extract_hstore_query(internal, internal, int2, internal, internal),
+	FUNCTION        4       gin_consistent_hstore(internal, int2, internal, int4, internal, internal),
+STORAGE         text;
+HSTORE_SQL
+    execute sql
+  end
+
+  def self.down
+    # Kinda... hard.
+  end
+end

data/spec/activerecord-postgres-hstore_spec.rb

@@ -0,0 +1,39 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "ActiverecordPostgresHstore" do
+  it "should convert hstore string to hash" do
+    {:a => 1, :b => 2}.to_hstore.should == "('a'=>'1') || ('b'=>'2')"
+  end
+
+  it "should convert hash to hstore string" do
+    '"a"=>"1", "b"=>"2"'.from_hstore.should == {'a' => '1', 'b' => '2'}
+  end
+ 
+  it "should quote correctly" do
+    {:a => "'a'"}.to_hstore.should == "('a'=>'''a''')"
+  end
+  
+end
+
+=begin
+
+  #---
+
+  test "should create contact" do
+    assert Contact.make :dynamic_values => {:a => 1, :b => 2}
+  end
+
+  test "should raise HstoreTypeMismatch" do
+    assert_raises ActiveRecord::HstoreTypeMismatch do
+      assert Contact.make :dynamic_values => "bug"
+    end
+  end
+
+  test "should read values from contact" do
+    contact = Contact.make :dynamic_values => {:a => 1, :b => "Lorem ipsum", 'other stuff' => "'''a'''"}
+    assert_equal({'a' => '1', 'b' => 'Lorem ipsum', 'other stuff' => "'''a'''"}, Contact.find(contact.id).dynamic_values)
+  end
+
+end
+
+=end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'activerecord-postgres-hstore'
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+  
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: activerecord-postgres-hstore
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Juan Maiz
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-09-08 00:00:00 -03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 2
+        - 9
+        version: 1.2.9
+  type: :development
+  version_requirements: *id001
+description: This gem adds support for the postgres hstore type. It is the _just right_ alternative for storing hashes instead of using seralization or dynamic tables.
+email: juanmaiz@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.textile
+files: 
+- .document
+- .gitignore
+- LICENSE
+- Rakefile
+- VERSION
+- lib/activerecord-postgres-hstore.rb
+- lib/activerecord-postgres-hstore/activerecord.rb
+- lib/activerecord-postgres-hstore/hash.rb
+- lib/activerecord-postgres-hstore/hstore.rb
+- lib/activerecord-postgres-hstore/string.rb
+- lib/templates/setup_hstore.rb
+- spec/activerecord-postgres-hstore_spec.rb
+- README.textile
+has_rdoc: true
+homepage: http://github.com/softa/activerecord-postgres-hstore
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Goodbye serialize, hello hstore
+test_files: 
+- spec/spec_helper.rb
+- spec/activerecord-postgres-hstore_spec.rb