freezer 0.5.0 → 0.6.0

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+### v0.6.0
+
+* Added support for different serialization strategies based on the column type
+
 ### v0.5.0
 
 * Initial release

data/lib/freezer/active_record_extensions.rb

@@ -1,4 +1,3 @@
-require 'freezer/serialization'
 require 'active_support/concern'
 require 'active_support/core_ext/hash/reverse_merge'
 require 'active_support/core_ext/string/inflections'
@@ -17,6 +16,14 @@ module Freezer
 
         klass = options[:class_name].camelize.constantize
         accessor_name = association_name.to_s.underscore
+        serializer = if self.columns_hash[options[:column_name].to_s].type == :hstore
+          require 'freezer/serialization/hstore'
+          ::Freezer::Serialization::HStore
+        else
+          require 'freezer/serialization/serialize'
+          self.serialize options[:column_name].to_sym, Hash
+          ::Freezer::Serialization::Serialize
+        end
 
         # Reader
         define_method(accessor_name) do
@@ -28,7 +35,7 @@ module Freezer
 
           # On cache miss, try to read from the raw accessor
           if hstore = read_attribute(options[:column_name])
-            @freezer_cache[accessor_name] = Serialization.deserialize(options[:class_name], hstore, options[:slient])
+            @freezer_cache[accessor_name] = serializer.deserialize(options[:class_name], hstore, options[:slient])
           else
             @freezer_cache[accessor_name] = nil
           end
@@ -46,7 +53,7 @@ module Freezer
           @freezer_cache ||= {}
 
           if record
-            write_attribute(options[:column_name], Serialization.serialize(record))
+            write_attribute(options[:column_name], serializer.serialize(record))
           else
             write_attribute(options[:column_name], nil)
           end

data/lib/freezer/hstore_serialization.rb

@@ -0,0 +1,66 @@
+require 'freezer/frozen_record_proxy'
+require 'active_record/connection_adapters/column'
+
+module Freezer
+  module Serialization
+    module HStore
+      SERIALIZABLE_TYPES = [
+        :primary_key, :string, :text, :integer, :float, :decimal,
+        :datetime,:timestamp, :time, :date, :boolean
+      ].freeze
+
+      class << self
+        # TODO give each version its own module or something
+        def serialize(record)
+          # Start with the serialization format version string
+          hstore = {':sv'=>'1'}
+
+          columns = record.class.columns
+          attributes = record.attributes
+
+          columns.each do |column|
+            key = serialize_key(column.name, column.type)
+            value = serialize_value(column.type, attributes[column.name])
+            hstore[key] = value
+          end
+
+          hstore
+        end
+
+        def deserialize(klass, attributes, silent = false)
+          attributes = attributes.dup
+          sv = attributes.delete(':sv')
+          raise ArgumentError, "Unknown serialization format #{sv.to_s}" unless sv == '1'
+          attributes = attributes.inject({}) do |hash,(key,value)|
+            real_key, type = deserialize_key(key)
+            hash[real_key] = deserialize_value(type, value)
+            hash
+          end
+          FrozenRecordFactory.build(klass, attributes, silent)
+        end
+
+        def serialize_key(key, type)
+          "#{key.gsub(':','::')}:#{type}"
+        end
+
+        def deserialize_key(serialized)
+          m = serialized.match(/(.*):([^:]+)\z/)
+          [m[1].gsub('::',':'), m[2].to_sym]
+        end
+
+        def serialize_value(type, value)
+          raise ArgumentError, "Do not know how to serialize #{type.to_s}" unless SERIALIZABLE_TYPES.include? type
+          return nil if value.nil?
+          value.to_s
+        end
+
+        def deserialize_value(type, value)
+          raise ArgumentError, "Do not know how to deserialize #{type.to_s}" unless SERIALIZABLE_TYPES.include? type
+          return nil if value.nil?
+          # For now, we will let AR handle the casting for us
+          value.to_s
+        end
+      end
+    end
+  end
+end

data/lib/freezer/serialization/hstore.rb

