hstore_accessor 0.6.1 → 0.9.0

data/lib/hstore_accessor.rb

@@ -1,10 +1,16 @@
+require "active_support"
+require "active_record"
 require "hstore_accessor/version"
-require "hstore_accessor/type_helpers"
+
+if ::ActiveRecord::VERSION::STRING.to_f >= 4.2
+  require "hstore_accessor/active_record_4.2/type_helpers"
+else
+  require "hstore_accessor/active_record_<_4.2/type_helpers"
+  require "hstore_accessor/active_record_<_4.2/time_helper"
+end
+
 require "hstore_accessor/serialization"
 require "hstore_accessor/macro"
-require "hstore_accessor/time_helper"
-require "active_support"
-require "active_record"
 require "bigdecimal"
 
 module HstoreAccessor

data/lib/hstore_accessor/active_record_4.2/type_helpers.rb

@@ -0,0 +1,34 @@
+module HstoreAccessor
+  module TypeHelpers
+    TYPES = {
+      boolean: ActiveRecord::Type::Boolean,
+      date: ActiveRecord::Type::Date,
+      datetime: ActiveRecord::Type::DateTime,
+      decimal: ActiveRecord::Type::Decimal,
+      float: ActiveRecord::Type::Float,
+      integer: ActiveRecord::Type::Integer,
+      string: ActiveRecord::Type::String
+    }
+
+    TYPES.default = ActiveRecord::Type::Value
+
+    class << self
+      def column_type_for(attribute, data_type)
+        ActiveRecord::ConnectionAdapters::Column.new(attribute.to_s, nil, TYPES[data_type].new)
+      end
+
+      def cast(type, value)
+        return nil if value.nil?
+
+        case type
+        when :string, :hash, :array, :decimal
+          value
+        when :integer, :float, :datetime, :date, :boolean
+          TYPES[type].new.type_cast_from_user(value)
+        else value
+          # Nothing.
+        end
+      end
+    end
+  end
+end

data/lib/hstore_accessor/{time_helper.rb → active_record_<_4.2/time_helper.rb}

@@ -1,6 +1,5 @@
 module HstoreAccessor
   module TimeHelper
-
     # There is a bug in ActiveRecord::ConnectionAdapters::Column#string_to_time
     # which drops the timezone. This has been fixed, but not released.
     # This method includes the fix. See: https://github.com/rails/rails/pull/12290
@@ -11,10 +10,10 @@ module HstoreAccessor
 
       time_hash = Date._parse(string)
       time_hash[:sec_fraction] = ActiveRecord::ConnectionAdapters::Column.send(:microseconds, time_hash)
-      (year, mon, mday, hour, min, sec, microsec, offset) = *time_hash.values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction, :offset)
+      year, mon, mday, hour, min, sec, microsec, offset = time_hash.values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction, :offset)
 
       # Treat 0000-00-00 00:00:00 as nil.
-      return nil if year.nil? || (year == 0 && mon == 0 && mday == 0)
+      return nil if year.nil? || [year, mon, mday].all?(&:zero?)
 
       if offset
         time = Time.utc(year, mon, mday, hour, min, sec, microsec) rescue nil
@@ -26,6 +25,5 @@ module HstoreAccessor
         Time.public_send(ActiveRecord::Base.default_timezone, year, mon, mday, hour, min, sec, microsec) rescue nil
       end
     end
-
   end
 end

data/lib/hstore_accessor/active_record_<_4.2/type_helpers.rb

@@ -0,0 +1,42 @@
+module HstoreAccessor
+  module TypeHelpers
+    TYPES = {
+      string: "char",
+      datetime: "datetime",
+      date: "date",
+      float: "float",
+      boolean: "boolean",
+      decimal: "decimal",
+      integer: "int"
+    }
+
+    class << self
+      def column_type_for(attribute, data_type)
+        ActiveRecord::ConnectionAdapters::Column.new(attribute.to_s, nil, TYPES[data_type])
+      end
+
+      def cast(type, value)
+        return nil if value.nil?
+
+        column_class = ActiveRecord::ConnectionAdapters::Column
+
+        case type
+        when :string, :hash, :array, :decimal
+          value
+        when :integer
+          column_class.value_to_integer(value)
+        when :float
+          value.to_f
+        when :datetime
+          TimeHelper.string_to_time(value)
+        when :date
+          column_class.value_to_date(value)
+        when :boolean
+          column_class.value_to_boolean(value)
+        else value
+          # Nothing.
+        end
+      end
+    end
+  end
+end

data/lib/hstore_accessor/macro.rb

@@ -1,18 +1,52 @@
 module HstoreAccessor
   module Macro
-
     module ClassMethods
-
       def hstore_accessor(hstore_attribute, fields)
-        define_method("hstore_metadata_for_#{hstore_attribute}") do
-          fields
+        @@hstore_keys_and_types ||= {}
+
+        "hstore_metadata_for_#{hstore_attribute}".tap do |method_name|
+          singleton_class.send(:define_method, method_name) do
+            fields
+          end
+
+          delegate method_name, to: :class
         end
 
         field_methods = Module.new
