binding_dumper 0.1.0

data/lib/binding_dumper/core_ext/magic_context_patch_builder.rb

@@ -0,0 +1,55 @@
+# Class for buliding patch that adds method '_local_binding'
+#  to existing object
+#
+# @example
+#   data = {
+#     file: '/path/to/file.rb',
+#     line: 17,
+#     method: 'do_something',
+#     lvars: { a: 'b' }
+#   }
+#   patch = BindingDumper::CoreExt::MagicContextPatchBuilder.new(data).patch
+#   context = Object.new.extend(patch)
+#
+#   context._local_binding
+#   # => #<Binding>
+#   context._local_binding.eval('a')
+#   # => 'b'
+#   context._local_binding.eval('__FILE__')
+#   # => '/path/to/file.rb'
+#   context._local_binding.eval('__LINE__')
+#   # => 17
+#   context._local_binding.eval('__method__')
+#   # => 'do_something'
+#
+module BindingDumper
+  module CoreExt
+    class MagicContextPatchBuilder
+      attr_reader :undumped
+
+      def initialize(undumped)
+        @undumped = undumped
+      end
+
+      # Returns module that is ready for patching existing context
+      #
+      # @return [Module]
+      #
+      def patch
+        undumped = self.undumped
+        Module.new do
+          define_method :_local_binding do
+            result = binding
+
+            undumped[:lvars].each do |lvar_name, lvar|
+              result.eval("#{lvar_name} = ObjectSpace._id2ref(#{lvar.object_id})")
+            end
+
+            mod = LocalBindingPatchBuilder.new(undumped).patch
+            result.extend(mod)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/binding_dumper/dumpers/abstract.rb

@@ -0,0 +1,73 @@
+# Class with common functionality of all dumpers
+#
+class BindingDumper::Dumpers::Abstract
+  attr_reader :dumped_ids
+
+  # @param abstract_object [Object] any object
+  # @param dumped_ids [Array<Fixnum>] list of object ids that are already dumped
+  #
+  def initialize(abstract_object, dumped_ids = [])
+    @abstract_object = abstract_object
+    @dumped_ids = dumped_ids
+  end
+
+  private
+
+  # Returns abstract object
+  #  Sometimes it's a Hash that represents object structure
+  #  Sometimes it's just that object (if its' primitive)
+  #
+  # @return [Object]
+  #
+  def abstract_object
+    if @abstract_object.is_a?(Hash) && @abstract_object.has_key?(:_object_data)
+      @abstract_object[:_object_data]
+    else
+      @abstract_object
+    end
+  end
+
+  # Returns +true+ if +abstract_object+ should be converted
+  #
+  # @return [true, false]
+  #
+  def should_convert?
+    !dumped_ids.include?(abstract_object.object_id)
+  end
+
+  # Returns true if +abstract_object+ can be dumped using Marshal.dump
+  #
+  # @return [true, false]
+  #
+  def can_be_fully_dumped?(object)
+    begin
+      Marshal.dump(object)
+      true
+    rescue TypeError, IOError
+      false
+    end
+  end
+
+  # Returns +true+ if undumpable object (like StringIO.new)
+  #  can't be dumped itself, but it's blank copy can be dumped
+  #
+  # @return [true, false]
+  #
+  def can_be_dumped_as_copy?(object)
+    begin
+      copy = object.class.allocate
+      Marshal.dump(copy)
+      true
+    rescue TypeError, IOError
+      false
+    end
+  end
+
+  # Returns +true+ if object can't be marshaled
+  #
+  # @return [true, false]
+  #
+  def undumpable?(object)
+    !can_be_fully_dumped?(object) && !can_be_dumped_as_copy?(object)
+  end
+end

data/lib/binding_dumper/dumpers/array_dumper.rb

@@ -0,0 +1,64 @@
+module BindingDumper
+  # Class responsible for converting arrays to marshalable Hash
+  #
+  # @example
+  #   array = [1,2,3]
+  #   dump = BindingDumper::Dumpers::Array.new(array).convert
+  #   # => { marshalable: :hash }
+  #   BindingDumper::Dumpers::Array.new(dump).deconvert
+  #   # => [1,2,3]
+  #
+  class Dumpers::ArrayDumper < Dumpers::Abstract
+    alias_method :array, :abstract_object
+
+    # Returns true if ArrayDumper can convert +abstract_object+
+    #
+    # @return [true, false]
+    #
+    def can_convert?
+      array.is_a?(Array)
+    end
+
+    # Returns true if ArrayDumper can deconvert +abstract_object+
+    #
+    # @return [true, false]
+    #
+    def can_deconvert?
+      array.is_a?(Array)
+    end
+
+    # Converts +abstract_object+ to marshalable Hash
+    #
+    # @return [Hash]
+    #
+    def convert
+      unless should_convert?
+        return { _existing_object_id: array.object_id }
+      end
+
+      dumped_ids << array.object_id
+
+      result = array.map do |item|
+        UniversalDumper.convert(item, dumped_ids)
+      end
+
+      {
+        _old_object_id: array.object_id,
+        _object_data: result
+      }
+    end
+
+    # Deconverts passed +abstract_object+ back to the original state
+    #
+    # @return [Array]
+    #
+    def deconvert
+      result = []
+      yield result
+      array.each do |converted_item|
+        result << UniversalDumper.deconvert(converted_item)
+      end
+      result
+    end
+  end
+end

