freezer 0.0.0 → 0.5.0

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+### v0.5.0
+
+* Initial release

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2012 Godfrey Chan
+
+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.md

@@ -0,0 +1,2 @@
+freezer
+=======

data/lib/freezer.rb

@@ -0,0 +1,6 @@
+require 'freezer/active_record_extensions'
+require 'active_record/base'
+
+class ActiveRecord::Base
+  include Freezer::ActiveRecordExtensions
+end

data/lib/freezer/active_record_extensions.rb

@@ -0,0 +1,62 @@
+require 'freezer/serialization'
+require 'active_support/concern'
+require 'active_support/core_ext/hash/reverse_merge'
+require 'active_support/core_ext/string/inflections'
+
+module Freezer
+  module ActiveRecordExtensions
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def has_one_frozen(association_name, options = {})
+        options.reverse_merge!({
+          class_name: association_name.to_s,
+          column_name: "frozen_#{association_name.to_s}",
+          slient: false
+        })
+
+        klass = options[:class_name].camelize.constantize
+        accessor_name = association_name.to_s.underscore
+
+        # Reader
+        define_method(accessor_name) do
+          @freezer_cache ||= {}
+
+          if @freezer_cache.key? accessor_name
+            return @freezer_cache[accessor_name]
+          end
+
+          # 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])
+          else
+            @freezer_cache[accessor_name] = nil
+          end
+
+          @freezer_cache[accessor_name]
+        end
+
+        # Writer
+        define_method("#{accessor_name}=") do |record|
+          unless record.nil? || record.is_a?(klass)
+            message = "#{klass}(##{klass.object_id}) expected, got #{record.class}(##{record.class.object_id})"
+            raise ArgumentError, message
+          end
+
+          @freezer_cache ||= {}
+
+          if record
+            write_attribute(options[:column_name], Serialization.serialize(record))
+          else
+            write_attribute(options[:column_name], nil)
+          end
+
+          @freezer_cache.delete(accessor_name)
+
+          # Return the frozen copy of record by calling the reader
+          self.__send__(accessor_name.to_sym)
+        end
+      end
+    end
+  end
+end

data/lib/freezer/frozen_record_proxy.rb

@@ -0,0 +1,40 @@
+require 'active_support/core_ext/string/inflections'
+require 'active_record/errors'
+
+module Freezer
+  module FrozenRecordFactory
+    class << self
+      def get_class(klass)
+        klass.is_a?(Class) ? klass : klass.to_s.camelize.constantize
+      end
+
+      def build(klass, attributes, slient = false)
+        record = get_class(klass).new attributes, without_protection: true
+        FrozenRecordProxy.new(record, slient)
+      end
+    end
+  end
+
+  class FrozenRecordProxy < BasicObject
+    [:==, :equal?, :!, :!=, :instance_eval, :instance_exec].each { |meth| undef_method(meth) }
+
+    def initialize(record, silent = false)
+      @silent = silent
+      @record = record
+      @record.readonly!
+      @record.freeze
+    end
+
+    private
+
+    def method_missing(method, *args, &block)
+      begin
+        @record.__send__(method, *args, &block)
+      rescue ::RuntimeError => e
+        @record.__send__(:raise, e) unless @silent && e.message == "can't modify frozen Hash"
+      rescue ::ActiveRecord::ReadOnlyRecord => e
+        @record.__send__(:raise, e) unless @silent
+      end
+    end
+  end
+end

data/lib/freezer/serialization.rb

@@ -0,0 +1,64 @@
+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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: freezer
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.5.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,14 +9,70 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-20 00:00:00.000000000 Z
-dependencies: []
+date: 2012-07-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.4
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !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
+email:
+- godfreykfc@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- lib/freezer/active_record_extensions.rb
+- lib/freezer/frozen_record_proxy.rb
+- lib/freezer/serialization.rb
+- lib/freezer.rb
+- README.md
+- CHANGELOG.md
+- LICENSE
 homepage: https://github.com/chancancode/freezer
 licenses: []
 post_install_message: 
@@ -34,7 +90,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.6
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24