-        fields.each do |key, type|
 
+        if ActiveRecord::VERSION::STRING.to_f >= 4.2
+          singleton_class.send(:define_method, :type_for_attribute) do |attribute|
+            data_type = @@hstore_keys_and_types[attribute]
+            if data_type
+              TypeHelpers::TYPES[data_type].new
+            else
+              super(attribute)
+            end
+          end
+
+          singleton_class.send(:define_method, :column_for_attribute) do |attribute|
+            data_type = @@hstore_keys_and_types[attribute.to_s]
+            if data_type
+              TypeHelpers.column_type_for(attribute.to_s, data_type)
+            else
+              super(attribute)
+            end
+          end
+        else
+          field_methods.send(:define_method, :column_for_attribute) do |attribute|
+            data_type = @@hstore_keys_and_types[attribute.to_s]
+            if data_type
+              TypeHelpers.column_type_for(attribute.to_s, data_type)
+            else
+              super(attribute)
+            end
+          end
+        end
+
+        fields.each do |key, type|
           data_type = type
           store_key = key
+
           if type.is_a?(Hash)
             type = type.with_indifferent_access
             data_type = type[:data_type]
@@ -23,71 +57,101 @@ module HstoreAccessor
 
           raise Serialization::InvalidDataTypeError unless Serialization::VALID_TYPES.include?(data_type)
 
-          field_methods.send(:define_method, "#{key}=") do |value|
-            casted_value = TypeHelpers.cast(data_type, value)
-            serialized_value = serialize(data_type, casted_value)
-            unless send(key) == casted_value
-              send(:attribute_will_change!, key)
-              send("#{hstore_attribute}_will_change!")
+          @@hstore_keys_and_types[key.to_s] = data_type
+
+          field_methods.instance_eval do
+            define_method("#{key}=") do |value|
+              casted_value = TypeHelpers.cast(data_type, value)
+              serialized_value = Serialization.serialize(data_type, casted_value)
+
+              unless send(key) == casted_value
+                send("#{hstore_attribute}_will_change!")
+              end
+
+              send("#{hstore_attribute}=", (send(hstore_attribute) || {}).merge(store_key.to_s => serialized_value))
             end
-            send("#{hstore_attribute}=", (send(hstore_attribute) || {}).merge(store_key.to_s => serialized_value))
-          end
 
-          field_methods.send(:define_method, key) do
-            value = send(hstore_attribute) && send(hstore_attribute).with_indifferent_access[store_key.to_s]
-            deserialize(data_type, value)
-          end
+            define_method(key) do
+              value = send(hstore_attribute) && send(hstore_attribute).with_indifferent_access[store_key.to_s]
+              Serialization.deserialize(data_type, value)
+            end
 
-          field_methods.send(:define_method, "#{key}?") do
-            send("#{key}").present?
-          end
+            define_method("#{key}?") do
+              send(key).present?
+            end
 
-          field_methods.send(:define_method, "#{key}_changed?") do
-            send(:attribute_changed?, key)
-          end
+            define_method("#{key}_changed?") do
+              send("#{key}_change").present?
+            end
 
-          field_methods.send(:define_method, "#{key}_was") do
-            send(:attribute_was, key)
-          end
+            define_method("#{key}_was") do
+              (send(:attribute_was, hstore_attribute.to_s) || {})[key.to_s]
+            end
+
+            define_method("#{key}_change") do
+              hstore_changes = send("#{hstore_attribute}_change")
+              return if hstore_changes.nil?
+              attribute_changes = hstore_changes.map { |change| change.try(:[], store_key.to_s) }
+              attribute_changes.compact.present? ? attribute_changes : nil
+            end
 
-          field_methods.send(:define_method, "#{key}_change") do
-            send(:attribute_change, key)
+            define_method("restore_#{key}!") do
+              old_hstore = send("#{hstore_attribute}_change").try(:first) || {}
+              send("#{key}=", old_hstore[key.to_s])
+            end
+
+            define_method("reset_#{key}!") do
+              if ActiveRecord::VERSION::STRING.to_f >= 4.2
+                ActiveSupport::Deprecation.warn(<<-MSG.squish)
+                  `#reset_#{key}!` is deprecated and will be removed on Rails 5.
+                  Please use `#restore_#{key}!` instead.
+                MSG
+              end
+              send("restore_#{key}!")
+            end
+
+            define_method("#{key}_will_change!") do
+              send("#{hstore_attribute}_will_change!")
+            end
           end
 
           query_field = "#{hstore_attribute} -> '#{store_key}'"
+          eq_query_field = "#{hstore_attribute} @> hstore('#{store_key}', ?)"
 
           case data_type
           when :string
