trick_serial 0.2.0

data/lib/trick_serial/serializer/cgi_session.rb

@@ -0,0 +1,239 @@
+require 'trick_serial/serializer'
+
+module TrickSerial
+  class Serializer
+    # Support for ::CGI::Session stores.
+    #
+    # Stores for use with CGI::Session and TrickSerial::Serializer::CgiSession::Store
+    # must implement #_data and #_data= to get access to the underlying Hash structure.
+    #
+    module CgiSession
+      def self.activate!
+        require 'cgi/session'
+        require 'cgi/session/pstore'
+
+        ::CGI::Session.send(:include, SessionSerializer)
+
+        if defined? ::CGI::Session::FileStore
+          ::CGI::Session::FileStore.send(:include, FileStoreSerializer)
+        end
+        if defined? ::CGI::Session::PStore
+          ::CGI::Session::PStore.send(:include, PStoreSerializer)
+        end
+        if defined? ::CGI::Session::MemCacheStore
+          ::CGI::Session::MemCacheStore.send(:include, MemCacheStoreSerializer)
+        end
+        if defined? ::CGI::Session::CassandraStore
+          ::CGI::Session::CassandraStore.send(:include, CassandraStoreSerializer)
+        end
+      end
+      
+      # Defines a Session store Decorator that interjects TrickSerial::Serializer
+      # inside #restore, #update, etc.
+      #
+      # Example:
+      #
+      #   cgi = CGI.new("html4")
+      #   session = CGI::Session.new(
+      #     'database_manager' => TrickSerial::Serializer::CgiSession::Store, # The Decorator.
+      #     'TrickSerial.database_manager' => CGI::Session::PStore, # Actual store Class.
+      #     # Options for PStore instance:
+      #     'tmpdir' => '/tmp/mysessions',
+      #     'session_key' => 'mykey',
+      #     ...
+      #   )
+      #     
+      class Store
+        attr_accessor :logger, :logger_level
+
+        # Options:
+        #
+        #   'TrickSerial.database_manager': the actual session Store class (e.g.: CGI::Session::PStore).
+        #   'TrickSerial.dbman': an actual session store instance.
+        #   'TrickSerial.serializer': a clonable instance of TrickSerial::Serializer.
+        #   'TrickSerial.logger': a Log4r object.
+        #   'TrickSerial.logger_level': a Symbol for the logger level (e.g: :debug)
+        #
+        # The remaining options are passed to the actual Store specified by
+        # :'TrickSerial.database_manager'.
+        def initialize(session, option={})
+          @session = session
+          @option = option
+          @dbman_cls = option.delete('TrickSerial.database_manager') ||
+            (raise "#{self} options did not specify TrickSerial.database_manager: #{option.inspect}")
+          @dbman = option.delete('TrickSerial.dbman')
+          # option['new_session'] = true 
+          @option['database_manager'] = @dbman_cls
+          @serializer = option.delete('TrickSerial.serializer')
+          @logger = option.delete('TrickSerial.logger')
+          @logger_level = option.delete('TrickSerial.logger_level') || :debug
+          _log { "creating #{self} for #{option.inspect}" }
+        end
+
+        def _dbman
+          @dbman ||= 
+            begin
+              # Fool decorated Store.
+              save = @session.new_session
+              @session.new_session = true
+              # debugger
+              @dbman_cls.new(@session, @option)
+            ensure
+              @session.new_session = save
+            end
+        end
+
+        def _make_serializer
+          (@serializer || TrickSerial::Serializer.default).dup
+        end
+
+        def restore
+          _log { "#{self} restore" }
+          _dbman.restore
+          _dbman.decode_with_trick_serial_serializer! if _dbman.respond_to?(:decode_with_trick_serial_serializer!)
+          _dbman._data
+        end
+
+        def update
+          _log { "#{self} update" }
+          serializer = _make_serializer
+          data_save = _dbman._data
+          _dbman._data = serializer.encode(_dbman._data)
+          _dbman.encode_with_trick_serial_serializer! if _dbman.respond_to?(:encode_with_trick_serial_serializer!)
+          # debugger
+          _dbman.update
+        ensure
+          _dbman._data = data_save
+        end
+
+        def close
+          _log { "#{self} close" }
+          serializer = _make_serializer
+          data_save = _dbman._data
+          _dbman._data = serializer.encode(_dbman._data)
+          _dbman.encode_with_trick_serial_serializer! if _dbman.respond_to?(:encode_with_trick_serial_serializer!)
+          _dbman.close
+        ensure
+          _dbman._data = data_save
+        end
+
+        def delete
+          _log { "#{self} close" }
+          _dbman.delete
+        end
+
+        def _log msg = nil
+          msg ||= yield if block_given?
+          if msg && @logger
+            @logger.send(@logger_level, msg)
+          end
+        end
+      end
+
+      # Hacks to get access to Session.new_session.
+      module SessionSerializer
+        attr_writer :session_id, :new_session
+      end
+
+      # Defines common mixin for interjecting TrickSerial::Serializer before
+      # SessionStore#update saves its data. 
+      module SessionStoreDataHook
+        def self.included target
+          super
+          target.extend(ModuleMethods)
+        end
+        
+        module ModuleMethods
+          def included target
+            super
+=begin
+            target.class_eval do 
+              alias :restore_without_trick_serial_serializer :restore
+              alias :restore :restore_with_trick_serial_serializer
+              alias :update_without_trick_serial_serializer :update
+              alias :update :update_with_trick_serial_serializer
+            end
+=end
+          end
+        end
+
+=begin        
+        def restore_with_trick_serial_serializer
+          restore_without_trick_serial_serializer
+          decode_with_trick_serial_serializer!
+          _data
+        end
+=end
+
+        def encode_with_trick_serial_serializer!
+        end
+
+        def decode_with_trick_serial_serializer!
+        end
+
+=begin
+        # Clones TrickSerial::Serializer.default.
+        # Encodes the session store's "data".
+        # Replaces the session store's data with the encoded data.
+        # Call original #update.
+        # Restores old session store's "data".
+        def update_with_trick_serial_serializer
+          serializer = TrickSerial::Serializer.default.dup
+          data_save = self._data
+          self._data = serializer.encode(self._data)
+          encode_with_trick_serial_serializer!
+          update_without_trick_serial_serializer
+        ensure
+          self._data = data_save
+        end
+=end
+      end
+      
+      # FileStore can only handle String => String data.
+      # Use Marshal and Base64 to further encode it.
+      module FileStoreSerializer
+        include SessionStoreDataHook
+        def self.included target
+          super
+          require 'base64'
+        end
+
+        def _data; @hash; end
+        def _data= x; @hash = x; end
+
+        PHONY_KEY = '_'.freeze
+
+        def encode_with_trick_serial_serializer!
+          # $stderr.puts "#{self} encode <= @hash=#{@hash.inspect}"
+          @hash &&= { PHONY_KEY => ::Base64.encode64(Marshal.dump(@hash)).chomp! }
+          # $stderr.puts "#{self} encode => @hash=#{@hash.inspect}"
+        end
+        def decode_with_trick_serial_serializer!
+          # $stderr.puts "#{self} decode <= @hash=#{@hash.inspect}"
+          @hash &&= (v = @hash[PHONY_KEY]) ? Marshal.load(::Base64.decode64(v)) : { }
+          # $stderr.puts "#{self} decode => @hash=#{@hash.inspect}"
+        end
+      end
+
+      module PStoreSerializer
+        include SessionStoreDataHook
+        def _data; @hash; end
+        def _data= x; @hash = x; end
+      end
+      
+      module MemCacheStoreSerializer
+        include SessionStoreDataHook
+        def _data; @session_data; end
+        def _data=x; @session_data = x; end
+      end
+      
+      module CassandraStoreSerializer
+        include SessionStoreDataHook
+        def _data; @session_data; end
+        def _data=x; @session_data = x; end
+      end
+    end
+    
+  end
+end
+

