serialize-rails 0.0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2011 Jan Berdajs
+
+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.rdoc

@@ -0,0 +1,24 @@
+= Serialize for Rails
+
+Rails already supports serialization of attributes, but it can only do Yaml.
+This gem upgrades the default Rails serialize method so you can serialize into
+yaml, json, xml and with marshal (Ruby binary format). It also supports gzipping
+the output if you want it to take up less space.
+
+Format can be one of the following:
+
+    :yaml, :json, :xml, :marshal
+
+Yaml is the default, and serialize will behave just like normal if you don't use
+any of the new options.
+
+Example usage:
+
+    class Mouse < ActiveRecord::Base
+      serialize :info, Hash, :format => :json
+      serialize :data, :format => :xml, :gzip => true
+    end
+
+When you use gzip you __must__ use a binary-compatible column type such
+as `BLOB` (MySQL) or `bytea` (PostgreSQL). If you don't use gzip, `text` is
+recommended to allow strings of arbitrary length.

data/Rakefile

@@ -0,0 +1,38 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'SerializeRails'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task :default => :test

data/lib/serialize-rails.rb

@@ -0,0 +1,5 @@
+require 'serialize-rails/serialization'
+require 'serialize-rails/coders/json_column'
+require 'serialize-rails/coders/xml_column'
+require 'serialize-rails/coders/marshal_column'
+require 'serialize-rails/coders/gzip_column'

data/lib/serialize-rails/coders/gzip_column.rb

@@ -0,0 +1,42 @@
+require 'zlib'
+
+module ActiveRecord
+  module Coders # :nodoc:
+    class GzipColumn # :nodoc:
+      RESCUE_ERRORS = [ ArgumentError ]
+
+      attr_accessor :wrapped_coder
+
+      def initialize(wrap_coder)
+        @wrapped_coder = wrap_coder
+      end
+
+      def object_class
+        wrapped_coder.object_class
+      end
+
+      def object_class=(value)
+        wrapped_coder.object_class = value
+      end
+
+      def dump(obj)
+        obj = wrapped_coder.dump(obj)
+        return if obj.nil?
+        return obj unless obj.is_a?(String)
+
+        Zlib::Deflate.deflate obj
+      end
+
+      def load(data)
+        return object_class.new if object_class != Object && data.nil?
+        return data unless data.is_a?(String)
+        begin
+          ungzipped_data = Zlib::Inflate.inflate(data)
+          wrapped_coder.load(ungzipped_data)
+        rescue *RESCUE_ERRORS
+          data
+        end
+      end
+    end
+  end
+end

data/lib/serialize-rails/coders/json_column.rb

@@ -0,0 +1,43 @@
+require 'json'
+
+module ActiveRecord
+  module Coders # :nodoc:
+    class JSONColumn # :nodoc:
+      RESCUE_ERRORS = [ ArgumentError, JSON::JSONError ]
+
+      attr_accessor :object_class
+
+      def initialize(object_class = Object)
+        @object_class = object_class
+      end
+
+      def dump(obj)
+        return if obj.nil?
+
+        unless obj.is_a?(object_class)
+          raise SerializationTypeMismatch,
+            "Attribute was supposed to be a #{object_class}, but was a #{obj.class}. -- #{obj.inspect}"
+        end
+        JSON.dump obj
+      end
+
+      def load(json)
+        return object_class.new if object_class != Object && json.nil?
+        return json unless json.is_a?(String)
+        begin
+          obj = JSON.load(json)
+
+          unless obj.is_a?(object_class) || obj.nil?
+            raise SerializationTypeMismatch,
+              "Attribute was supposed to be a #{object_class}, but was a #{obj.class}"
+          end
+          obj ||= object_class.new if object_class != Object
+
+          obj
+        rescue *RESCUE_ERRORS
+          json
+        end
+      end
+    end
+  end
+end

data/lib/serialize-rails/coders/marshal_column.rb

@@ -0,0 +1,41 @@
+module ActiveRecord
+  module Coders # :nodoc:
+    class MarshalColumn # :nodoc:
+      RESCUE_ERRORS = [ ArgumentError, TypeError ]
+
+      attr_accessor :object_class
+
+      def initialize(object_class = Object)
+        @object_class = object_class
+      end
+
+      def dump(obj)
+        return if obj.nil?
+
+        unless obj.is_a?(object_class)
+          raise SerializationTypeMismatch,
+            "Attribute was supposed to be a #{object_class}, but was a #{obj.class}. -- #{obj.inspect}"
+        end
+        Marshal.dump obj
+      end
+
+      def load(data)
+        return object_class.new if object_class != Object && data.nil?
+        return data unless data.is_a?(String)
+        begin
+          obj = Marshal.load(data)
+
+          unless obj.is_a?(object_class) || obj.nil?
+            raise SerializationTypeMismatch,
+              "Attribute was supposed to be a #{object_class}, but was a #{obj.class}"
+          end
+          obj ||= object_class.new if object_class != Object
+
+          obj
+        rescue *RESCUE_ERRORS
+          data
+        end
+      end
+    end
+  end
+end