-            send(:scope, "with_#{key}", -> value { where("#{query_field} = ?", value.to_s) })
-          when :integer, :float, :decimal
-            send(:scope, "#{key}_lt",  -> value { where("(#{query_field})::#{data_type} < ?", value.to_s) })
+            send(:scope, "with_#{key}", -> value { where(eq_query_field, value.to_s) })
+          when :integer
+            send(:scope, "#{key}_lt", -> value { where("(#{query_field})::#{data_type} < ?", value.to_s) })
+            send(:scope, "#{key}_lte", -> value { where("(#{query_field})::#{data_type} <= ?", value.to_s) })
+            send(:scope, "#{key}_eq", -> value { where(eq_query_field, value.to_s) })
+            send(:scope, "#{key}_gte", -> value { where("(#{query_field})::#{data_type} >= ?", value.to_s) })
+            send(:scope, "#{key}_gt", -> value { where("(#{query_field})::#{data_type} > ?", value.to_s) })
+          when :float, :decimal
+            send(:scope, "#{key}_lt", -> value { where("(#{query_field})::#{data_type} < ?", value.to_s) })
             send(:scope, "#{key}_lte", -> value { where("(#{query_field})::#{data_type} <= ?", value.to_s) })
-            send(:scope, "#{key}_eq",  -> value { where("(#{query_field})::#{data_type} = ?", value.to_s) })
+            send(:scope, "#{key}_eq", -> value { where("(#{query_field})::#{data_type} = ?", value.to_s) })
             send(:scope, "#{key}_gte", -> value { where("(#{query_field})::#{data_type} >= ?", value.to_s) })
-            send(:scope, "#{key}_gt",  -> value { where("(#{query_field})::#{data_type} > ?", value.to_s) })
-          when :time
+            send(:scope, "#{key}_gt", -> value { where("(#{query_field})::#{data_type} > ?", value.to_s) })
+          when :datetime
             send(:scope, "#{key}_before", -> value { where("(#{query_field})::integer < ?", value.to_i) })
-            send(:scope, "#{key}_eq",     -> value { where("(#{query_field})::integer = ?", value.to_i) })
-            send(:scope, "#{key}_after",  -> value { where("(#{query_field})::integer > ?", value.to_i) })
+            send(:scope, "#{key}_eq", -> value { where(eq_query_field, value.to_i.to_s) })
+            send(:scope, "#{key}_after", -> value { where("(#{query_field})::integer > ?", value.to_i) })
           when :date
             send(:scope, "#{key}_before", -> value { where("#{query_field} < ?", value.to_s) })
-            send(:scope, "#{key}_eq",     -> value { where("#{query_field} = ?", value.to_s) })
-            send(:scope, "#{key}_after",  -> value { where("#{query_field} > ?", value.to_s) })
+            send(:scope, "#{key}_eq", -> value { where(eq_query_field, value.to_s) })
+            send(:scope, "#{key}_after", -> value { where("#{query_field} > ?", value.to_s) })
           when :boolean
-            send(:scope, "is_#{key}", -> { where("#{query_field} = 'true'") })
-            send(:scope, "not_#{key}", -> { where("#{query_field} = 'false'") })
+            send(:scope, "is_#{key}", -> { where(eq_query_field, "true") })
+            send(:scope, "not_#{key}", -> { where(eq_query_field, "false") })
           when :array
-            send(:scope, "#{key}_eq",        -> value { where("#{query_field} = ?", value.join(Serialization::SEPARATOR)) })
-            send(:scope, "#{key}_contains",  -> value do
-              where("string_to_array(#{query_field}, '#{Serialization::SEPARATOR}') @> string_to_array(?, '#{Serialization::SEPARATOR}')", Array[value].flatten.join(Serialization::SEPARATOR))
-            end)
+            send(:scope, "#{key}_eq", -> value { where("#{query_field} = ?", value.join(Serialization::SEPARATOR)) })
+            send(:scope, "#{key}_contains", -> value { where("string_to_array(#{query_field}, '#{Serialization::SEPARATOR}') @> string_to_array(?, '#{Serialization::SEPARATOR}')", Array[value].flatten.join(Serialization::SEPARATOR)) })
           end
         end
 
         include field_methods
       end
-
     end
-
   end
 end

data/lib/hstore_accessor/serialization.rb

@@ -1,45 +1,57 @@
 module HstoreAccessor
   module Serialization
-
     InvalidDataTypeError = Class.new(StandardError)
 
-    VALID_TYPES = [:string, :integer, :float, :time, :boolean, :array, :hash, :date, :decimal]
-
-    SEPARATOR = "||;||"
+    VALID_TYPES = [
+      :array,
+      :boolean,
+      :date,
+      :datetime,
+      :decimal,
+      :float,
+      :hash,
+      :integer,
+      :string
+    ]
 
     DEFAULT_SERIALIZER = ->(value) { value.to_s }
     DEFAULT_DESERIALIZER = DEFAULT_SERIALIZER
 