data/lib/trick_serial/serializer/rails.rb

@@ -0,0 +1,88 @@
+require 'trick_serial/serializer'
+
+module TrickSerial
+  class Serializer
+    module Rails
+      def self.activate!
+        rails_version = 
+          (Rails.version rescue nil) ||
+          (RAILS_VERSION rescue nil) || :unknown
+        case rails_version
+        when /^3\./
+          V3
+        when /^1\.2\./
+          V12
+        else
+          raise ArgumentError, "#{self}: Unknown Rails version: #{rails_version.inspect}"
+        end.activate!
+      end
+
+      # Rails 3 support.
+      module V3
+        def self.activate!
+=begin
+          if defined? ::ActiveRecord::Session
+            ::ActiveRecord::Sesson.send(:include, ActiveRecordSessionSerializer)
+          end
+=end
+          if defined? ::ActionDispatch::Session::MemCacheStore
+            ::ActionDispatch::Session::MemCacheStore.send(:include, SessionStoreSerializer)
+          end
+        end
+
+        module SessionStoreSerializer
+          def self.included target
+            super
+            target.class_eval do
+              alias :get_session_without_trick_serial_serializer :get_session
+              alias :get_session :get_session_with_trick_serial_serializer
+              alias :set_session_without_trick_serial_serializer :set_session
+              alias :set_session :get_session_with_trick_serial_serializer
+            end
+          end
+
+          def get_session_with_trick_serial_serializer env, sid
+            result = get_session_without_trick_serial_serializer env, sid
+            result
+          end
+
+          def set_session_with_trick_serial_serializer env, sid, session_data
+            serializer = (env[:'TrickSerial::Serializer.instance'] || TrickSerial::Serializer.default).dup
+            session_data = serializer.encode(session_data) 
+            set_session_without_trick_serial_serializer env, sid, session_data
+            result
+          end
+        end
+
+        module ActiveRecordSessionSerializer
+          def self.included target
+            super
+            target.class_eval do
+              alias :marshal_data_without_trick_serial_serializer! :marshal_data!
+              alias :marshal_data! :marshal_data_with_trick_serial_serializer!
+            end
+          end
+
+          def marshal_data_with_trick_serial_serializer!
+            save_data = @data
+            if loaded?
+              serializer = TrickSerial::Serializer.default.dup
+              @data = serializer.encode(@data)
+            end
+            marshal_data_without_trick_serial_serializer!
+          ensure
+            @data = save_data
+          end
+        end
+      end
+
+      # Rails 1.2 support.
+      module V12
+        def self.activate!
+          require 'trick_serial/serializer/cgi_session'
+          TrickSerial::Serializer::CgiSession.activate!
+        end
+      end
+    end
+  end
+end

