activerecord-postgres-hstore 0.1.2 → 0.3.0

data/VERSION

@@ -1 +1 @@
-0.1.2
+0.3.0

data/activerecord-postgres-hstore.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{activerecord-postgres-hstore}
-  s.version = "0.1.2"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Juan Maiz", "Diogo Biazus"]
-  s.date = %q{2011-08-02}
+  s.date = %q{2011-12-28}
   s.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.}
   s.email = %q{juanmaiz@gmail.com}
   s.extra_rdoc_files = [
@@ -84,6 +84,7 @@ Gem::Specification.new do |s|
     "lib/activerecord-postgres-hstore/hash.rb",
     "lib/activerecord-postgres-hstore/string.rb",
     "lib/templates/setup_hstore.rb",
+    "lib/templates/setup_hstore91.rb",
     "spec/activerecord-postgres-hstore_spec.rb",
     "spec/spec_helper.rb"
   ]

data/app/Gemfile

@@ -2,7 +2,7 @@ source 'http://rubygems.org'
 
 gem 'rails', '3.0.0'
 gem 'pg'
-gem 'activerecord-postgres-hstore', '0.0.2'
+gem 'activerecord-postgres-hstore', :path => '../'
 
 # Use unicorn as the web server
 # gem 'unicorn'

data/app/Gemfile.lock

@@ -1,3 +1,10 @@
+PATH
+  remote: ../
+  specs:
+    activerecord-postgres-hstore (0.1.2)
+      activerecord
+      rake
+
 GEM
   remote: http://rubygems.org/
   specs:
@@ -24,7 +31,6 @@ GEM
       activesupport (= 3.0.0)
       arel (~> 1.0.0)
       tzinfo (~> 0.3.23)
-    activerecord-postgres-hstore (0.0.2)
     activeresource (3.0.0)
       activemodel (= 3.0.0)
       activesupport (= 3.0.0)
@@ -70,6 +76,6 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
-  activerecord-postgres-hstore (= 0.0.2)
+  activerecord-postgres-hstore!
   pg
   rails (= 3.0.0)

data/app/config/application.rb

@@ -38,5 +38,6 @@ module Benchs
 
     # Configure sensitive parameters which will be filtered from the log file.
     config.filter_parameters += [:password]
+    config.active_record.schema_format = :sql
   end
 end

data/app/db/development_structure.sql

@@ -267,6 +267,15 @@ CREATE FUNCTION hs_contains(hstore, hstore) RETURNS boolean
     AS '$libdir/hstore', 'hs_contains';
 
 
+--
+-- Name: hstore(text, text); Type: FUNCTION; Schema: public; Owner: -
+--
+
+CREATE FUNCTION hstore(text, text) RETURNS hstore
+    LANGUAGE c IMMUTABLE
+    AS '$libdir/hstore', 'tconvert';
+
+
 --
 -- Name: isdefined(hstore, text); Type: FUNCTION; Schema: public; Owner: -
 --
@@ -553,13 +562,6 @@ ALTER TABLE ONLY foos
     ADD CONSTRAINT foos_pkey PRIMARY KEY (id);
 
 
---
--- Name: bars_gin_data; Type: INDEX; Schema: public; Owner: -; Tablespace: 
---
-
-CREATE INDEX bars_gin_data ON bars USING gin (data);
-
-
 --
 -- Name: unique_schema_migrations; Type: INDEX; Schema: public; Owner: -; Tablespace: 
 --