+    SEPARATOR = "||;||"
+
     SERIALIZERS = {
-      array:    -> value { (value && value.join(SEPARATOR)) || nil },
-      hash:     -> value { (value && value.to_json) || nil },
-      time:     -> value { value.to_i },
-      boolean:  -> value { (value.to_s == "true").to_s },
-      date:     -> value { (value && value.to_s) || nil }
+      array: -> value { (value && value.join(SEPARATOR)) || nil },
+      boolean: -> value { (value.to_s == "true").to_s },
+      date: -> value { value && value.to_s },
+      hash: -> value { (value && value.to_json) || nil },
+      datetime: -> value { value && value.to_i }
     }
+    SERIALIZERS.default = DEFAULT_SERIALIZER
 
     DESERIALIZERS = {
-      array:    -> value { (value && value.split(SEPARATOR)) || nil },
-      hash:     -> value { (value && JSON.parse(value)) || nil },
-      integer:  -> value { value.to_i },
-      float:    -> value { value.to_f },
-      time:     -> value { Time.at(value.to_i) },
-      boolean:  -> value { TypeHelpers.cast(:boolean, value) },
-      date:     -> value { (value && Date.parse(value)) || nil },
-      decimal:  -> value { BigDecimal.new(value) }
+      array: -> value { (value && value.split(SEPARATOR)) || nil },
+      boolean: -> value { TypeHelpers.cast(:boolean, value) },
+      date: -> value { value && Date.parse(value) },
+      decimal: -> value { value && BigDecimal.new(value) },
+      float: -> value { value && value.to_f },
+      hash: -> value { (value && JSON.parse(value)) || nil },
+      integer: -> value { value && value.to_i },
+      datetime: -> value { value && Time.at(value.to_i).in_time_zone }
     }
+    DESERIALIZERS.default = DEFAULT_DESERIALIZER
 
-    def serialize(type, value, serializer=nil)
-      return nil if value.nil?
-      serializer ||= (SERIALIZERS[type] || DEFAULT_SERIALIZER)
-      serializer.call(value)
-    end
+    class << self
+      def serialize(type, value, serializer=SERIALIZERS[type])
+        return nil if value.nil?
 
-    def deserialize(type, value, deserializer=nil)
-      return nil if value.nil?
-      deserializer ||= (DESERIALIZERS[type] || DEFAULT_DESERIALIZER)
-      deserializer.call(value)
-    end
+        serializer.call(value)
+      end
 
+      def deserialize(type, value, deserializer=DESERIALIZERS[type])
+        return nil if value.nil?
+
+        deserializer.call(value)
+      end
+    end
   end
 end

data/lib/hstore_accessor/version.rb

@@ -1,3 +1,3 @@
 module HstoreAccessor
-  VERSION = "0.6.1"
+  VERSION = "0.9.0"
 end

data/spec/hstore_accessor_spec.rb

@@ -7,30 +7,34 @@ FIELDS = {
   published: { data_type: :boolean, store_key: "p" },
   weight: { data_type: :float, store_key: "w" },
   popular: :boolean,
-  build_timestamp: :time,
+  build_timestamp: :datetime,
   tags: :array,
   reviews: :hash,
   released_at: :date,
   miles: :decimal
 }
 
+DATA_FIELDS = {
+  color_data: :string
+}
+
 class Product < ActiveRecord::Base
   hstore_accessor :options, FIELDS
+  hstore_accessor :data, DATA_FIELDS
 end
 
-describe HstoreAccessor do
+class SuperProduct < Product
+end
 
+describe HstoreAccessor do
   context "macro" do
-
     let(:product) { Product.new }
 
     FIELDS.keys.each do |field|
       it "creates a getter for the hstore field: #{field}" do
         expect(product).to respond_to(field)
       end
-    end
 
-    FIELDS.keys.each do |field|
       it "creates a setter for the hstore field: #{field}=" do
         expect(product).to respond_to(:"#{field}=")
       end
@@ -52,43 +56,42 @@ describe HstoreAccessor do
       expect(product.options["w"]).to eq "38.5"
       expect(product.weight).to eq 38.5
     end
-
   end
 
-  context "#__hstore_metadata_for_*" do
-
-    let(:product) { Product.new }
+  context "#hstore_metadata_for_*" do
+    let(:product) { Product }
 
     it "returns the metadata hash for the specified field" do
       expect(product.hstore_metadata_for_options).to eq FIELDS
+      expect(product.hstore_metadata_for_data).to eq DATA_FIELDS
     end
 
+    context "instance method" do
+      subject { Product.new }
+      it { is_expected.to delegate_method(:hstore_metadata_for_options).to(:class) }
+      it { is_expected.to delegate_method(:hstore_metadata_for_data).to(:class) }
+    end
   end
 
   context "nil values" do
-
     let!(:timestamp) { Time.now }
     let!(:datestamp) { Date.today }
-    let!(:product)   { Product.new }
-    let!(:product_a) { Product.create(color: "green",  price: 10, weight: 10.1, tags: ["tag1", "tag2", "tag3"], popular: true,  build_timestamp: (timestamp - 10.days), released_at: (datestamp - 8.days), miles: BigDecimal.new('9.133790001')) }
+    let(:product) { Product.new }
+    let(:persisted_product) { Product.create!(color: "green", price: 10, weight: 10.1, tags: %w(tag1 tag2 tag3), popular: true, build_timestamp: (timestamp - 10.days), released_at: (datestamp - 8.days), miles: BigDecimal.new("9.133790001")) }
 
     FIELDS.keys.each do |field|
       it "responds with nil when #{field} is not set" do
         expect(product.send(field)).to be_nil
       end