data/lib/trick_serial/serializer/simple.rb

@@ -0,0 +1,129 @@
+
+require 'trick_serial/serializer'
+
+module TrickSerial
+class Serializer
+  # Simple, non-swizzling coder.
+  # This requires encode and decode operations.
+  # Array and Hash are not extended to support swizzling.
+  # Ivar swizzling is not used.
+  class Simple < self
+    def _encode! x
+      # pp [ :_encode!, x.class, x ]
+
+      case x
+      when ObjectProxy
+        x
+
+      when Array
+        if o = @visited[x.object_id]
+          return o.first
+        end
+        extended = false
+        o = x
+        x = x.dup if @copy
+        @visited[o.object_id] = [ x, o ]
+        x.map! do | v |
+          _encode! v
+        end
+
+      when Hash
+        if o = @visited[x.object_id]
+          return o.first
+        end
+        extended = false
+        o = x
+        x = x.dup if @copy
+        @visited[o.object_id] = [ x, o ]
+        x.keys.to_a.each do | k |
+          x[k] = _encode!(x[k])
+        end
+
+      when *@proxyable
+        if proxy = @object_to_proxy_map[x.object_id]
+          return proxy.first
+        end
+        # debugger
+        o = x
+        proxy_cls = nil
+        if class_option = self._class_option(x)
+          proxy_cls = class_option[:proxy_class]
+          # Deeply encode instance vars?
+          if ivs = class_option[:instance_vars]
+            ivs = x.instance_variables if ivs == true
+            x = x.dup if @copy
+            @object_to_proxy_map[o.object_id] = [ x, o ]
+            ivs.each do | ivar |
+              v = x.instance_variable_get(ivar)
+              v = _encode!(v)
+              x.instance_variable_set(ivar, v)
+            end
+          end
+        end
+        
+        x = _make_proxy o, x, proxy_cls
+      end
+
+      x
+    end # def
+
+    def _decode! x
+      case x
+      when ObjectProxy
+        x = x.object
+
+      when Array
+        if o = @visited[x.object_id]
+          return o.first
+        end
+        extended = false
+        o = x
+        x = x.dup if @copy
+        @visited[o.object_id] = [ x, o ]
+        x.map! do | v |
+          _decode! v
+        end
+        
+      when Hash
+        if o = @visited[x.object_id]
+          return o.first
+        end
+        extended = false
+        o = x
+        x = x.dup if @copy
+        @visited[o.object_id] = [ x, o ]
+        x.keys.to_a.each do | k |
+          x[k] = _decode!(x[k])
+        end
+        
+      when *@proxyable
+        if proxy = @object_to_proxy_map[x.object_id]
+          return proxy.first
+        end
+        # debugger
+        o = x
+        if class_option = _class_option(x)
+          # Deeply encode instance vars?
+          if ivs = class_option[:instance_vars]
+            ivs = x.instance_variables if ivs == true
+            x = x.dup if @copy
+            @object_to_proxy_map[o.object_id] = [ x, o ]
+            ivs.each do | ivar |
+              v = x.instance_variable_get(ivar)
+              # $stderr.puts "\n#{x.class} #{x.object_id} ivar #{ivar} #{v.inspect}" if @debug
+              v = _decode!(v)
+              x.instance_variable_set(ivar, v)
+            end
+          end
+        end
+        @object_to_proxy_map[o.object_id] ||= [ x, o ]
+      end # case
+      
+      x
+    end # def
+    
+  end # class
+end # class
+end # module
+
+