data/lib/serialize-rails/coders/xml_column.rb

@@ -0,0 +1,47 @@
+require 'ox'
+
+module ActiveRecord
+  module Coders # :nodoc:
+    class XMLColumn # :nodoc:
+      RESCUE_ERRORS = [ ArgumentError, SyntaxError ]
+
+      attr_accessor :object_class, :options
+
+      def initialize(object_class = Object, options = nil)
+        @object_class = object_class
+        @options = options || Hash.new
+        default_options = { :load => Hash.new, :dump => Hash.new }
+        @options = default_options.merge(@options)
+      end
+
+      def dump(obj)
+        return if obj.nil?
+
+        unless obj.is_a?(object_class)
+          raise SerializationTypeMismatch,
+            "Attribute was supposed to be a #{object_class}, but was a #{obj.class}. -- #{obj.inspect}"
+        end
+        Ox.dump(obj, options[:dump])
+      end
+
+      def load(xml)
+        return object_class.new if object_class != Object && xml.nil?
+        return xml unless xml.is_a?(String)
+        begin
+          default_load_opts = { :mode => :object }
+          obj = Ox.load(xml, default_load_opts.merge(options[:load]))
+
+          unless obj.is_a?(object_class) || obj.nil?
+            raise SerializationTypeMismatch,
+              "Attribute was supposed to be a #{object_class}, but was a #{obj.class}"
+          end
+          obj ||= object_class.new if object_class != Object
+
+          obj
+        rescue *RESCUE_ERRORS
+          xml
+        end
+      end
+    end
+  end
+end

data/lib/serialize-rails/serialization.rb

@@ -0,0 +1,69 @@
+# Must trigger autoloading of the class
+if ActiveRecord::AttributeMethods::Serialization.nil?
+  raise "ActiveRecord not loaded"
+end
+
+module ActiveRecord
+  module AttributeMethods
+    module Serialization
+      module ClassMethods
+        # If you have an attribute that needs to be saved to the database as an
+        # object, and retrieved as the same object, then specify the name of that
+        # attribute using this method and it will be handled automatically. The
+        # serialization is done through YAML. If +class_name+ is specified, the
+        # serialized object must be of that class on retrieval or
+        # <tt>SerializationTypeMismatch</tt> will be raised.
+        #
+        # ==== Parameters
+        #
+        # * +attr_name+ - The field name that should be serialized.
+        # * +class_name+ - Optional, class name that the object type should be equal to.
+        #
+        # ==== Example
+        #
+        #   # Serialize a preferences attribute.
+        #   class User < ActiveRecord::Base
+        #     serialize :preferences
+        #   end
+        def serialize(attr_name, *args)
+          include Behavior if defined? Behavior # Rails 4
+
+          options = args.shift
+          if options.is_a? Hash
+            class_name = Object
+          else
+            class_name = options || Object
+            options = args.shift || Hash.new
+          end
+
+          default_options = {
+            :format => :yaml,
+            :gzip => false
+          }
+          options = default_options.merge(options)
+
+          coder = if [:load, :dump].all? { |x| class_name.respond_to?(x) }
+                    class_name
+                  else
+                    case options[:format]
+                    when :json
+                      Coders::JSONColumn.new(class_name)
+                    when :marshal
+                      Coders::MarshalColumn.new(class_name)
+                    when :xml
+                      Coders::XMLColumn.new(class_name, options[:ox_options])
+                    else
+                      Coders::YAMLColumn.new(class_name)
+                    end
+                  end
+
+          coder = Coders::GzipColumn.new(coder) if options[:gzip]
+
+          # merge new serialized attribute and create new hash to ensure that each class in inheritance hierarchy
+          # has its own hash of own serialized attributes
+          self.serialized_attributes = serialized_attributes.merge(attr_name.to_s => coder)
+        end
+      end
+    end
+  end
+end

data/lib/serialize-rails/version.rb

@@ -0,0 +1,3 @@
+module SerializeRails
+  VERSION = "0.0.1"
+end

data/test/active_record_helper.rb

@@ -0,0 +1,12 @@
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+ActiveRecord::Migration.verbose = false
+load "schema.rb"
+
+def get_raw_info
+  raw_data = ActiveRecord::Base.connection.select_all("SELECT info FROM mice")
+  raw_data.first["info"]
+end
+
+def clean_db
+  ActiveRecord::Base.connection.select_all("DELETE FROM mice")
+end