@@ -0,0 +1,66 @@
+require 'freezer/frozen_record_proxy'
+require 'active_record/connection_adapters/column'
+
+module Freezer
+  module Serialization
+    module HStore
+      SERIALIZABLE_TYPES = [
+        :primary_key, :string, :text, :integer, :float, :decimal,
+        :datetime,:timestamp, :time, :date, :boolean
+      ].freeze
+
+      class << self
+        # TODO give each version its own module or something
+        def serialize(record)
+          # Start with the serialization format version string
+          hstore = {':sv'=>'1'}
+
+          columns = record.class.columns
+          attributes = record.attributes
+
+          columns.each do |column|
+            key = serialize_key(column.name, column.type)
+            value = serialize_value(column.type, attributes[column.name])
+            hstore[key] = value
+          end
+
+          hstore
+        end
+
+        def deserialize(klass, attributes, silent = false)
+          attributes = attributes.dup
+          sv = attributes.delete(':sv')
+          raise ArgumentError, "Unknown serialization format #{sv.to_s}" unless sv == '1'
+          attributes = attributes.inject({}) do |hash,(key,value)|
+            real_key, type = deserialize_key(key)
+            hash[real_key] = deserialize_value(type, value)
+            hash
+          end
+          FrozenRecordFactory.build(klass, attributes, silent)
+        end
+
+        def serialize_key(key, type)
+          "#{key.gsub(':','::')}:#{type}"
+        end
+
+        def deserialize_key(serialized)
+          m = serialized.match(/(.*):([^:]+)\z/)
+          [m[1].gsub('::',':'), m[2].to_sym]
+        end
+
+        def serialize_value(type, value)
+          raise ArgumentError, "Do not know how to serialize #{type.to_s}" unless SERIALIZABLE_TYPES.include? type
+          return nil if value.nil?
+          value.to_s
+        end
+
+        def deserialize_value(type, value)
+          raise ArgumentError, "Do not know how to deserialize #{type.to_s}" unless SERIALIZABLE_TYPES.include? type
+          return nil if value.nil?
+          # For now, we will let AR handle the casting for us
+          value.to_s
+        end
+      end
+    end
+  end
+end

data/lib/freezer/serialization/serialize.rb

@@ -0,0 +1,17 @@
+require 'freezer/frozen_record_proxy'
+
+module Freezer
+  module Serialization
+    module Serialize
+      class << self
+        def serialize(record)
+          record.attributes.dup
+        end
+
+        def deserialize(klass, attributes, silent = false)
+          FrozenRecordFactory.build(klass, attributes.dup, silent)
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: freezer
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-25 00:00:00.000000000 Z
+date: 2012-08-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -43,22 +43,6 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 3.2.4
-- !ruby/object:Gem::Dependency
-  name: activerecord-postgres-hstore
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 0.4.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 0.4.0
 description: ''
 email:
 - godfreykfc@gmail.com
@@ -68,7 +52,9 @@ extra_rdoc_files: []
 files:
 - lib/freezer/active_record_extensions.rb
 - lib/freezer/frozen_record_proxy.rb
-- lib/freezer/serialization.rb
+- lib/freezer/hstore_serialization.rb
+- lib/freezer/serialization/hstore.rb
+- lib/freezer/serialization/serialize.rb
 - lib/freezer.rb
 - README.md
 - CHANGELOG.md

data/lib/freezer/serialization.rb

@@ -1,64 +0,0 @@
-require 'freezer/frozen_record_proxy'
-require 'active_record/connection_adapters/column'
-
-module Freezer
-  module Serialization
-    SERIALIZABLE_TYPES = [
-      :primary_key, :string, :text, :integer, :float, :decimal,
-      :datetime,:timestamp, :time, :date, :boolean
-    ].freeze
-
-    class << self
-      # TODO give each version its own module or something
-      def serialize(record)
-        # Start with the serialization format version string
-        hstore = {':sv'=>'1'}
-
-        columns = record.class.columns
-        attributes = record.attributes
-
-        columns.each do |column|
-          key = serialize_key(column.name, column.type)
-          value = serialize_value(column.type, attributes[column.name])
-          hstore[key] = value
-        end
-
-        hstore
-      end
-
-      def deserialize(klass, attributes, silent = false)
-        attributes = attributes.dup
-        sv = attributes.delete(':sv')
-        raise ArgumentError, "Unknown serialization format #{sv.to_s}" unless sv == '1'
-        attributes = attributes.inject({}) do |hash,(key,value)|
-          real_key, type = deserialize_key(key)
-          hash[real_key] = deserialize_value(type, value)
-          hash
-        end
-        FrozenRecordFactory.build(klass, attributes, silent)
-      end
-
-      def serialize_key(key, type)
-        "#{key.gsub(':','::')}:#{type}"
-      end
-
-      def deserialize_key(serialized)
-        m = serialized.match(/(.*):([^:]+)\z/)
-        [m[1].gsub('::',':'), m[2].to_sym]
-      end
-
-      def serialize_value(type, value)
-        raise ArgumentError, "Do not know how to serialize #{type.to_s}" unless SERIALIZABLE_TYPES.include? type
-        return nil if value.nil?
-        value.to_s
-      end
-
-      def deserialize_value(type, value)
-        raise ArgumentError, "Do not know how to deserialize #{type.to_s}" unless SERIALIZABLE_TYPES.include? type
-        return nil if value.nil?
-        # For now, we will let AR handle the casting for us
-        value.to_s
-      end
-    end
-  end
-end