-    end
 
-    FIELDS.keys.each do |field|
       it "responds with nil when #{field} is set back to nil after being set initially" do
-        product_a.send("#{field}=", nil)
-        expect(product_a.send(field)).to be_nil
+        persisted_product.send("#{field}=", nil)
+        expect(persisted_product.send(field)).to be_nil
       end
     end
-
   end
 
   describe "predicate methods" do
-
     let!(:product) { Product.new }
 
     it "exist for each field" do
@@ -105,7 +108,6 @@ describe HstoreAccessor do
     end
 
     context "boolean fields" do
-
       it "return the state for true boolean fields" do
         product.popular = true
         product.save
@@ -140,27 +142,22 @@ describe HstoreAccessor do
         expect(product.popular?).to be false
       end
     end
-
   end
 
   describe "scopes" do
-
     let!(:timestamp) { Time.now }
     let!(:datestamp) { Date.today }
-    let!(:product_a) { Product.create(color: "green",  price: 10, weight: 10.1, tags: ["tag1", "tag2", "tag3"], popular: true,  build_timestamp: (timestamp - 10.days), released_at: (datestamp - 8.days), miles: BigDecimal.new('10.113379001')) }
-    let!(:product_b) { Product.create(color: "orange", price: 20, weight: 20.2, tags: ["tag2", "tag3", "tag4"], popular: false, build_timestamp: (timestamp - 5.days), released_at: (datestamp - 4.days), miles: BigDecimal.new('20.213379001')) }
-    let!(:product_c) { Product.create(color: "blue",   price: 30, weight: 30.3, tags: ["tag3", "tag4", "tag5"], popular: true,  build_timestamp: timestamp, released_at: datestamp, miles: BigDecimal.new('30.313379001')) }
+    let!(:product_a) { Product.create(color: "green", price: 10, weight: 10.1, tags: %w(tag1 tag2 tag3), popular: true, build_timestamp: (timestamp - 10.days), released_at: (datestamp - 8.days), miles: BigDecimal.new("10.113379001")) }
+    let!(:product_b) { Product.create(color: "orange", price: 20, weight: 20.2, tags: %w(tag2 tag3 tag4), popular: false, build_timestamp: (timestamp - 5.days), released_at: (datestamp - 4.days), miles: BigDecimal.new("20.213379001")) }
+    let!(:product_c) { Product.create(color: "blue", price: 30, weight: 30.3, tags: %w(tag3 tag4 tag5), popular: true, build_timestamp: timestamp, released_at: datestamp, miles: BigDecimal.new("30.313379001")) }
 
     context "for string fields support" do
-
       it "equality" do
         expect(Product.with_color("orange").to_a).to eq [product_b]
       end
-
     end
 
     context "for integer fields support" do
-
       it "less than" do
         expect(Product.price_lt(20).to_a).to eq [product_a]
       end
@@ -180,11 +177,9 @@ describe HstoreAccessor do
       it "greater than" do
         expect(Product.price_gt(20).to_a).to eq [product_c]
       end
-
     end
 
     context "for float fields support" do
-
       it "less than" do
         expect(Product.weight_lt(20.0).to_a).to eq [product_a]
       end
@@ -204,50 +199,44 @@ describe HstoreAccessor do
       it "greater than" do
         expect(Product.weight_gt(20.5).to_a).to eq [product_c]
       end
-
     end
 
     context "for decimal fields support" do
-
       it "less than" do
-        expect(Product.miles_lt(BigDecimal.new('10.55555')).to_a).to eq [product_a]
+        expect(Product.miles_lt(BigDecimal.new("10.55555")).to_a).to eq [product_a]
       end
 
       it "less than or equal" do
-        expect(Product.miles_lte(BigDecimal.new('20.213379001')).to_a).to eq [product_a, product_b]
+        expect(Product.miles_lte(BigDecimal.new("20.213379001")).to_a).to eq [product_a, product_b]
       end
 
       it "equality" do
-        expect(Product.miles_eq(BigDecimal.new('10.113379001')).to_a).to eq [product_a]
+        expect(Product.miles_eq(BigDecimal.new("10.113379001")).to_a).to eq [product_a]
       end
 
       it "greater than or equal" do
-        expect(Product.miles_gte(BigDecimal.new('20.213379001')).to_a).to eq [product_b, product_c]
+        expect(Product.miles_gte(BigDecimal.new("20.213379001")).to_a).to eq [product_b, product_c]
       end
 
       it "greater than" do
-        expect(Product.miles_gt(BigDecimal.new('20.555555')).to_a).to eq [product_c]
+        expect(Product.miles_gt(BigDecimal.new("20.555555")).to_a).to eq [product_c]
       end
