cerealize 0.8.0

data/CHANGES

@@ -0,0 +1,4 @@
+= cerealize changes history
+
+=== cerealize 0.8.0, 2010-04-18
+ * release early, release often

data/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/README

@@ -0,0 +1,63 @@
+= cerealize 0.8.0
+by Cardinal Blue ( http://cardinalblue.com )
+
+== LINKS:
+
+* github[http://github.com/cardinalblue/cerealize]
+* rubygems[http://rubygems.org/gems/cerealize]
+
+== DESCRIPTION:
+
+  Serialize out of the Cerealize Box
+  - a drop-in replacement for ActiveRecord's serialize
+
+  It can auto transcode old encoding (yaml if you're using AR's serialize),
+  to new encoding (marshal, json, you name it) without any migration.
+
+  Current supported encoding:
+  1. YAML
+  2. Marshal
+  3. JSON (planned)
+
+  Current supported ORM:
+  1. ActiveRecord (tested with 2.3.5)
+  2. DataMapper (planned)
+
+== SYNOPSIS:
+
+ require 'cerealize'
+ class User < ActiveRecord::Base
+   # when force_encoding set to false (this is default), cerealize is
+   # smart enough to transcode old encoding (e.g. yaml) to new encoding
+   # (i.e. marshal)
+   cerealize :data, Hash, :encoding => :marshal, :force_encoding => false
+ end
+
+== REQUIREMENTS:
+
+* tested with MRI 1.8.7 and 1.9.1
+* one of your desired ORM
+
+== INSTALL:
+
+> gem install cerealize
+or
+> script/plugin install git://github.com/cardinalblue/cerealize.git
+
+== LICENSE:
+
+  Apache License 2.0
+
+  Copyright (c) 2010, Cardinal Blue
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.

data/Rakefile

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+begin
+  require 'bones'
+rescue LoadError
+  abort '### Please install the "bones" gem ###'
+end
+
+ensure_in_path 'lib'
+proj = 'cerealize'
+require "#{proj}/version"
+
+Bones{
+  ruby_opts [''] # silence warning for now
+
+  version Cerealize::VERSION
+
+  depend_on 'activerecord',                       :version => '>=2.3.5'
+  # depend_on 'activerecord', :development => true, :version => '>=2.3.5'
+
+  name    proj
+  url     "http://github.com/cardinalblue/#{proj}"
+  authors 'Cardinal Blue'
+  email   'dev (XD) cardinalblue.com'
+
+  history_file   'CHANGES'
+   readme_file   'README'
+   ignore_file   '.gitignore'
+  rdoc.include   ['\w+']
+}
+
+CLEAN.include Dir['**/*.rbc']
+
+task :default do
+  Rake.application.options.show_task_pattern = /./
+  Rake.application.display_tasks_and_comments
+end

data/TODO

@@ -0,0 +1,7 @@
+= cerealize todo list
+
+* cleanup test cases... use proper way to setup encoding
+* extract options, instead of hardcoded into method closure (block)
+* extract base64 decorator, then we can use pure marshal
+* datamapper support
+* json support

data/init.rb

@@ -0,0 +1,2 @@
+# encoding: utf-8
+require 'cerealize'

data/lib/cerealize.rb

@@ -0,0 +1,135 @@
+# encoding: utf-8
+
+require 'active_record'
+autoload :YAML, 'yaml'
+
+module Cerealize
+  module Codec
+    autoload 'Yaml',    'cerealize/codec/yaml'
+    autoload 'Marshal', 'cerealize/codec/marshal'
+  end
+  class NoSuchCodec     < ArgumentError; end
+  class NoSuitableCodec < RuntimeError ; end
+
+  #
+  # Dirty functionality: note that *_changed? and changed? work,
+  # but *_was, *_change, and changes do NOT work.
+  #
+
+  def self.included(base)
+    base.send :extend, ClassMethods
+  end
+
+  module_function
+  def codecs
+    @codecs ||= Codec.constants.sort.map{ |codec_name|
+                  Codec.const_get(codec_name)
+                }
+  end
+
+  def codec_names
+    @codec_names ||= codecs.map{ |codec|
+                       codec.to_s.sub(/(\w+::)+/, '').downcase.to_sym
+                     }
+  end
+
+  def codec_detect(str)
+    codecs.find{ |codec| codec.yours?(str) }
+  end
+
+  def codec_get(codec_name)
+    Codec.const_get(codec_name.to_s.capitalize)
+  rescue NameError
+    raise NoSuchCodec.new(codec_name)
+  end
+
+  def encode(obj, codec)
+    return nil unless obj
+    codec.encode(obj)
+  end
+
+  def decode(str, codec=nil)
+    return nil unless str
+    codec ||= codec_detect(str)
+
+    if codec && codec.yours?(str)
+      codec.decode(str)
+    else
+      raise NoSuitableCodec.new("#{str[0..46]}...")
+    end
+  end
+
+  module ClassMethods
+
+    def cerealize property, klass=nil, options={}
+      field_pre   = "@#{property}_pre".to_sym
+      field_cache = "@#{property}".to_sym
+      codec       = Cerealize.codec_get(options[:encoding] || :marshal)
+      force_encoding  = options[:force_encoding]
+
+      # Invariants:
+      #   - instance_variable_defined?(field_cache)  IFF the READER or WRITER has been called
+      #   - instance_variable_defined?(field_pre)    IFF the READER was called BEFORE
+      #                                              any WRITER
+
+      # READER method
+      #
+      define_method property do
+        # Rails.logger.debug "#{property} (READER)"
+
+        # See if no assignment yet
+        if !instance_variable_defined?(field_cache)
+
+          # Save property if not already saved
+          if !instance_variable_defined?(field_pre)
+            instance_variable_set(field_pre, read_attribute(property))
+          end
+
+          # Set cached from pre
+          v = Cerealize.decode(instance_variable_get(field_pre),
+                               force_encoding && codec )
+          raise ActiveRecord::SerializationTypeMismatch, "expected #{klass}, got #{v.class}" \
+            if klass && !v.nil? && !v.kind_of?(klass)
+          instance_variable_set(field_cache, v)
+        end
+
+        # Return cached
+        instance_variable_get(field_cache)
+      end
+
+      # WRITER method
+      #
+      define_method "#{property}=" do |v|
+        # Rails.logger.debug "#{property}=#{v}"
+        send "#{property}_will_change!" if instance_variable_get(field_cache) != v
+        instance_variable_set(field_cache, v)
+      end
+
+      # Callback for before_save
+      #
+      define_method "#{property}_update_if_dirty" do
+        # Rails.logger.debug "#{property}_update_if_dirty"
+
+        # See if we have a new cur value
+        if instance_variable_defined?(field_cache)
+          v = instance_variable_get(field_cache)
+          v_enc = Cerealize.encode(v, codec)
+
+          # See if no pre at all (i.e. it was written to before being read),
+          # or if different. When comparing, compare both marshalized string,
+          # and Object ==.
+          #
+          if !instance_variable_defined?(field_pre) ||
+            (v_enc != instance_variable_get(field_pre) &&
+              v != Cerealize.decode(instance_variable_get(field_pre),
+                                    force_encoding && codec ))
+            write_attribute(property, v_enc)
+          end
+        end
+        remove_instance_variable(field_pre)   if instance_variable_defined?(field_pre)
+        remove_instance_variable(field_cache) if instance_variable_defined?(field_cache)
+      end
+      before_save("#{property}_update_if_dirty")
+    end
+  end
+end # of Cerealize

data/lib/cerealize/codec/marshal.rb

@@ -0,0 +1,21 @@
+
+module Cerealize
+  module Codec; end
+  module Codec::Marshal
+    module_function
+
+    # Version 4.8 of Marshalize always base64s to "BA"
+    # TODO: extract base64 decorator, then we can use pure marshal
+    def yours?(str)
+      str[0..1] == 'BA'
+    end
+
+    def encode(obj)
+      [Marshal.dump(obj)].pack('m*')
+    end
+
+    def decode(str)
+      Marshal.load(str.unpack('m*').first)
+    end
+  end
+end

data/lib/cerealize/codec/yaml.rb

@@ -0,0 +1,20 @@
+
+module Cerealize
+  module Codec; end
+  module Codec::Yaml
+    module_function
+
+    # See YAML spec (though might fail if "directives"?)
+    def yours?(str)
+      str[0..2] == '---'
+    end
+
+    def encode(obj)
+      YAML.dump(obj)
+    end
+
+    def decode(str)
+      YAML.load(str)
+    end
+  end
+end

data/lib/cerealize/version.rb

@@ -0,0 +1,4 @@
+
+module Cerealize
+  VERSION = '0.8.0'
+end

data/test/helper.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+
+def set_encoding(encoding)
+  Boat.send :cerealize, :captain, nil, :encoding => encoding
+end

data/test/helper_active_record.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+ActiveRecord::Base.establish_connection(
+  :adapter  => 'sqlite3',
+  :database => ':memory:'
+)
+
+class Boat < ActiveRecord::Base
+  include Cerealize
+  cerealize :captain
+  cerealize :cargo, Blob
+end
+
+ActiveRecord::Base.connection.create_table :boats, :force => true do |t|
+  t.string  :name
+  t.integer :tonnage
+  t.string  :captain
+  t.string  :cargo
+end
+
+
+
+class Cat < ActiveRecord::Base
+  include Cerealize
+  cerealize :name, String, :encoding => :yaml
+  cerealize :tail, Array,  :encoding => :marshal, :force_encoding => true
+  cerealize :food, Hash,   :encoding => :marshal
+end
+
+ActiveRecord::Base.connection.create_table :cats, :force => true do |t|
+  t.text :name
+  t.text :tail
+  t.text :food
+end

data/test/stub.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+class Person
+  def initialize(name, age=nil)
+    self.name = name
+    self.age  = age
+  end
+
+  ATTR = [ :name, :age, :hat, :pocket ]
+  attr_accessor(*ATTR)
+
+  def ==(other)
+    ATTR.all?{|m| send(m) == other.send(m) }
+  end
+  def eql?(other)
+    ATTR.all?{|m| send(m).eql? other.send(m) }
+  end
+end
+
+class Hat
+  def initialize(color); self.color = color; end
+  attr_accessor :color
+end
+
+class Blob; end

data/test/test_all_codec.rb

@@ -0,0 +1,242 @@
+# encoding: utf-8
+
+require 'rubygems' if RUBY_VERSION < '1.9.1'
+require 'cerealize'
+
+require 'test/stub'
+require 'test/helper'
+require 'test/helper_active_record'
+
+require 'test/unit'
+
+class AllCodecTest < Test::Unit::TestCase
+  def setup
+    Boat.delete_all
+  end
+
+  def teardown
+  end
+
+  Cerealize.codec_names.each do |encoding|
+
+    define_method "test_#{encoding}_basic" do
+      set_encoding(encoding)
+
+      b = Boat.create(:name => 'pequod')
+
+      b.captain = Person.new('ahab')
+      b.save!
+
+      b = Boat.find_by_name('pequod')
+      assert_equal Person, b.captain.class
+      assert_equal 'ahab', b.captain.name
+
+      b.captain = Person.new('ishmael')             # make sure not frozen!
+      assert_equal 'ishmael', b.captain.name
+      b.captain.name = 'call me ishmael'
+      b.save!
+
+      b = Boat.find_by_name('pequod')
+      assert_equal 'call me ishmael', b.captain.name
+    end
+
+    ['string', {:key1 => 'v', :key2 => [3,4]}].each do |captain|
+      define_method "test_#{encoding}_for_#{captain}_changed?" do
+        b = Boat.create(:captain => captain)
+        assert !b.changed?
+        b.captain = b.captain
+        assert !b.changed?
+        b.captain = captain
+        assert !b.changed?
+        b.captain = captain.dup
+        assert !b.changed?
+        b.captain = case captain
+                      when String; captain.reverse
+                      when Hash;   captain.merge(:key2 => [1,2])
+                    end
+        assert b.changed?
+      end
+    end
+
+    [ :none, :read, :read_write, :write ].each do |action|
+
+      define_method "test_#{encoding}_partial_update_#{action}" do
+        set_encoding(encoding)
+
+        Boat.delete_all
+
+        b1 = Boat.create :name => 'titanic', :tonnage => 1000
+        b1.captain = Person.new 'smith'
+        b1.save!
+
+        b1 = Boat.find_by_name 'titanic'
+        b1.tonnage += 1000
+        if [:read, :read_write].include?(action)
+          b1.captain
+        end
+        if [:read_write, :write].include?(action)
+          b1.captain = Person.new 'dawson'
+        end
+
+        b2 = Boat.find_by_name 'titanic'
+        b2.captain = Person.new 'rose'
+        b2.save!
+
+        b1.save! # Potentially overwriting save!
+
+        b3 = Boat.find_by_name 'titanic'
+        if [:read_write, :write].include?(action)
+          assert_equal 'dawson', b3.captain.name
+        elsif action == :none
+          assert_equal 'rose', b3.captain.name
+        elsif action == :read
+          assert %w{ rose dawson }.include?(b3.captain.name),
+            "captain.name is #{b3.captain.name}"
+        end
+      end
+    end
+
+    define_method "test_#{encoding}_just_save" do
+      set_encoding(encoding)
+      b1 = Boat.new :name => 'alinghi'
+      b1.save!
+      assert_equal nil, Boat.find_by_name('alinghi').captain
+    end
+
+    define_method "test_#{encoding}_just_save_writing" do
+      set_encoding(encoding)
+      b1 = Boat.new :name => 'surprise'
+      b1.captain = Person.new 'aubrey'
+      b1.save!
+      assert_equal 'aubrey', Boat.find_by_name('surprise').captain.name
+    end
+
+    define_method "test_#{encoding}_just_reading" do
+      set_encoding(encoding)
+      b1 = Boat.create :name => 'black pearl', :captain => Person.new('sparrow')
+      b2 = Boat.find_by_name 'black pearl'
+      assert_equal 'sparrow', b2.captain.name
+    end
+
+    define_method "test_#{encoding}_deep_change" do
+      set_encoding(encoding)
+      b1 = Boat.create :name => 'bounty', :captain => (Person.new('bligh'))
+
+      b2 = Boat.find_by_name 'bounty'
+      b2.captain.hat = Hat.new('blue')
+      b2.save!
+
+      assert_equal 'blue', Boat.find_by_name('bounty').captain.hat.color
+    end
+
+    define_method "test_#{encoding}_deeper_change_object" do
+      set_encoding(encoding)
+      b1 = Boat.create :name => 'bounty', :captain => (Person.new('bligh'))
+
+      b2 = Boat.find_by_name 'bounty'
+      b2.captain.pocket = [ :pounds ]
+      b2.save!
+
+      b2 = Boat.find_by_name 'bounty'
+      b2.captain.pocket << :francs
+      b2.save!
+
+      assert_equal [ :pounds, :francs ], Boat.find_by_name('bounty').captain.pocket
+    end
+
+    define_method "test_#{encoding}_deeper_change_hash" do
+      set_encoding(encoding)
+      b1 = Boat.create :name => 'bounty', :captain => { :name => :bligh }
+
+      b2 = Boat.find_by_name 'bounty'
+      b2.captain[:pocket] = [ :pounds ]
+      b2.save!
+
+      b2 = Boat.find_by_name 'bounty'
+      b2.captain[:pocket] << :francs
+      b2.save!
+
+      assert_equal [ :pounds, :francs ], Boat.find_by_name('bounty').captain[:pocket]
+    end
+
+
+    define_method "test_#{encoding}_class_checking" do
+      set_encoding(encoding)
+      Boat.create :name => 'lollypop', :cargo => Blob.new
+      Boat.find_by_name 'lollypop'
+
+      Boat.create :name => 'minerva', :cargo => "WRONG KIND"
+      assert_raise ActiveRecord::SerializationTypeMismatch do
+        Boat.find_by_name('minerva').cargo
+      end
+    end
+
+    define_method "test_#{encoding}_simple_hash" do
+      set_encoding(encoding)
+      b = Boat.new
+      h = { :name => 'skipper' }
+      b.captain = h
+      assert_equal h, b.captain
+      b.save
+      assert_equal h, b.captain
+      b.captain[:actor] = 'alan hale'
+      assert_equal 'alan hale', b.captain[:actor]
+    end
+
+    define_method "test_#{encoding}_check_if_really_saved" do
+      set_encoding(encoding)
+      b = Boat.new
+      b.captain = { :name => 'ramius' }
+      b.save
+
+      b2 = Boat.find(b.id)
+      assert_equal b.captain, b2.captain
+      b2.captain[:nationality] = 'russian'
+      b2.save
+
+      b3 = Boat.find(b2.id)
+      assert_equal 'russian', b3.captain[:nationality]
+    end
+
+    define_method "test_#{encoding}_array_cerealize" do
+      set_encoding(encoding)
+      b = Boat.new
+      b.captain = [123, 456]
+      b.save
+      assert_equal [123, 456], b.captain
+      assert_equal [123, 456], Boat.find(b.id).captain
+    end
+
+    define_method "test_#{encoding}_repeated_saves" do
+      set_encoding(encoding)
+      b = Boat.new
+      b.captain = { :name => 'kirk', :age => 23 }
+      b.save
+
+      assert_equal 23, b.captain[:age]
+      assert_equal 23, Boat.first.captain[:age]
+
+      b.captain[:age] += 1
+      b.save
+      assert_equal 24, b.captain[:age]
+      assert_equal 24, Boat.first.captain[:age]
+
+      b.captain[:age] += 1
+      b.save
+      b.captain[:age] += 1
+      b.save
+      assert_equal 26, b.captain[:age]
+      assert_equal 26, Boat.first.captain[:age]
+
+      b.captain[:age] += 1
+      b.save
+      b.captain[:age] += 1
+      b.save
+      b.captain[:age] += 1
+      b.save
+      assert_equal 29, b.captain[:age]
+      assert_equal 29, Boat.first.captain[:age]
+
+    end
+  end
+end

data/test/test_basic.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+require 'rubygems' if RUBY_VERSION < '1.9.1'
+require 'cerealize'
+
+require 'test/stub'
+require 'test/helper'
+require 'test/helper_active_record'
+
+require 'test/unit'
+
+class BasicTest < Test::Unit::TestCase
+  def setup
+    Boat.delete_all
+  end
+
+  def teardown
+  end
+
+  def test_encoding_yaml
+    set_encoding(:yaml)
+    Boat.create :name => 'yamato', :captain => Person.new('kosaku')
+    s = Boat.connection.select_value("SELECT captain FROM boats WHERE name='yamato';")
+    assert s[0..2] = '---'
+  end
+
+  def test_encoding_marshal
+    set_encoding(:marshal)
+    Boat.create :name => 'santa maria', :captain => Person.new('columbus')
+    s = Boat.connection.select_value("SELECT captain FROM boats WHERE name='santa maria';")
+    assert s[0..1] = 'BA'
+  end
+
+end

data/test/test_transcode.rb

@@ -0,0 +1,75 @@
+# encoding: utf-8
+
+require 'rubygems' if RUBY_VERSION < '1.9.1'
+require 'cerealize'
+
+require 'test/stub'
+require 'test/helper'
+require 'test/helper_active_record'
+
+require 'test/unit'
+
+class TranscodeTest < Test::Unit::TestCase
+  def setup
+    Cat.delete_all
+  end
+
+  def teardown
+  end
+
+  def test_no_such_codec
+    assert_raise Cerealize::NoSuchCodec do
+      Cat.dup.send(:cerealize, :bad, Hash, :encoding => :blah)
+    end
+  end
+
+  def test_no_suitable_codec_if_force_encoding
+    cat = Cat.new
+    cat[:tail] = '---'
+    cat.save
+    id = cat.id
+    assert_raise Cerealize::NoSuitableCodec do
+      Cat.find(id).tail
+    end
+  end
+
+  def test_auto_transcode_yaml
+    name = 'Nine Tails'
+    marshaled_name = Cerealize::Codec::Marshal.encode(name)
+    cat = Cat.new
+    cat[:name] = marshaled_name
+    cat.save
+    id = cat.id
+
+    new_cat = Cat.find(id)
+    assert_equal name, new_cat.name
+    new_cat.name.reverse!
+
+    # no change if not saved yet
+    assert_equal marshaled_name, new_cat[:name]
+    new_cat.save
+
+    # should be transcode into YAML
+    assert Cerealize::Codec::Yaml.yours?(new_cat[:name])
+    new_cat.reload
+    assert Cerealize::Codec::Yaml.yours?(new_cat[:name])
+  end
+
+  def test_auto_transcode_marshal
+    food = {:a => :b}
+    yamled_food = Cerealize::Codec::Yaml.encode(food)
+    cat = Cat.new
+    cat[:food] = yamled_food
+    cat.save
+    cat.reload
+
+    assert_equal food, cat.food
+    assert_equal yamled_food, cat[:food]
+    cat.food.merge!(:c => :d)
+    cat.save
+    cat.reload
+
+    assert Cerealize::Codec::Marshal.yours?(cat[:food])
+    assert_equal food.merge(:c => :d), cat.food
+  end
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification 
+name: cerealize
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 8
+  - 0
+  version: 0.8.0
+platform: ruby
+authors: 
+- Cardinal Blue
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-19 00:00:00 +08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 3
+        - 5
+        version: 2.3.5
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: bones
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 3
+        - 4
+        - 1
+        version: 3.4.1
+  type: :development
+  version_requirements: *id002
+description: "  Serialize out of the Cerealize Box\n  - a drop-in replacement for ActiveRecord's serialize\n\n  It can auto transcode old encoding (yaml if you're using AR's serialize),\n  to new encoding (marshal, json, you name it) without any migration.\n\n  Current supported encoding:\n  1. YAML\n  2. Marshal\n  3. JSON (planned)\n\n  Current supported ORM:\n  1. ActiveRecord (tested with 2.3.5)\n  2. DataMapper (planned)"
+email: dev (XD) cardinalblue.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- CHANGES
+- LICENSE
+- README
+- Rakefile
+- TODO
+files: 
+- CHANGES
+- LICENSE
+- README
+- Rakefile
+- TODO
+- init.rb
+- lib/cerealize.rb
+- lib/cerealize/codec/marshal.rb
+- lib/cerealize/codec/yaml.rb
+- lib/cerealize/version.rb
+- test/helper.rb
+- test/helper_active_record.rb
+- test/stub.rb
+- test/test_all_codec.rb
+- test/test_basic.rb
+- test/test_transcode.rb
+has_rdoc: true
+homepage: http://github.com/cardinalblue/cerealize
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: cerealize
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Serialize out of the Cerealize Box - a drop-in replacement for ActiveRecord's serialize  It can auto transcode old encoding (yaml if you're using AR's serialize), to new encoding (marshal, json, you name it) without any migration
+test_files: 
+- test/test_all_codec.rb
+- test/test_basic.rb
+- test/test_transcode.rb