data/lib/binding_dumper/dumpers/class_dumper.rb

@@ -0,0 +1,111 @@
+module BindingDumper
+  # Class responsible for converting classes to marshalable Hash
+  #
+  # @example
+  #   class MyClass
+  #     @a = 1
+  #     @@b = 2
+  #   end
+  #   dump = BindingDumper::Dumpers::ClassDumper.new(MyClass).convert
+  #   # => { marshalable: :hash }
+  #   BindingDumper::Dumpers::ClassDumper.new(MyClass).deconvert
+  #   # => MyClass
+  #
+  class Dumpers::ClassDumper < Dumpers::Abstract
+    alias_method :klass, :abstract_object
+
+    # Returns +true+ if ClassDumper can convert passed +abstract_object+
+    #
+    # @return [true, false]
+    #
+    def can_convert?
+      klass.is_a?(Class)
+    end
+
+    # Returns +true+ if ClassDumper can deconvert passed +abstract_object+
+    #
+    # @return [true, false]
+    #
+    def can_deconvert?
+      abstract_object.is_a?(Hash) &&
+        (abstract_object.has_key?(:_cvars) || abstract_object.has_key?(:_anonymous))
+    end
+
+    # Converts passed +abstract_object+ to marshalable Hash
+    #
+    # @return [Hash]
+    #
+    def convert
+      return unless should_convert?
+      dumped_ids << klass.object_id
+
+      if klass.name
+        {
+          _klass: klass,
+          _ivars: converted_ivars(dumped_ids),
+          _cvars: converted_cvars(dumped_ids)
+        }
+      else
+        {
+          _anonymous: true
+        }
+      end
+
+    end
+
+    # Deconverts passed +abstract_object+ back to the original state
+    #
+    # @return [Class]
+    #
+    def deconvert
+      return Class.new if abstract_object[:_anonymous]
+      klass, converted_ivars, converted_cvars = abstract_object[:_klass], abstract_object[:_ivars], abstract_object[:_cvars]
+
+      converted_ivars.each do |ivar_name, converted_ivar|
+        ivar = UniversalDumper.deconvert(converted_ivar)
+        klass.instance_variable_set(ivar_name, ivar)
+      end
+
+      converted_cvars.each do |cvar_name, converted_cvar|
+        cvar = UniversalDumper.deconvert(converted_cvar)
+        klass.class_variable_set(cvar_name, cvar)
+      end
+
+      klass
+    end
+
+    private
+
+    # Returns converted mapping of instance variables like
+    #  { instance variable name => instance variable value }
+    #
+    # @return [Hash]
+    #
+    def converted_ivars(dumped_ids = [])
+      converted = klass.instance_variables.map do |ivar_name|
+        ivar = klass.instance_variable_get(ivar_name)
+        conveted_ivar = UniversalDumper.convert(ivar, dumped_ids)
+        [ivar_name, conveted_ivar]
+      end
+      Hash[converted]
+    end
+
+    # Returns converted mapping of class variables like
+    #  { class variable name => class variable vakue }
+    #
+    # @return [Hash]
+    #
+    def converted_cvars(dumped_ids = [])
+      converted = klass.class_variables.map do |cvar_name|
+        ivar = klass.class_variable_get(cvar_name)
+        if dumped_ids.include?(ivar.object_id)
+          []
+        else
+          conveted_ivar = UniversalDumper.convert(ivar, dumped_ids)
+          [cvar_name, conveted_ivar]
+        end
+      end
+      Hash[converted]
+    end
+  end
+end

data/lib/binding_dumper/dumpers/existing_object_dumper.rb