@@ -571,8 +573,8 @@ CREATE UNIQUE INDEX unique_schema_migrations ON schema_migrations USING btree (v
 -- PostgreSQL database dump complete
 --
 
-INSERT INTO schema_migrations (version) VALUES ('20100906191151');
-
 INSERT INTO schema_migrations (version) VALUES ('20100906191457');
 
-INSERT INTO schema_migrations (version) VALUES ('20100906191506');
+INSERT INTO schema_migrations (version) VALUES ('20100906191506');
+
+INSERT INTO schema_migrations (version) VALUES ('20100906191151');

data/app/db/schema.rb

@@ -11,5 +11,17 @@
 # It's strongly recommended to check this file into your version control system.
 
 ActiveRecord::Schema.define(:version => 20100906191506) do
-  execute File.read("#{Rails.root}/db/development_structure.sql")
+
+  create_table "bars", :force => true do |t|
+    t.hstore   "data"
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+
+  create_table "foos", :force => true do |t|
+    t.text     "data"
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+
 end

data/lib/activerecord-postgres-hstore.rb

@@ -1,6 +1,7 @@
 require 'rails'
 require 'rails/generators'
 require 'rails/generators/migration'
+require 'pg'
 
 # = Hstore Railtie
 #
@@ -39,10 +40,15 @@ class Hstore < Rails::Railtie
     end
 
     def create_migration_file
-      migration_template 'setup_hstore.rb', 'db/migrate/setup_hstore.rb'
+      pgversion = ActiveRecord::Base.connection.send(:postgresql_version)
+      if pgversion < 90100
+        migration_template 'setup_hstore.rb', 'db/migrate/setup_hstore.rb'
+      else
+        migration_template 'setup_hstore91.rb', 'db/migrate/setup_hstore.rb'
+      end
     end
 
   end
 end
 require "activerecord-postgres-hstore/string"
-require "activerecord-postgres-hstore/hash"
+require "activerecord-postgres-hstore/hash"

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

@@ -77,12 +77,10 @@ module ActiveRecord
         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
+            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
@@ -118,39 +116,36 @@ module ActiveRecord
     end
 
     class PostgreSQLColumn < Column
-      alias :old_type_cast_code :type_cast_code
-      alias :old_simplified_type :simplified_type
-
       # Does the type casting from hstore columns using String#from_hstore or Hash#from_hstore.
-      def type_cast_code(var_name)
-        type == :hstore ? "#{var_name}.from_hstore" : old_type_cast_code(var_name)
+      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(field_type)
-        field_type =~ /^hstore$/ ? :hstore : old_simplified_type(field_type)
+      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
-
-      alias :old_quote :quote
-      alias :old_columns :columns
-      alias :old_native_database_types :native_database_types
-    
-      def native_database_types
-        old_native_database_types.merge({:hstore => { :name => "hstore" }})
+      def native_database_types_with_hstore
+        native_database_types_without_hstore.merge({:hstore => { :name => "hstore" }})
       end
 
       # Quotes correctly a hstore column value.
-      def quote(value, column = nil)
-        if value && column && column.sql_type =~ /^hstore$/
+      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 value.to_hstore
+          return quote_without_hstore(value.to_hstore, column)
         end
-        old_quote(value,column)
+        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/hash.rb

@@ -1,11 +1,24 @@
 class Hash
 
-  # Generates a single quoted hstore string format. This is the format used
+  # Generates an hstore string format. This is the format used
   # to insert or update stuff in the database.
   def to_hstore
-    return "''" if empty?
-    #@todo DIOGO! Check security issues with this quoting pleaz
-    map{|idx, val| "('#{idx.to_s.escape_quotes}'=>'#{val.to_s.escape_quotes}')"  }.join(' || ')
+    return "" if empty?
+
+    map { |idx, val| 
+      iv = [idx,val].map { |_| 
+        e = _.to_s.gsub(/"/, '\"')
+        if _.nil?
+          'NULL'
+        elsif e =~ /[,\s=>]/ || e.blank?
+          '"%s"' % e
+        else
+          e
+        end
+      }
+
+      "%s=>%s" % iv
+    } * ","
   end
 
   # If the method from_hstore is called in a Hash, it just returns self.

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

@@ -9,27 +9,35 @@ class String
   # 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'). I'll call it a "single 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?
-    return true if empty? || self == "''"
-    # 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)
+    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
-    Hash[ scan(/"([^"]+)"=>"([^"]+)"/) ]
+    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
 
-  def escape_quotes
-    self.gsub(/'/,"''")
-  end
+  private
 
+  def hstore_pair
+    quoted_string = /"[^"\\]*(?:\\.[^"\\]*)*"/
+    unquoted_string = /[^\s=,][^\s=,\\]*(?:\\.[^\s=,\\]*|=[^,>])*/
+    string = /(#{quoted_string}|#{unquoted_string})/
+    /#{string}\s*=>\s*#{string}/
+  end
 end

data/lib/templates/setup_hstore91.rb

@@ -0,0 +1,9 @@
+class SetupHstore < ActiveRecord::Migration
+  def self.up
+    execute "CREATE EXTENSION hstore"
+  end
+
+  def self.down
+    execute "DROP EXTENSION hstore"
+  end
+end

data/spec/activerecord-postgres-hstore_spec.rb

@@ -1,9 +1,28 @@
 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" do
-    ["('a'=>'1') || ('b'=>'2')", "('b'=>'2') || ('a'=>'1')"].should include({:a => 1, :b => 2}.to_hstore)
+  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
@@ -11,23 +30,53 @@ describe "ActiverecordPostgresHstore" do
   end
  
   it "should quote correctly" do
-    {:a => "'a'"}.to_hstore.should eq("('a'=>'''a''')")
+    {:a => "'a'"}.to_hstore.should eq(%q(a=>'a'))
   end
 
   it "should quote keys correctly" do
-    {"'a'" => "a"}.to_hstore.should  eq("('''a'''=>'a')")
+    {"'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 correctly" do
-    "\"'a'\"=>\"a\"".from_hstore.should eq({"'a'" => "a"})
+  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 convert empty hash" do
-    {}.to_hstore.should eq("''")
+    {}.to_hstore.should eq("")
   end
 
   it "should convert empty string" do
     ''.from_hstore.should eq({})
+    '         '.from_hstore.should eq({})
   end
   
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: activerecord-postgres-hstore
 version: !ruby/object:Gem::Version 
-  hash: 31
+  hash: 19
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 2
-  version: 0.1.2
+  - 3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Juan Maiz
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-08-02 00:00:00 -03:00
+date: 2011-12-28 00:00:00 -02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -198,6 +198,7 @@ files:
 - lib/activerecord-postgres-hstore/hash.rb
 - lib/activerecord-postgres-hstore/string.rb
 - lib/templates/setup_hstore.rb
+- lib/templates/setup_hstore91.rb
 - spec/activerecord-postgres-hstore_spec.rb
 - spec/spec_helper.rb
 has_rdoc: true