-
     end
 
     context "for array fields support" do
-
       it "equality" do
-        expect(Product.tags_eq(["tag1", "tag2", "tag3"]).to_a).to eq [product_a]
+        expect(Product.tags_eq(%w(tag1 tag2 tag3)).to_a).to eq [product_a]
       end
 
       it "contains" do
         expect(Product.tags_contains("tag2").to_a).to eq [product_a, product_b]
-        expect(Product.tags_contains(["tag2", "tag3"]).to_a).to eq [product_a, product_b]
-        expect(Product.tags_contains(["tag1", "tag2", "tag3"]).to_a).to eq [product_a]
-        expect(Product.tags_contains(["tag1", "tag2", "tag3", "tag4"]).to_a).to eq []
+        expect(Product.tags_contains(%w(tag2 tag3)).to_a).to eq [product_a, product_b]
+        expect(Product.tags_contains(%w(tag1 tag2 tag3)).to_a).to eq [product_a]
+        expect(Product.tags_contains(%w(tag1 tag2 tag3 tag4)).to_a).to eq []
       end
-
     end
 
     context "for time fields support" do
-
       it "before" do
         expect(Product.build_timestamp_before(timestamp)).to eq [product_a, product_b]
       end
@@ -259,11 +248,9 @@ describe HstoreAccessor do
       it "after" do
         expect(Product.build_timestamp_after(timestamp - 6.days)).to eq [product_b, product_c]
       end
-
     end
 
     context "for date fields support" do
-
       it "before" do
         expect(Product.released_at_before(datestamp)).to eq [product_a, product_b]
       end
@@ -275,11 +262,9 @@ describe HstoreAccessor do
       it "after" do
         expect(Product.released_at_after(datestamp - 6.days)).to eq [product_b, product_c]
       end
-
     end
 
     context "for boolean field support" do
-
       it "true" do
         expect(Product.is_popular).to eq [product_a, product_c]
       end
@@ -287,13 +272,81 @@ describe HstoreAccessor do
       it "false" do
         expect(Product.not_popular).to eq [product_b]
       end
+    end
+  end
+
+  describe "#type_for_attribute" do
+    if ::ActiveRecord::VERSION::STRING.to_f >= 4.2
+      subject { SuperProduct }
 
+      def self.it_returns_the_type_for_the_attribute(type, attribute_name, active_record_type)
+        context "#{type}" do
+          it "returns the type for the column" do
+            expect(subject.type_for_attribute(attribute_name.to_s)).to eq(active_record_type.new)
+          end
+        end
+      end
+
+      it_returns_the_type_for_the_attribute "default behavior", :string_type, ActiveRecord::Type::String
+      it_returns_the_type_for_the_attribute :string, :color, ActiveRecord::Type::String
+      it_returns_the_type_for_the_attribute :integer, :price, ActiveRecord::Type::Integer
+      it_returns_the_type_for_the_attribute :float, :weight, ActiveRecord::Type::Float
+      it_returns_the_type_for_the_attribute :datetime, :build_timestamp, ActiveRecord::Type::DateTime
+      it_returns_the_type_for_the_attribute :date, :released_at, ActiveRecord::Type::Date
+      it_returns_the_type_for_the_attribute :boolean, :published, ActiveRecord::Type::Boolean
+    else
+      subject { Product }
+
+      it "is not defined" do
+        expect(subject).to_not respond_to(:type_for_attribute)
+      end
     end
+  end
+
+  describe "#column_for_attribute" do
+    if ActiveRecord::VERSION::STRING.to_f >= 4.2
+
+      def self.it_returns_the_properly_typed_column(type, attribute_name, cast_type_class)
+        context "#{type}" do
+          subject { SuperProduct.column_for_attribute(attribute_name) }
+          it "returns a column with a #{type} cast type" do
+            expect(subject).to be_a(ActiveRecord::ConnectionAdapters::Column)
+            expect(subject.cast_type).to eq(cast_type_class.new)
+          end
+        end
+      end
+
+      it_returns_the_properly_typed_column :string, :color, ActiveRecord::Type::String
+      it_returns_the_properly_typed_column :integer, :price, ActiveRecord::Type::Integer
+      it_returns_the_properly_typed_column :boolean, :published, ActiveRecord::Type::Boolean
+      it_returns_the_properly_typed_column :float, :weight, ActiveRecord::Type::Float
+      it_returns_the_properly_typed_column :datetime, :build_timestamp, ActiveRecord::Type::DateTime
+      it_returns_the_properly_typed_column :date, :released_at, ActiveRecord::Type::Date
+      it_returns_the_properly_typed_column :decimal, :miles, ActiveRecord::Type::Decimal
+      it_returns_the_properly_typed_column :array, :tags, ActiveRecord::Type::Value
+      it_returns_the_properly_typed_column :hash, :reviews, ActiveRecord::Type::Value
+    else
+      def self.it_returns_the_properly_typed_column(hstore_type, attribute_name, active_record_type)
+        context "#{hstore_type}" do
+          subject { SuperProduct.new.column_for_attribute(attribute_name) }
+          it "returns a column with a #{hstore_type} cast type" do
+            expect(subject).to be_a(ActiveRecord::ConnectionAdapters::Column)
+            expect(subject.type).to eq(active_record_type)
+          end
+        end
+      end
 