@@ -0,0 +1,89 @@
+module BindingDumper
+  # Class responsible for restoring recurring objects
+  #
+  # If you dump an object twice you will get:
+  #  First time:  { marshalable: :hash }
+  #  Second time: { _existing_object_id: 1234 }
+  #
+  # This _existing_object_id is actually an object_id of dumped object
+  #  in original memory
+  #
+  # So, after deconverting the hash { _existing_object_id: ojbect_id }
+  #  You will get an object from your current memory
+  #
+  # @example
+  #   class Profile
+  #     attr_accessor :first_name, :last_name
+  #   end
+
+  #   profile = Profile.allocate
+  #   profile.first_name = profile     # <-- so the object is recursive
+  #   profile.last_name = StringIO.new # <-- and unmarshalable
+  #   dump = BindingDumper::UniversalDumper.convert(profile)
+  #   =>
+  #   {
+  #     :_klass => Profile,
+  #     :_ivars => {
+  #       :@first_name => {
+  #         :_existing_object_id => 47687640 # <-- right here
+  #       },
+  #       :@last_name => {
+  #         :_klass => StringIO,
+  #         :_undumpable => true
+  #       }
+  #     },
+  #     :_old_object_id => 47687640
+  #   }
+  #
+  #   restored = BindingDumper::UniversalDumper.deconvert(profile)
+  #   restored.profile.equal?(restored)
+  #   # => true # (they have the same object id)
+  #
+  class Dumpers::ExistingObjectDumper < Dumpers::Abstract
+    alias_method :hash, :abstract_object
+
+    # Returns false, this class is only for deconverting
+    #
+    def can_convert?
+      false # really, it's only for deconverting
+    end
+
+    # Returns true if ExistingObjectDumper can deconvert passed +abstract_object+
+    #
+    # @return [true, false]
+    #
+    def can_deconvert?
+      hash.is_a?(Hash) && hash.has_key?(:_existing_object_id)
+    end
+
+    # Raises an exception, don't use this class for converting
+    #
+    # @raise [NotImplementedError]
+    #
+    def convert
+      raise NotImplementedError
+    end
+
+    # Deconverts passed +abstract_object+ back to the original state
+    #
+    # @return [Object]
+    #
+    # @raise [RuntimeError] when object doesn't exist in the memory
+    #
+    def deconvert
+      data_without_object_id = hash.dup.delete(:_existing_object_id)
+
+      unless UniversalDumper.memories.has_key?(existing_object_id)
+        raise "Object with id #{existing_object_id} wasn't dumped. Something is wrong."
+      end
+
+      UniversalDumper.memories[existing_object_id]
+    end
+
+    private
+
+    def existing_object_id
+      hash[:_existing_object_id]
+    end
+  end
+end

data/lib/binding_dumper/dumpers/hash_dumper.rb

@@ -0,0 +1,69 @@
+module BindingDumper
+  # Class responsible for converting arbitary hashes to marshalable hashes
+  #
+  # @example
+  #   hash = { key: 'value' }
+  #   dump = BindingDumper::Dumpers::HashDumper.new(hash).convert
+  #   BindingDumper::Dumpers::HashDumper.new(dump).deconvert
+  #   # => { key: 'value' }
+  #
+  class Dumpers::HashDumper < Dumpers::Abstract
+    alias_method :hash, :abstract_object
+
+    # Returns true if HashDumper can convert passed +abstract_object+
+    #
+    # @return [true, false]
+    #
+    def can_convert?
+      hash.is_a?(Hash)
+    end
+
+    # Returns true if HashDumper can deconvert passed +abstract_object+
+    #
+    # @return [true, false]
+    #
+    def can_deconvert?
+      abstract_object.is_a?(Hash)
+    end
+
+    # Converts passed +abstract_object+ to marshalable Hash
+    #
+    # @return [Hash]
+    #
+    def convert
+      unless should_convert?
+        return { _existing_object_id: hash.object_id }
+      end
+
+      dumped_ids << hash.object_id
+
+      prepared = hash.map do |k, v|
+        converted_k = UniversalDumper.convert(k, dumped_ids)
+        converted_v = UniversalDumper.convert(v, dumped_ids)
+        [converted_k, converted_v]
+      end
+
+      result = Hash[prepared]
+
+      {
+        _old_object_id: hash.object_id,
+        _object_data: result
+      }
+    end
+
+    # Deconverts passed +abstract_object+ back to the original state
+    #
+    # @return [Hash]
+    #
+    def deconvert
+      result = {}
+      yield result
+      hash.each do |converted_k, converted_v|
+        k = UniversalDumper.deconvert(converted_k)
+        v = UniversalDumper.deconvert(converted_v)
+        result[k] = v
+      end
+      result
+    end
+  end
+end