data/test/gzip_column_test.rb

@@ -0,0 +1,29 @@
+require 'test_helper'
+require 'serialize-rails/coders/gzip_column'
+require 'serialize-rails/coders/json_column'
+
+module ActiveRecord
+  module Coders
+    class JSONColumnTest < ActiveSupport::TestCase
+      def test_initialize_takes_class
+        coder = GzipColumn.new(JSONColumn.new(Object))
+        assert_equal Object, coder.object_class
+      end
+
+      def test_gzip_works
+        json_coder = JSONColumn.new(Object)
+        coder = GzipColumn.new(json_coder)
+
+        test_array = ["hello"] * 5
+        json_output = json_coder.dump(test_array)
+        gzipped_output = coder.dump(test_array)
+        assert_operator json_output.length, :>, gzipped_output.length
+      end
+
+      def test_dump_and_load
+        coder = GzipColumn.new(JSONColumn.new(Object))
+        assert_equal([1, "x"], coder.load(coder.dump([1, "x"])))
+      end
+    end
+  end
+end

data/test/json_column_test.rb

@@ -0,0 +1,48 @@
+require 'test_helper'
+require 'serialize-rails/coders/json_column'
+
+module ActiveRecord
+  module Coders
+    class JSONColumnTest < ActiveSupport::TestCase
+      def test_initialize_takes_class
+        coder = JSONColumn.new(Object)
+        assert_equal Object, coder.object_class
+      end
+
+      def test_type_mismatch_on_different_classes_on_dump
+        coder = JSONColumn.new(Array)
+        assert_raises(SerializationTypeMismatch) do
+          coder.dump("a")
+        end
+      end
+
+      def test_type_mismatch_on_different_classes
+        coder = JSONColumn.new(Array)
+        assert_raises(SerializationTypeMismatch) do
+          coder.load "{}"
+        end
+      end
+
+      def test_nil_is_ok
+        coder = JSONColumn.new
+        assert_nil coder.load "null"
+      end
+
+      def test_returns_new_with_different_class
+        coder = JSONColumn.new SerializationTypeMismatch
+        assert_equal SerializationTypeMismatch, coder.load("null").class
+      end
+
+      def test_load_handles_other_classes
+        coder = JSONColumn.new
+        assert_equal [], coder.load([])
+      end
+
+      def test_load_swallows_json_exceptions
+        coder = JSONColumn.new
+        bad_json = 'x'
+        assert_equal bad_json, coder.load(bad_json)
+      end
+    end
+  end
+end

data/test/marshal_column_test.rb

@@ -0,0 +1,48 @@
+require 'test_helper'
+require 'serialize-rails/coders/marshal_column'
+
+module ActiveRecord
+  module Coders
+    class MarshalColumnTest < ActiveSupport::TestCase
+      def test_initialize_takes_class
+        coder = MarshalColumn.new(Object)
+        assert_equal Object, coder.object_class
+      end
+
+      def test_type_mismatch_on_different_classes_on_dump
+        coder = MarshalColumn.new(Array)
+        assert_raises(SerializationTypeMismatch) do
+          coder.dump("a")
+        end
+      end
+
+      def test_type_mismatch_on_different_classes
+        coder = MarshalColumn.new(Array)
+        assert_raises(SerializationTypeMismatch) do
+          coder.load Marshal.dump(Hash.new)
+        end
+      end
+
+      def test_nil_is_ok
+        coder = MarshalColumn.new
+        assert_nil coder.load Marshal.dump(nil)
+      end
+
+      def test_returns_new_with_different_class
+        coder = MarshalColumn.new SerializationTypeMismatch
+        assert_equal SerializationTypeMismatch, coder.load(Marshal.dump(nil)).class
+      end
+
+      def test_load_handles_other_classes
+        coder = MarshalColumn.new
+        assert_equal [], coder.load([])
+      end
+
+      def test_load_swallows_marshal_exceptions
+        coder = MarshalColumn.new
+        bad_marshal = '{}'
+        assert_equal bad_marshal, coder.load(bad_marshal)
+      end
+    end
+  end
+end

data/test/schema.rb

@@ -0,0 +1,25 @@
+ActiveRecord::Schema.define(:version => 0) do
+  create_table :mice, :force => true do |t|
+    t.text :info
+  end
+end
+
+class MouseDefaults < ActiveRecord::Base
+  self.table_name = "mice"
+  serialize :info
+end
+
+class MouseDefaultsArray < ActiveRecord::Base
+  self.table_name = "mice"
+  serialize :info, Array
+end
+
+class MouseJsonArray < ActiveRecord::Base
+  self.table_name = "mice"
+  serialize :info, Array, :format => :json
+end
+
+class MouseJsonArrayGzip < ActiveRecord::Base
+  self.table_name = "mice"
+  serialize :info, Array, :format => :json, :gzip => true
+end