+      it_returns_the_properly_typed_column :string, :color, :string
+      it_returns_the_properly_typed_column :integer, :price, :integer
+      it_returns_the_properly_typed_column :boolean, :published, :boolean
+      it_returns_the_properly_typed_column :float, :weight, :float
+      it_returns_the_properly_typed_column :time, :build_timestamp, :datetime
+      it_returns_the_properly_typed_column :date, :released_at, :date
+      it_returns_the_properly_typed_column :decimal, :miles, :decimal
+    end
   end
 
   context "when assigning values it" do
-
     let(:product) { Product.new }
 
     it "correctly stores string values" do
@@ -335,26 +388,80 @@ describe HstoreAccessor do
       expect(product.weight).to eq 93.45
     end
 
-    it "correctly stores array values" do
-      product.tags = ["household", "living room", "kitchen"]
-      product.save
-      product.reload
-      expect(product.tags).to eq ["household", "living room", "kitchen"]
+    context "array values" do
+      it "correctly stores nothing" do
+        product.tags = nil
+        product.save
+        product.reload
+        expect(product.tags).to be_nil
+      end
+
+      it "correctly stores strings" do
+        product.tags = ["household", "living room", "kitchen"]
+        product.save
+        product.reload
+        expect(product.tags).to eq ["household", "living room", "kitchen"]
+      end
     end
 
-    it "correctly stores hash values" do
-      product.reviews = { "user_123" => "4 stars", "user_994" => "3 stars" }
-      product.save
-      product.reload
-      expect(product.reviews).to eq({ "user_123" => "4 stars", "user_994" => "3 stars" })
+    context "hash values" do
+      it "correctly stores nothing" do
+        product.reviews = nil
+        product.save
+        product.reload
+        expect(product.reviews).to be_nil
+      end
+
+      it "correctly stores hash values as json" do
+        hash = product.reviews = { "user_123" => "4 stars", "user_994" => "3 stars" }
+        product.save
+        product.reload
+        expect(product.reviews).to eq("user_123" => "4 stars", "user_994" => "3 stars")
+        expect(product.options["reviews"]).to eq(hash.to_json)
+      end
     end
 
-    it "correctly stores time values" do
-      timestamp = Time.now - 10.days
-      product.build_timestamp = timestamp
-      product.save
-      product.reload
-      expect(product.build_timestamp.to_i).to eq timestamp.to_i
+    context "multipart values" do
+      it "stores multipart dates correctly" do
+        product.update_attributes!(
+          "released_at(1i)" => "2014",
+          "released_at(2i)" => "04",
+          "released_at(3i)" => "14"
+        )
+        product.reload
+        expect(product.released_at).to eq(Date.new(2014, 4, 14))
+      end
+    end
+
+    context "time values" do
+      let(:chicago_timezone) { ActiveSupport::TimeZone["America/Chicago"] }
+      let(:new_york_timezone) { ActiveSupport::TimeZone["America/New_York"] }
+
+      it "correctly stores value" do
+        timestamp = Time.now - 10.days
+        product.build_timestamp = timestamp
+        product.save!
+        product.reload
+        expect(product.build_timestamp.to_i).to eq timestamp.to_i
+      end
+
+      it "stores the value in utc" do
+        timestamp = Time.now.in_time_zone(chicago_timezone) - 10.days
+        product.build_timestamp = timestamp
+        product.save!
+        product.reload
+        expect(product.options["build_timestamp"].to_i).to eq timestamp.utc.to_i
+      end
+
+      it "returns the time value in the current time zone" do
+        timestamp = Time.now.in_time_zone(chicago_timezone) - 10.days
+        product.build_timestamp = timestamp
+        product.save!
+        product.reload
+        Time.use_zone(new_york_timezone) do
+          expect(product.build_timestamp.utc_offset).to eq new_york_timezone.utc_offset
+        end
+      end
     end
 
     it "correctly stores date values" do
@@ -367,7 +474,7 @@ describe HstoreAccessor do
     end
 
     it "correctly stores decimal values" do
-      decimal = BigDecimal.new('9.13370009001')
+      decimal = BigDecimal.new("9.13370009001")
       product.miles = decimal
       product.save
       product.reload
@@ -376,9 +483,8 @@ describe HstoreAccessor do
     end
 
     context "correctly stores boolean values" do
-
       it "when string 'true' is passed" do
-        product.popular = 'true'
+        product.popular = "true"
         product.save
         product.reload
         expect(product.popular).to be true
@@ -390,7 +496,6 @@ describe HstoreAccessor do
         product.reload
         expect(product.popular).to be true
       end
-
     end
 
     it "setters call the _will_change! method of the store attribute" do
