activerecord-postgres-hstore 0.6.0 → 0.7.0

data/Gemfile

@@ -3,8 +3,3 @@ source "http://rubygems.org"
 # specify gem dependencies in activerecord-postgres-hstore.gemspec
 # except the platform-specific dependencies below
 gemspec
-
-group :development, :test do
-  gem 'activerecord-jdbcpostgresql-adapter', :platforms => :jruby
-  gem 'pg', :platforms => :ruby
-end

data/README.md

@@ -1,7 +1,4 @@
-[![Build Status](https://secure.travis-ci.org/softa/activerecord-postgres-hstore.png?branch=master)](http://travis-ci.org/softa/activerecord-postgres-hstore)
-
-Goodbye serialize, hello hstore.
---------------------------------
+#Goodbye serialize, hello hstore. [![Build Status](https://secure.travis-ci.org/softa/activerecord-postgres-hstore.png?branch=master)](http://travis-ci.org/softa/activerecord-postgres-hstore)
 
 You need dynamic columns in your tables. What do you do?
 
@@ -9,57 +6,30 @@ You need dynamic columns in your tables. What do you do?
 * 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.
 
-Requirements
-------------
-
-Postgresql 8.4+ with contrib and Rails 3+. (It
-might work on 2.3.x with minor patches…)
-On Ubuntu, this is easy: `sudo apt-get install postgresql-contrib-9.1`
+##Note about 0.7
 
-On Mac you have a couple of options:
+I have decided to clean up the old code and provide only a custom serializer in this new version.
 
-* [the binary package kindly provided by EnterpriseDB](http://www.enterprisedb.com/products-services-training/pgdownload#osx)
-* [Homebrew’s](https://github.com/mxcl/homebrew) Postgres installation also includes the contrib packages: `brew install postgres`
-* [Postgres.app](http://postgresapp.com/)
+In order to acomplish this I had to drop support for older versions of Rails (3.0 and earlier) and also
+remove some monkey patches that added functionality to the Hash, String, and some ActiveRecord objects.
+This monkey patches provided methods such as Hash\#to\_hstore and String\#from\_hstore.
 
-Notes for Rails 3.1 and above
------------------------------
 
-The master branch already support a custom serialization coder.
-If you want to use it just put in your Gemfile:
-
-    gem 'activerecord-postgres-hstore', github: 'engageis/activerecord-postgres-hstore'
-
-If you install them gem from the master branch you also have to insert a
-line in each model that uses hstore.
-Assuming a model called **Person**, with a **data** field on it, the
-code should look like:
-
-    class Person < ActiveRecord::Base
-      serialize :data, ActiveRecord::Coders::Hstore
-    end
-
-If you want a default value (say, an empty hash) you should pass it as an argument when you
-initialize the serializer, like so:
+**If you rely on this feature please stick to 0.6 version** and there is still a branch named 0.6 to which you can submit your pull requests.
 
-    class Person < ActiveRecord::Base
-      serialize :data, ActiveRecord::Coders::Hstore.new({})
-    end
+##Requirements
 
-This way, you will automatically start with an empty hash that you can write attributes to.
+Postgresql 8.4+ with contrib and Rails 3.1+ (If you want to try on older rails versions I recommend the 0.6 and ealier versions of this gem)
+On Ubuntu, this is easy: `sudo apt-get install postgresql-contrib-9.1`
 
-    irb(main):001:0> person = Person.new
-    => #<Person id: nil, name: nil, data: {}, created_at: nil, updated_at: nil>
-    irb(main):002:0> person.data['favorite_color'] = 'blue'
-    => "blue"
+On Mac you have a couple of options:
 
-If you skip this step, you will have to manually initialize the value to an empty hash before
-writing to the attribute, or else you will get an error:
+* [the binary package kindly provided by EnterpriseDB](http://www.enterprisedb.com/products-services-training/pgdownload#osx)
+* [Homebrew’s](https://github.com/mxcl/homebrew) Postgres installation also includes the contrib packages: `brew install postgres`
+* [Postgres.app](http://postgresapp.com/)
 
-    NoMethodError: undefined method `[]=' for nil:NilClass
+##Install
 
-Install
--------
 
 Hstore is a PostgreSQL contrib type, [check it out first](http://www.postgresql.org/docs/9.2/static/hstore.html).
 
@@ -71,23 +41,6 @@ And run your bundler:
 
 `bundle install`
 
-Make sure that you have the desired database, if not create it as the
-desired user:
-
-`createdb hstorage_dev`
-
-Add the parameters to your database.yml (these are system dependant),
-e.g.:
-
-    development:
-      adapter: postgresql
-      host: 127.0.0.1
-      database: hstorage_dev
-      encoding: unicode
-      username: postgres
-      password:
-      pool: 5
-
 Now you need to create a migration that adds hstore support for your
 PostgreSQL database:
 
@@ -105,17 +58,65 @@ Finally you can create your own tables using hstore type. It’s easy:
 You’re done.
 Well, not yet. Don’t forget to add indexes. Like this:
 
-`CREATE INDEX people_gist_data ON people USING GIST(data);`
+```sql CREATE INDEX people_gist_data ON people USING GIST(data);```
 or
-`CREATE INDEX people_gin_data ON people USING GIN(data);`
+```sql CREATE INDEX people_gin_data ON people USING GIN(data);```
+
+This gem provides some functions to generate this kind of index inside your migrations.
+For the model Person we could create an index (defaults to type GIST) over the data field with this migration:
+
+```ruby
+class AddIndexToPeople < ActiveRecord::Migration
+  def change
+    add_hstore_index :people, :data                                                                                                                                
+  end 
+end
+```
 
 To understand the difference between the two types of indexes take a
 look at [PostgreSQL docs](http://www.postgresql.org/docs/9.2/static/textsearch-indexes.html).
 
-Usage
------
+##Usage
+
+This gem only provides a custom serialization coder.
+If you want to use it just put in your Gemfile:
+
+    gem 'activerecord-postgres-hstore'
+
+Now add a line (for each hstore column) on the model you have your hstore columns.
+Assuming a model called **Person**, with a **data** field on it, the
+code should look like:
+
+```ruby
+class Person < ActiveRecord::Base
+  serialize :data, ActiveRecord::Coders::Hstore
+end
+```
+
+If you want a default value (say, an empty hash) you should pass it as an argument when you
+initialize the serializer, like so:
+
+```ruby
+class Person < ActiveRecord::Base
+  serialize :data, ActiveRecord::Coders::Hstore.new({})
+end
+```
+
+This way, you will automatically start with an empty hash that you can write attributes to.
+
+    irb(main):001:0> person = Person.new
+    => #<Person id: nil, name: nil, data: {}, created_at: nil, updated_at: nil>
+    irb(main):002:0> person.data['favorite_color'] = 'blue'
+    => "blue"
 
-Once you have it installed, you just need to learn a little bit of new
+If you skip this step, you will have to manually initialize the value to an empty hash before
+writing to the attribute, or else you will get an error:
+
+    NoMethodError: undefined method `[]=' for nil:NilClass
+
+###Querying the database
+
+Now you just need to learn a little bit of new
 sqls for selecting stuff (creating and updating is transparent).
 Find records that contains a key named 'foo’:
 
@@ -162,8 +163,7 @@ and with many keys:
 
     Person.delete_keys(:data, :foo, :bar)
 
-Caveats
--------
+##Caveats
 
 hstore keys and values have to be strings. This means `true` will become `"true"` and `42` will become `"42"` after you save the record. Only `nil` values are preserved.
 
@@ -178,8 +178,7 @@ To avoid the above, make sure all named parameters are strings:
 
 Have fun.
 
-Test Database
--------------
+##Test Database
 
 To have hstore enabled when you load your database schema (as happens in rake db:test:prepare), you
 have two options.
@@ -195,14 +194,13 @@ This will change your schema dumps from Ruby to SQL. If you're
 unsure about the implications of this change, we suggest reading this
 [Rails Guide](http://guides.rubyonrails.org/migrations.html#schema-dumping-and-you).
 
-Help
-----
+##Help
 
 You can use issues in github for that. Or else you can reach us at
 twitter: [@dbiazus](https://twitter.com/#!/dbiazus) or [@joaomilho](https://twitter.com/#!/joaomilho)
 
-Note on Patches/Pull Requests
------------------------------
+##Note on Patches/Pull Requests
+
 
 * Fork the project.
 * Make your feature addition or bug fix.
@@ -210,7 +208,6 @@ Note on Patches/Pull Requests
 * 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.
 
-Copyright
----------
+##Copyright
 
 Copyright © 2010 Juan Maiz. See LICENSE for details.

data/activerecord-postgres-hstore.gemspec

@@ -4,7 +4,7 @@ $:.unshift lib unless $:.include?(lib)
 
 Gem::Specification.new do |s|
   s.name = "activerecord-postgres-hstore"
-  s.version = "0.6.0"
+  s.version = "0.7.0"
 
   s.platform    = Gem::Platform::RUBY
   s.license     = "MIT"
@@ -19,7 +19,6 @@ Gem::Specification.new do |s|
   s.add_dependency "rails"
   s.add_dependency "rake"
   s.add_development_dependency "bundler"
-  s.add_development_dependency "shoulda"
   s.add_development_dependency "rdoc"
   s.add_development_dependency "rspec", "~> 2.11"
 

data/lib/activerecord-postgres-hstore.rb

@@ -1,11 +1,5 @@
 require 'active_support'
 
-if RUBY_PLATFORM == "jruby"
-  require 'activerecord-jdbcpostgresql-adapter'
-else
-  require 'pg'
-end
-
 if defined? Rails
   require "activerecord-postgres-hstore/railties"
 else
@@ -13,6 +7,4 @@ else
     require "activerecord-postgres-hstore/activerecord"
   end
 end
-require "activerecord-postgres-hstore/string"
-require "activerecord-postgres-hstore/hash"
 require "activerecord-postgres-hstore/coder"

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

@@ -3,7 +3,6 @@ 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:
@@ -65,42 +64,9 @@ module ActiveRecord
       raise "invalid attribute #{attribute}" unless self.class.column_names.include?(attribute.to_s)
       destroy_keys(attribute, *keys).save
     end
-
-    if defined? Rails and Rails.version < '3.1.0'
-      # 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
-
-  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
-
     module SchemaStatements
 
       # Installs hstore by creating the Postgres extension
@@ -175,38 +141,5 @@ module ActiveRecord
       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/coder.rb

@@ -14,11 +14,47 @@ module ActiveRecord
       end
 
       def dump(obj)
-        obj.nil? ? (@default.nil? ? nil : @default.to_hstore) : obj.to_hstore
+        obj.nil? ? (@default.nil? ? nil : to_hstore(@default)) : to_hstore(obj)
       end
 
       def load(hstore)
-        hstore.nil? ? @default : hstore.from_hstore
+        hstore.nil? ? @default : from_hstore(hstore)
+      end
+
+      private
+      # Escapes values such that they will work in an hstore string
+      def hstore_escape(str)
+        return 'NULL' if str.nil?
+        return str if str =~ /^".*"$/
+        '"%s"' % str
+      end
+
+      def to_hstore obj
+        return "" if obj.empty?
+        obj.map do |idx, val| 
+          "%s=>%s" % [hstore_escape(idx), hstore_escape(val)]
+        end * ","
+      end
+
+      def hstore_pair
+        quoted_string = /"[^"\\]*(?:\\.[^"\\]*)*"/
+        unquoted_string = /[^\s=,][^\s=,\\]*(?:\\.[^\s=,\\]*|=[^,>])*/
+        string = /(#{quoted_string}|#{unquoted_string})/
+        /#{string}\s*=>\s*#{string}/
+      end
+
+      def from_hstore hstore
+        token_pairs = (hstore.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 /\A"(.*)"\Z/m then $1.gsub(/\\(.)/, '\1')
+            else t.gsub(/\\(.)/, '\1')
+            end
+          }
+        }
+        Hash[ token_pairs ]
       end
     end
   end

data/spec/activerecord-coders-hstore_spec.rb

@@ -1,27 +1,107 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-describe "ActiverecordCodersHstore" do
-  it 'should load nil' do
-    ActiveRecord::Coders::Hstore.load(nil).should be_nil
-  end
+describe ActiveRecord::Coders::Hstore do
+  describe "#load" do
+    subject{ ActiveRecord::Coders::Hstore.new.load(value) }
 
-  it 'should load an hstore' do
-    ActiveRecord::Coders::Hstore.load("a=>a").should == { 'a' => 'a' }
-  end
+    context 'when value is nil and we have a default in the constructor' do
+      subject{ ActiveRecord::Coders::Hstore.new({'a'=>'a'}).load(nil) }
+      it{ should eql({'a'=>'a'}) }
+    end
+
+    context 'when key and value have newline char' do
+      let(:value){ "\"foo\nbar\"=>\"\nnewline\"" }
+      it{ should eql({"foo\nbar" => "\nnewline"}) }
+    end
+
+    context 'when key and value are empty strings' do
+      let(:value){ %q(""=>"") }
+      it{ should eql({'' => ''}) }
+    end
 
-  it 'should dump an hstore' do
-    ActiveRecord::Coders::Hstore.dump({'a'=>'a'}).should == {'a'=>'a'}.to_hstore
+    context 'when value has single quotes' do
+      let(:value){ %q("'a'"=>"'a'") }
+      it{ should eql({"'a'" => "'a'"}) }
+    end
+
+    context 'when value is empty hash' do
+      let(:value){ '' }
+      it{ should eql({}) }
+    end
+
+    context 'when value is nil' do
+      let(:value){ nil }
+      it { should be_nil }
+    end
+
+    context 'when value is a hstore' do
+      let(:value){ "a=>a" }
+      it{ should eql({ 'a' => 'a' }) }
+    end
   end
 
-  it 'should dump nil' do
-    ActiveRecord::Coders::Hstore.dump(nil).should be_nil
+  describe "#dump" do
+    subject{ ActiveRecord::Coders::Hstore.new.dump(value) }
+
+    context 'when value is nil and we have a default in the constructor' do
+      subject{ ActiveRecord::Coders::Hstore.new({'a'=>'a'}).dump(nil) }
+      it{ should eql('"a"=>"a"') }
+    end
+
+    context 'when key and value have newline char' do
+      let(:value){ {"foo\nbar" => "\nnewline"} }
+      it{ should eql("\"foo\nbar\"=>\"\nnewline\"") }
+    end
+
+    context 'when key and value are empty strings' do
+      let(:value){ {'' => ''} }
+      it{ should eql(%q(""=>"")) }
+    end
+
+    context 'when value has single quotes' do
+      let(:value){ {"'a'" => "'a'"} }
+      it{ should eql(%q("'a'"=>"'a'")) }
+    end
+
+    context 'when value is empty hash' do
+      let(:value){ {} }
+      it{ should eql('') }
+    end
+
+    context 'when value is nil' do
+      let(:value){ nil }
+      it{ should be_nil }
+    end
+
+    context "when value is an hstore" do
+      let(:value){ {'a' => 'a'} }
+      it{ should eql('"a"=>"a"') }
+    end
   end
 
-  it 'should dump the default given nil' do
-    ActiveRecord::Coders::Hstore.new({'a'=>'a'}).dump(nil).should == {'a'=>'a'}.to_hstore
+  describe ".load" do
+    before do
+      @parameter = 'b=>b'
+      instance = double("coder instance")
+      instance.should_receive(:load).with(@parameter)
+      ActiveRecord::Coders::Hstore.should_receive(:new).and_return(instance)
+    end
+
+    it("should instantiate and call load") do
+      ActiveRecord::Coders::Hstore.load(@parameter)
+    end
   end
 
-  it 'should load the default given nil' do
-    ActiveRecord::Coders::Hstore.new({'a'=>'a'}).load(nil).should eql({'a'=>'a'})
+  describe ".dump" do
+    before do
+      @parameter = {'b' => 'b'}
+      instance = double("coder instance")
+      instance.should_receive(:dump).with(@parameter)
+      ActiveRecord::Coders::Hstore.should_receive(:new).and_return(instance)
+    end
+
+    it("should instantiate and call dump") do
+      ActiveRecord::Coders::Hstore.dump(@parameter)
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-postgres-hstore
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-03 00:00:00.000000000 Z
+date: 2013-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -60,22 +60,6 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: shoulda
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
@@ -128,13 +112,10 @@ files:
 - lib/activerecord-postgres-hstore.rb
 - lib/activerecord-postgres-hstore/activerecord.rb
 - lib/activerecord-postgres-hstore/coder.rb
-- lib/activerecord-postgres-hstore/hash.rb
 - lib/activerecord-postgres-hstore/railties.rb
-- lib/activerecord-postgres-hstore/string.rb
 - lib/templates/setup_hstore.rb
 - lib/templates/setup_hstore91.rb
 - spec/activerecord-coders-hstore_spec.rb
-- spec/activerecord-postgres-hstore_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/softa/activerecord-postgres-hstore
 licenses:

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

@@ -1,39 +0,0 @@
-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/string.rb

@@ -1,43 +0,0 @@
-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 /\A"(.*)"\Z/m 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/spec/activerecord-postgres-hstore_spec.rb

@@ -1,104 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe "ActiverecordPostgresHstore" 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
-
-  it "should not change values with line breaks" do
-    input = { "a" => "foo\n\nbar" }
-    output = input.to_hstore
-    output.from_hstore.should eq(input)
-  end
-  
-end