chikamichi-marshalize 1.0.4

data/.gitignore

@@ -0,0 +1,4 @@
+*~
+log/*.log
+tmp/**/*
+

data/COPYING

@@ -0,0 +1,14 @@
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+                    Version 2, December 2004
+
+ Copyright (C) 2004 Sam Hocevar
+  14 rue de Plaisance, 75014 Paris, France
+ Everyone is permitted to copy and distribute verbatim or modified
+ copies of this license document, and changing it is allowed as long
+ as the name is changed.
+
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. You just DO WHAT THE FUCK YOU WANT TO.
+

data/ChangeLog.rdoc

@@ -0,0 +1,18 @@
+= 1.0
+
+== 1.0.4
+
+- gemspc with Jeweler!
+
+== 1.0.2, 1.0.3
+
+- gempsec, again
+
+== 1.0.1
+
+- gemspec
+
+== 1.0.0
+
+- initial release
+- documentation

data/README.rdoc

@@ -0,0 +1,47 @@
+= Marshalize
+
+This Rails plugin provides serialization using Marshal[http://ruby-doc.org/core/classes/Marshal.html] in the same way Rails provides builtin serialization using YAML. In a model, just do
+  class Robot < ActiveRecord::Base
+    marshalize :features
+  end
+and your app will automagically handle the +features+ attribute using Marshal, dumping when saving to the database, loading when fetching from it.
+
+You can register any kind object (not just arrays and hashes...). Be aware that Marshal defines a binary format, which may change in incoming Ruby releases and is currently not portable outside the Ruby scripting world. For a portable yet slower alternatives, you may try JSON or YML serializers.
+
+== Example
+
+  class Robot < ActiveRecord::Base
+    
+    marshalize :parameters               # The "parameters" attribute will be saved as binary data
+    
+    marshalize :features,  RobotFeature  # You can define what kind of object is to be marshalized
+                                         # An error will be raised if another class is provided for
+                                         # this attribute
+    
+    serialize  :status,    Array         # Marshalization plays well with YAML classic serialization
+  
+  end
+
+== Installation
+
+=== as a plugin:
+
+In your Rails application root directory:
+
+  script/plugin install git://github.com/chikamichi/marshalize.git
+
+=== as a gem:
+
+Not yet!
+
+No rake task needed.
+
+== TODO
+
+* +super+ stuff
+* manage blobs, not just text field (buffer limitations)
+* rake tasks to manage marshalized data recovering in case Marshal went astray (say, a new version breaking things down) 
+
+== License
+
+Released under the WTFPL (http://sam.zoy.org/wtfpl/COPYING)

data/Rakefile

@@ -0,0 +1,29 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the marshalize plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "marshalize"
+    gemspec.summary     = %q{Marshalize is a Rails plugin enabling ActiveRecord attributes serialization using the Marshal binary converter library.}
+    gemspec.description = %q{This Rails plugin provides serialization using Marshal in the same way Rails provides builtin serialization using YAML. You can register any kind object (not just arrays and hashes…). Be aware that Marshal defines a binary format, which may change in incoming Ruby releases and is currently not portable outside the Ruby scripting world. For a portable yet slower alternatives, you may try JSON or YML serializers.}
+    gemspec.email       = "jd@vauguet.fr"
+    gemspec.homepage    = "http://github.com/chikamichi/marshalize"
+    gemspec.authors =   ["Jean-Denis Vauguet"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+

data/VERSION

@@ -0,0 +1 @@
+1.0.4

data/generators/marshalize/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Explain the generator
+
+Example:
+    ./script/generate marshalize Thing
+
+    This will create:
+        what/will/it/create

data/generators/marshalize/marshalize_generator.rb

@@ -0,0 +1,8 @@
+class MarshalizeGenerator < Rails::Generator::NamedBase
+  def manifest
+    record do |m|
+      # m.directory "lib"
+      # m.template 'README', "README"
+    end
+  end
+end

data/init.rb

@@ -0,0 +1 @@
+# Include hook code here

data/lib/marshalize.rb

@@ -0,0 +1,283 @@
+require 'activesupport'
+
+# This module is split in several submodules for selective inclusion purpose
+module Marshalization #:nodoc:
+
+  VERSION = 0.1
+
+  module Dirty #:nodoc:
+
+    private
+
+    def update_with_marshalization
+      if partial_updates?
+        # Serialized and marshalized attributes should always be written in case they've been
+        # changed in place.
+        update_without_dirty(self.class.marshalized_attributes.keys)
+      else
+        update_without_dirty
+      end
+
+      update_with_dirty # an implicit call to super, which would fail as it is a private method
+                        # update_with_dirty is not
+    end
+
+    def self.included(receiver)
+      receiver.alias_method_chain :update, :marshalization
+    end
+  end
+  
+  #module Timestamp #:nodoc:
+    
+    #private
+
+    #def update_with_timestamps(*args) #:nodoc:
+      #if record_timestamps && (!partial_updates? || changed?)
+        #t = self.class.default_timezone == :utc ? Time.now.utc : Time.now
+        #write_attribute('updated_at', t) if respond_to?(:updated_at)
+        #write_attribute('updated_on', t) if respond_to?(:updated_on)
+      #end
+      #update_without_timestamps()
+    #end
+  #end
+
+  module Base # :nodoc:
+
+    marshalized_attributes ||= Hash.new
+
+    module ClassMethods #:nodoc:
+
+      # 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 Marshal. If +class_name+ is specified, the serialized object must be of that
+      # class on retrieval or SerializationTypeMismatch 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
+      #     serialize :preferences
+      #   end
+      def marshalize(attr_name, class_name = Object)
+        attr_name = attr_name.to_s
+        marshalized_attributes[attr_name] = class_name
+      end
+
+      # Returns a hash of all the attributes that have been specified for serialization as keys and their class restriction as values.
+      def marshalized_attributes
+        read_inheritable_attribute(:attr_marshalized) or write_inheritable_attribute(:attr_marshalized, {})
+      end
+
+    end # class: Marshalization::Base::ClassMethods
+
+    module InstanceMethods #:nodoc:
+
+      # Encode an attribute with ActiveSupport::Base64.encode64
+      def encode_attribute(attribute)
+        ActiveSupport::Base64.encode64(attribute)
+      end
+
+      # Decode an attribute with ActiveSupport::Base64.decode64
+      def decode_attribute(attribute)
+        ActiveSupport::Base64.decode64(attribute)
+      end
+
+      # Returns a copy of the attributes hash where all the values have been safely quoted for use in
+      # an SQL statement.
+      def attributes_with_quotes_with_marshalization(include_primary_key = true, include_readonly_attributes = true, attribute_names = @attributes.keys)
+
+        quoted = {}
+        connection = self.class.connection
+        attribute_names.each do |name|
+          if (column = column_for_attribute(name)) && (include_primary_key || !column.primary)
+
+            if self.class.marshalized_attributes.has_key?(name)
+              # smart-quoting Marshal-dumped values
+              quoted[name] = "'#{@attributes[name].to_s}'"
+            else
+              value = read_attribute(name)
+
+              # We need explicit to_yaml because quote() does not properly convert Time/Date fields to YAML.
+              if value && self.class.serialized_attributes.has_key?(name) && (value.acts_like?(:date) || value.acts_like?(:time))
+                value = value.to_yaml
+              end
+
+              quoted[name] = connection.quote(value, column)
+            end
+          end
+        end
+        include_readonly_attributes ? quoted : remove_readonly_attributes(quoted)
+      
+        # TODO in order to get rid of the aliasing, handle marshalized attributes, then call super
+        # passing all attributes but marshalized's. In fact, do it the reverse order so that the
+        # quoted hash is not made empty in super after we filled it
+        
+        #attribute_names.delete_if { |attribute| self.class.marshalized_attributes.has_key?(attribute) }
+        ##do stuff with marshalized_attributes.each -> quoted[name]
+        #puts "~~~~~~"
+        #puts attribute_names
+        #super(true, true, attribute_names)
+
+      end
+    end # module: Marshalization::Base::InstanceMethods
+
+    def self.included(receiver)
+      receiver.send :include, InstanceMethods
+      receiver.send :extend,  ClassMethods
+
+      unless receiver.respond_to?(:attributes_with_quotes_without_marshalization)
+        receiver.instance_eval do
+          alias_method_chain :attributes_with_quotes, :marshalization
+        end
+      end
+
+      #unless receiver.respond_to?(:update_with_dirty_without_marshalization)
+        #receiver.instance_eval do
+          #alias_method_chain :update_with_dirty, :marshalization
+        #end
+      #end
+    end
+
+  end # module: Marshalization::Base
+
+  module AttributeMethods
+
+    module ClassMethods
+
+      # This refactoring may break with incoming Rails releases since there is no call to super.
+      # See below for some explanations -- IMO it's too much work for a plugin, so this method
+      # is kind of a bold patch in itself
+      def define_attribute_methods
+        return if generated_methods?
+        columns_hash.each do |name, column|
+          if instance_method_already_implemented?(name)
+          else
+            if self.serialized_attributes[name]
+              define_read_method_for_serialized_attribute(name)
+            elsif self.marshalized_attributes[name]
+              define_read_method_for_marshalized_attribute(name)
+            elsif create_time_zone_conversion_attribute?(name, column)
+              define_read_method_for_time_zone_conversion(name)
+            else
+              define_read_method(name.to_sym, name, column)
+            end
+          end
+
+          unless instance_method_already_implemented?("#{name}=")
+            if create_time_zone_conversion_attribute?(name, column)
+              define_write_method_for_time_zone_conversion(name)
+            elsif self.marshalized_attributes[name]
+              define_write_method_for_marshalized_attribute(name.to_sym)
+            else
+              define_write_method(name.to_sym)
+            end
+          end
+
+          unless instance_method_already_implemented?("#{name}?")
+            define_question_method(name)
+          end
+        end
+
+        # attempt to have a call to super...
+        # it implies refactoring much of the columns handling in base.rb,
+        # because super (the original define_attribute_methods) calls
+        # several helpers which mess up with the prior marshalized 
+        # attributes definition process: columns_hash(), calling columns(), 
+        # hence the current connection.
+        #
+        # that's why it's a TODO and will probably stay as it
+        
+        #marshalized_attributes.each do |name, class_name|
+          #unless instance_method_already_implemented?(name)
+            #define_read_method_for_marshalized_attribute(name)
+          #end
+
+          #unless instance_method_already_implemented?("#{name}=")
+            #define_write_method_for_marshalized_attribute(name.to_sym)
+          #end
+
+          #unless instance_method_already_implemented?("#{name}?")
+            #define_question_method(name)
+          #end
+        #end
+
+        #generated_methods.clear
+        #@columns_hash.delete_if {|column_name, column| marshalized_attributes.has_key?(column_name) } 
+        #super
+        #columns_hash
+        ## TODO must add the suffix versions (= ?)
+        #generated_methods.merge(marshalized_attributes.keys)
+      end
+
+      # Define read method for marshalized attribute.
+      def define_read_method_for_marshalized_attribute(attr_name)
+        evaluate_attribute_method attr_name, "def #{attr_name}; unmarshalize_attribute('#{attr_name.to_sym}'); end"
+      end
+
+      def define_write_method_for_marshalized_attribute(attr_name)
+        evaluate_attribute_method attr_name, "def #{attr_name}=(new_value); marshalize_attribute('#{attr_name.to_sym}', new_value); end", "#{attr_name}="
+      end
+
+    end # class: Marshalization::AttributeMethods::ClassMethods
+
+    # Initialize an empty marshalized attribute.
+    # Prevents initialization error (marshal: data too short)
+    def initialize_marshalized_attribute(name, class_name)
+      @attributes[name] = encode_attribute(Marshal.dump(class_name.new))
+    end
+
+    def read_attribute(attr_name)
+      attr_name = attr_name.to_s
+      if !(value = @attributes[attr_name]).nil?
+        if column = column_for_attribute(attr_name)
+          if unmarshalizable_attribute?(attr_name, column)
+            unmarshalize_attribute(attr_name.to_sym)
+          else
+            super(attr_name.to_sym)
+          end
+        end
+      else
+      end
+    end
+
+    def marshalize_attribute(attr_name, value)
+      attr_name = attr_name.to_s
+      @attributes_cache.delete(attr_name)
+      if self.class.marshalized_attributes[attr_name]
+        dumped = encode_attribute(Marshal.dump(value))
+        @attributes[attr_name] = dumped
+      end
+    end
+
+    # Returns the unmarshalized object of the attribute.
+    def unmarshalize_attribute(attr_name)
+      attr_name = attr_name.to_s
+      if @attributes[attr_name].nil? || @attributes[attr_name] == ''
+        initialize_marshalized_attribute(attr_name, self.class.marshalized_attributes[attr_name])
+      end
+      unmarshalized_object = Marshal.load(decode_attribute(@attributes[attr_name]))
+
+      if unmarshalized_object.is_a?(self.class.marshalized_attributes[attr_name]) || unmarshalized_object.nil?
+        return unmarshalized_object
+      else
+        raise ActiveRecord::SerializationTypeMismatch,
+              "#{attr_name} was supposed to be a #{self.class.marshalized_attributes[attr_name]}, but was a #{unmarshalized_object.class.to_s}"
+      end
+    end
+
+    # Returns true if the attribute is of a text column and marked for marshalization.
+    def unmarshalizable_attribute?(attr_name, column)
+      column.text? && self.class.marshalized_attributes[attr_name]
+    end
+
+    def self.included(receiver)
+      receiver.send :extend, ClassMethods
+    end
+
+  end # module: Marshalization::AttributeMethods
+
+end # module: Marshalization

data/rails/init.rb

@@ -0,0 +1,5 @@
+require 'marshalize'
+
+ActiveRecord::Base.send :include, Marshalization::Base
+ActiveRecord::Base.send :include, Marshalization::AttributeMethods
+ActiveRecord::Base.send :include, Marshalization::Dirty

data/test/database.yml

@@ -0,0 +1,21 @@
+sqlite:
+  :adapter: sqlite
+  :dbfile: vendor/plugins/marshalize/test/marshalize_plugin.sqlite.db
+
+sqlite3:
+  :adapter: sqlite3
+  :dbfile: vendor/plugins/marshalize/test/marshalize_plugin.sqlite3.db
+
+postgresql:
+  :adapter: postgresql
+  :username: jd
+  :password: zpFrKad8
+  :database: test_plugin_marshalize
+  :min_messages: ERROR
+
+#mysql:
+  #:adapter: mysql
+  #:host: localhost
+  #:username: jd
+  #:password: zpFrKad8
+  #:database: marshalize_plugin_test

data/test/marshalize_test.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class ExtendActiveRecordTest < Test::Unit::TestCase
+
+  class Bird < ActiveRecord::Base
+    marshalize :songs
+    marshalize :locations, Array
+    serialize  :friends, Hash
+  end
+
+  def test_marshalize_the_songs_attribute
+
+    load_schema
+    
+
+    test_songs = {'Il fait beau' => 'texte de la chanson...', 'Perche sur une branche' => 'piou piou piou!'}
+
+    piou = Bird.new
+
+
+    piou.name      = "Coco"
+    piou.songs     = test_songs
+    
+    
+    piou.save!
+
+
+    retrieved = Bird.find_by_id piou.id
+
+    
+    assert_equal test_songs, retrieved.songs
+
+    #piou.locations_will_change!
+    piou.name = "Bibi"
+    piou.songs = 23
+    test_locations = ["Milan", "Paris"]
+    piou.locations = test_locations
+    test_friends = {"toucan" => 2, "lark sparrow" => 10}
+    piou.friends = test_friends
+    piou.save!
+
+    retrieved = Bird.find_by_id piou.id
+
+    assert_equal "Bibi", retrieved.name
+
+    assert_kind_of(Array, retrieved.locations, "Locations are stored in an array.")
+    assert_equal test_locations, retrieved.locations
+
+    assert_kind_of(Hash, retrieved.friends, "Friends are stored in a hash.")
+    assert_equal test_friends, retrieved.friends
+
+  end
+end

data/test/schema.rb

@@ -0,0 +1,9 @@
+ActiveRecord::Schema.define(:version => 0) do
+  create_table :birds, :force => true do |t|
+    t.string :name
+    t.text   :locations
+    t.text   :songs
+    t.text   :friends
+    #t.timestamps
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,37 @@
+require 'rubygems'
+require 'active_support'
+require 'active_support/test_case'
+
+ENV['RAILS_ENV'] = 'test'
+ENV['RAILS_ROOT'] ||= File.dirname(__FILE__) + '/../../../..'
+
+require 'test/unit'
+require File.expand_path(File.join(ENV['RAILS_ROOT'], 'config/environment.rb'))
+
+def load_schema
+  config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
+  ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
+  
+  db_adapter = ENV['DB']
+  
+  # no db passed, try one of these fine config-free DBs before bombing.
+  db_adapter ||=
+    begin
+      require 'sqlite'
+      'sqlite'
+    rescue MissingSourceFile
+      begin
+        require 'sqlite3'
+        'sqlite3'
+      rescue MissingSourceFile
+      end
+    end
+  
+  if db_adapter.nil?
+    raise "No DB Adapter selected. Pass the DB= option to pick one, or install Sqlite or Sqlite3."
+  end
+  
+  ActiveRecord::Base.establish_connection(config[db_adapter])
+  load(File.dirname(__FILE__) + "/schema.rb")
+  require File.dirname(__FILE__) + '/../rails/init.rb'
+end

data/uninstall.rb

@@ -0,0 +1 @@
+# Uninstall hook code here

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: chikamichi-marshalize
+version: !ruby/object:Gem::Version 
+  version: 1.0.4
+platform: ruby
+authors: 
+- Jean-Denis Vauguet
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-27 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: "This Rails plugin provides serialization using Marshal in the same way Rails provides builtin serialization using YAML. You can register any kind object (not just arrays and hashes\xE2\x80\xA6). Be aware that Marshal defines a binary format, which may change in incoming Ruby releases and is currently not portable outside the Ruby scripting world. For a portable yet slower alternatives, you may try JSON or YML serializers."
+email: jd@vauguet.fr
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- ChangeLog.rdoc
+- README.rdoc
+files: 
+- .gitignore
+- COPYING
+- ChangeLog.rdoc
+- README.rdoc
+- Rakefile
+- VERSION
+- generators/marshalize/USAGE
+- generators/marshalize/marshalize_generator.rb
+- init.rb
+- install.rb
+- lib/marshalize.rb
+- rails/init.rb
+- test/database.yml
+- test/marshalize_test.rb
+- test/schema.rb
+- test/test_helper.rb
+- uninstall.rb
+has_rdoc: false
+homepage: http://github.com/chikamichi/marshalize
+licenses: 
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Marshalize is a Rails plugin enabling ActiveRecord attributes serialization using the Marshal binary converter library.
+test_files: 
+- test/schema.rb
+- test/marshalize_test.rb
+- test/test_helper.rb