@@ -400,26 +505,30 @@ describe HstoreAccessor do
 
     describe "type casting" do
       it "type casts integer values" do
-        product.price = '468'
+        product.price = "468"
         expect(product.price).to eq 468
       end
+
       it "type casts float values" do
-        product.weight = '93.45'
+        product.weight = "93.45"
         expect(product.weight).to eq 93.45
       end
+
       it "type casts time values" do
         timestamp = Time.now - 10.days
         product.build_timestamp = timestamp.to_s
         expect(product.build_timestamp.to_i).to eq timestamp.to_i
       end
+
       it "type casts date values" do
         datestamp = Date.today - 9.days
         product.released_at = datestamp.to_s
         expect(product.released_at).to eq datestamp
       end
+
       it "type casts decimal values" do
-        product.miles = '1.337900129339202'
-        expect(product.miles).to eq BigDecimal.new('1.337900129339202')
+        product.miles = "1.337900129339202"
+        expect(product.miles).to eq BigDecimal.new("1.337900129339202")
       end
 
       it "type casts boolean values" do
@@ -430,6 +539,7 @@ describe HstoreAccessor do
           product.published = value
           expect(product.published).to be true
         end
+
         ActiveRecord::ConnectionAdapters::Column::FALSE_VALUES.each do |value|
           product.popular = value
           expect(product.popular).to be false
@@ -480,12 +590,12 @@ describe HstoreAccessor do
   end
 
   describe "dirty tracking" do
-
     let(:product) { Product.new }
 
     it "<attr>_changed? should return the expected value" do
       expect(product.color_changed?).to be false
       product.color = "ORANGE"
+      expect(product.price_changed?).to be false
       expect(product.color_changed?).to be true
       product.save
       expect(product.color_changed?).to be false
@@ -502,20 +612,106 @@ describe HstoreAccessor do
       expect(product.price_changed?).to be false
     end
 
-    it "<attr>_was should return the expected value" do
-      product.color = "ORANGE"
-      product.save
-      product.color = "GREEN"
-      expect(product.color_was).to eq "ORANGE"
+    describe "#<attr>_will_change!" do
+      it "tells ActiveRecord the hstore attribute has changed" do
+        expect(product).to receive(:options_will_change!)
+        product.color_will_change!
+      end
     end
 
-    it "<attr>_change should return the expected value" do
-      product.color = "ORANGE"
-      product.save
-      product.color = "GREEN"
-      expect(product.color_change).to eq ["ORANGE", "GREEN"]
+    describe "#<attr>_was" do
+      it "returns the expected value" do
+        product.color = "ORANGE"
+        product.save
+        product.color = "GREEN"
+        expect(product.color_was).to eq "ORANGE"
+      end
+
+      it "works when the hstore attribute is nil" do
+        product.options = nil
+        product.save
+        product.color = "green"
+        expect { product.color_was }.to_not raise_error
+      end
     end
 
-  end
+    describe "#<attr>_change" do
+      it "returns the old and new values" do
+        product.color = "ORANGE"
+        product.save
+        product.color = "GREEN"
+        expect(product.color_change).to eq %w(ORANGE GREEN)
+      end
+      context "when store_key differs from key" do
+        it "returns the old and new values" do
+          product.weight = 100.01
+          expect(product.weight_change[1]).to eq "100.01"
+        end
+      end
+      context "hstore attribute was nil" do
+        it "returns old and new values" do
+          product.options = nil
+          product.save!
+          green = product.color = "green"
+          expect(product.color_change).to eq([nil, green])
+        end
+      end
+
+      context "other hstore attributes were persisted" do
+        it "returns nil" do
+          product.price = 5
+          product.save!
+          product.price = 6
+          expect(product.color_change).to be_nil
+        end
+      end
+
+      context "not persisted" do
+        it "returns nil when there are no changes" do
+          expect(product.color_change).to be_nil
+        end
+      end
+    end
 
+    describe "#reset_<attr>!" do
+      before do
+        allow(ActiveSupport::Deprecation).to receive(:warn)
+      end
+
+      if ActiveRecord::VERSION::STRING.to_f >= 4.2
+        it "displays a deprecation warning" do
+          expect(ActiveSupport::Deprecation).to receive(:warn)
+          product.reset_color!
+        end
+      else
+        it "does not display a deprecation warning" do
+          expect(ActiveSupport::Deprecation).to_not receive(:warn)
+          product.reset_color!
+        end
+      end
+
+      it "restores the attribute" do
+        expect(product).to receive(:restore_color!)
+        product.reset_color!
+      end
+    end
+
+    describe "#restore_<attr>!" do
+      it "restores the attribute" do
+        product.color = "red"
+        product.restore_color!
+        expect(product.color).to be_nil
+      end
+
+      context "persisted" do
+        it "restores the attribute" do
+          green = product.color = "green"
+          product.save!
+          product.color = "red"
+          product.restore_color!
+          expect(product.color).to eq(green)
+        end
+      end
+    end
+  end
 end