data/test/serialization_test.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+require 'active_record_helper'
+require 'serialize-rails/coders/gzip_column'
+require 'serialize-rails/coders/json_column'
+require 'serialize-rails/serialization'
+
+# mostly already tested in AR tests, and did not change much
+class SerializationTest < ActiveSupport::TestCase
+  def teardown
+    clean_db
+  end
+
+  def test_defaults_to_yaml
+    MouseDefaults.create! :info => { 1 => "x" }
+    assert_equal("---\n1: x\n", get_raw_info)
+  end
+
+  def test_yaml_array
+    assert_raises(ActiveRecord::SerializationTypeMismatch) do
+      MouseDefaultsArray.create! :info => { 1 => "x" }
+    end
+  end
+
+  def test_json_array
+    MouseJsonArray.create! :info => Array.new
+    assert_equal("[]", get_raw_info.gsub(/\s+/, ""))
+  end
+
+  def test_json_array_gzip
+    test_array = ["hello"] * 5
+    MouseJsonArrayGzip.create! :info => test_array
+    json_for_array = ActiveRecord::Coders::JSONColumn.new(Array).dump(test_array)
+    assert_operator get_raw_info.length, :<, json_for_array.length
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,12 @@
+# Configure Rails Environment
+ENV["RAILS_ENV"] = "test"
+
+require 'test/unit'
+require 'active_support/all'
+require 'active_record'
+require 'serialize-rails'
+require 'active_record/errors'
+# require 'mocha'
+
+# Load support files
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }

data/test/xml_column_test.rb

@@ -0,0 +1,51 @@
+require 'test_helper'
+require 'serialize-rails/coders/xml_column'
+
+module ActiveRecord
+  module Coders
+    class XMLColumnTest < ActiveSupport::TestCase
+      XML_NIL = Ox.dump(nil)
+      XML_EMPTY_HASH = Ox.dump({})
+
+      def test_initialize_takes_class
+        coder = XMLColumn.new(Object)
+        assert_equal Object, coder.object_class
+      end
+
+      def test_type_mismatch_on_different_classes_on_dump
+        coder = XMLColumn.new(Array)
+        assert_raises(SerializationTypeMismatch) do
+          coder.dump("a")
+        end
+      end
+
+      def test_type_mismatch_on_different_classes
+        coder = XMLColumn.new(Array)
+        assert_raises(SerializationTypeMismatch) do
+          coder.load XML_EMPTY_HASH
+        end
+      end
+
+      def test_nil_is_ok
+        coder = XMLColumn.new
+        assert_nil coder.load XML_NIL
+      end
+
+      def test_returns_new_with_different_class
+        coder = XMLColumn.new SerializationTypeMismatch
+        assert_equal SerializationTypeMismatch, coder.load(XML_NIL).class
+      end
+
+      def test_load_handles_other_classes
+        coder = XMLColumn.new
+        assert_equal [], coder.load([])
+      end
+
+      def test_load_swallows_xml_exceptions
+        coder = XMLColumn.new
+        bad_xml = 'x'
+        assert_equal bad_xml, coder.load(bad_xml)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification
+name: serialize-rails
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Jan Berdajs
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: ox
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- mrbrdo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/serialize-rails/coders/gzip_column.rb
+- lib/serialize-rails/coders/json_column.rb
+- lib/serialize-rails/coders/marshal_column.rb
+- lib/serialize-rails/coders/xml_column.rb
+- lib/serialize-rails/serialization.rb
+- lib/serialize-rails/version.rb
+- lib/serialize-rails.rb
+- MIT-LICENSE
+- Rakefile
+- README.rdoc
+- test/active_record_helper.rb
+- test/gzip_column_test.rb
+- test/json_column_test.rb
+- test/marshal_column_test.rb
+- test/schema.rb
+- test/serialization_test.rb
+- test/test_helper.rb
+- test/xml_column_test.rb
+homepage: https://github.com/mrbrdo/serialize-rails
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Rails attribute serialization into yaml, json, xml and with ruby marshal.
+test_files:
+- test/active_record_helper.rb
+- test/gzip_column_test.rb
+- test/json_column_test.rb
+- test/marshal_column_test.rb
+- test/schema.rb
+- test/serialization_test.rb
+- test/test_helper.rb
+- test/xml_column_test.rb
+has_rdoc: