debug_helper 1.7.0 → 1.8.0

data/lib/debug_helper.rb

@@ -1,7 +1,31 @@
+require 'ostruct'
 require 'set'
 require 'yaml'
 
-require 'debug_helper/version'
+require_relative 'debug_helper/version'
+
+require_relative 'debug_helper/handler'
+
+  require_relative 'debug_helper/each_with_index_handler'
+    require_relative 'debug_helper/array_handler'
+    require_relative 'debug_helper/set_handler'
+
+  require_relative 'debug_helper/each_pair_handler'
+    require_relative 'debug_helper/hash_handler'
+    require_relative 'debug_helper/struct_handler'
+
+  require_relative 'debug_helper/dir_handler'
+  require_relative 'debug_helper/exception_handler'
+  require_relative 'debug_helper/file_handler'
+  require_relative 'debug_helper/generic_handler'
+  require_relative 'debug_helper/io_handler'
+  require_relative 'debug_helper/match_data_handler'
+  require_relative 'debug_helper/object_handler'
+  require_relative 'debug_helper/open_struct_handler'
+  require_relative 'debug_helper/regexp_handler'
+  require_relative 'debug_helper/string_handler'
+  require_relative 'debug_helper/symbol_handler'
+  require_relative 'debug_helper/range_handler'
 
 class DebugHelper
 
@@ -21,12 +45,10 @@ class DebugHelper
 
   def self.show(obj, message = obj.class, options = {})
     debug_helper = DebugHelper.new(obj, message, options)
-    x = debug_helper.send(:_show, obj, message, info = {})
-    puts x.to_yaml
+    s = debug_helper.show(obj, message, info = {})
+    puts s.to_yaml
   end
 
-  private
-
   def initialize(obj, message, options)
     self.obj = obj
     self.message = message
@@ -34,170 +56,67 @@ class DebugHelper
     self.object_ids = []
   end
 
-  def _show(obj, message, info)
-    if object_ids.include?(obj.object_id)
-      s = show_object(obj, message, info)
-    elsif depth == object_ids.size
-      s = show_object(obj, message, info)
-    else
-      object_ids.push(obj.object_id)
-      s = case
-            when obj.kind_of?(Array)
-              show_array(obj, message, info)
-            when obj.kind_of?(Hash)
-              show_hash(obj, message, info)
-            when obj.kind_of?(Set)
-              show_array(obj, message, info)
-            when obj.kind_of?(Struct)
-              show_struct(obj, message, info)
-            # when obj.kind_of?(Range)
-            else
-              show_object(obj, message, info)
-          end
-      object_ids.pop
-    end
-    s
-  end
-
-  def show_array(obj, message, info)
-    content = {}
-    obj.each_with_index do |item, i|
-      content.store("Element #{i}", _show(item, nil, {}))
-    end
-    attrs = {
-        :message => message,
-        :size => obj.size,
-    }
-    _show_item(obj.class.name, content, attrs, info)
+  def object_seen?(obj)
+    object_ids.include?(obj.object_id)
   end
 
-  def show_hash(obj, message, info)
-    content = {}
-    obj.each_with_index do |pair, i|
-      key, value = *pair
-      pair = {'Key' => _show(key, nil, {}), 'Value' => _show(value, nil, {})}
-      content.store("Pair #{i}", pair)
-    end
-    attrs = {
-        :size => obj.size,
-        :default => obj.default,
-        :default_proc => obj.default_proc,
-        :message => message,
-    }
-    _show_item(obj.class.name, content, attrs, info)
+  def depth_reached?
+    depth == object_ids.size
   end
 
-  def show_object(obj, message, info)
-    methods = methods_for_object(obj)
-    if methods.nil?
-      message_info = message.nil? ? '' : " (message='#{message}')"
-      "#{obj.class.name}#{message_info} #{obj.inspect}"
+  def show(obj, message, info)
+    handler = nil
+    if object_seen?(obj) || depth_reached?
+      handler = GenericHandler.new(self, obj, message, info)
+      s = handler.show
     else
-      content = {}
-      attrs = {:message => message}
-      methods[:instance].each do |instance_method|
-        value = obj.send(instance_method)
-        if instance_method == :size
-          attrs.store(:size, value)
-        else
-          content.store(instance_method.to_s, value)
+      object_ids.push(obj.object_id)
+      begin
+        # If there's a handler for the class, use it.
+        # Note that the class may be a custom class, not defined here,
+        # but instead defined outside this project.
+        # So if the user of this library has defined DebugHelper::FooHandler
+        # and the object is a Foo, that handler will be selected and called.
+        handler_class_name = "DebugHelper::#{obj.class.name}Handler"
+        handler_class = Object.const_get(handler_class_name)
+        handler = handler_class.new(method(__method__), obj, message, info)
+      rescue
+        # If there's not a handler for the class, try using :kind_of?.
+        [
+            Array,
+            Dir,
+            Exception,
+            File,
+            IO,
+            Hash,
+            OpenStruct,
+            Range,
+            Set,
+            String,
+            Struct,
+            # There's no method Symbol.new, so cannot instantiate a subclass.
+            # Symbol,
+        ].each do |klass|
+          if obj.kind_of?(klass)
+            handler_class_name = "DebugHelper::#{klass.name}Handler"
+            handler_class = Object.const_get(handler_class_name)
+            handler = handler_class.new(method(__method__), obj, message, info)
+            break
+          end
         end
       end
-      methods[:class].each do |pair|
-        class_method, arguments = *pair
-        value = Object.const_get(obj.class.to_s).send(class_method, *arguments)
-        content.store(class_method.to_s, value)
+      if handler.nil?
+        if obj.instance_of?(Object)
+          handler_class= ObjectHandler
+        else
+          handler_class = GenericHandler
+        end
+        handler = handler_class.new(self, obj, message, info)
       end
-      _show_item(obj.class.name, content, attrs, info)
-    end
-  end
-
-  def show_struct(obj, message, info)
-    content = {}
-    i = 0
-    obj.each_pair do |member|
-      member_name, value = *member
-      pair = {'Name' => member_name, 'Value' => _show(value, nil, {})}
-      content.store("Member #{i}", pair)
-      i += 1
-    end
-    attrs = {
-        :message => message,
-        :size => obj.size,
-    }
-    _show_item(obj.class.name, content, attrs, info)
-  end
-
-  def _show_item(class_name, content, attrs, info)
-    message = attrs[:message]
-    unless message.nil?
-      attrs[:message] = "'#{message}'"
-    end
-    label = label(class_name, attrs)
-    info.store(label, content)
-    info
-  end
-
-  def label(class_name, attrs)
-    a = []
-    attrs.each_pair do |key, value|
-      a.push("#{key}=#{value}") unless value.nil?
+      s = handler.show
+      object_ids.pop
     end
-    return class_name if a.empty?
-    attrs_s = a.join(' ')
-    "#{class_name} (#{attrs_s})"
-  end
-
-  def methods_for_object(obj)
-    methods = case
-                when obj.kind_of?(File)
-                  {
-                      # The instance forms of some of these require the file to be open.
-                      :class => {
-                          :absolute_path => [obj.path],
-                          :atime => [obj.path],
-                          :ctime => [obj.path],
-                          :executable? => [obj.path],
-                          :exist? => [obj.path],
-                          :ftype => [obj.path],
-                          :mtime => [obj.path],
-                          :path => [obj.path],
-                          :pipe? => [obj.path],
-                          :readable? => [obj.path],
-                          :realpath => [obj.path],
-                          :setgid? => [obj.path],
-                          :setuid? => [obj.path],
-                          :size => [obj.path],
-                          :socket? => [obj.path],
-                          :symlink? => [obj.path],
-                          :writable? => [obj.path],
-                      },
-                      :instance => [],
-                  }
-                when obj.kind_of?(String)
-                  {
-                      :class => {},
-                      :instance => [
-                          :to_s,
-                          :size,
-                          :encoding,
-                          :ascii_only?,
-                          :bytesize,
-                      ]
-                  }
-                when obj.kind_of?(Symbol)
-                  {
-                      :class => {},
-                      :instance => [
-                          :to_s,
-                          :size,
-                          :encoding,
-                      ]
-                  }
-                else
-                  nil
-              end
-    methods
+    s
   end
 
 end

data/lib/debug_helper/array_handler.rb

@@ -0,0 +1,12 @@
+class DebugHelper
+
+  class ArrayHandler < EachWithIndexHandler
+
+    def calls_for_instance
+      [
+          [:size],
+      ]
+    end
+
+  end
+end

data/lib/debug_helper/dir_handler.rb

@@ -0,0 +1,19 @@
+class DebugHelper
+
+  class DirHandler < Handler
+
+    def calls_for_instance
+      [
+          [:path],
+      ]
+    end
+
+    def calls_for_class
+      [
+          [:entries, obj.path],
+          [:exist?, obj.path],
+      ]
+    end
+
+  end
+end

data/lib/debug_helper/each_pair_handler.rb

@@ -0,0 +1,13 @@
+class DebugHelper
+
+  class EachPairHandler < Handler
+
+    attr_accessor :pair_names
+
+    def each_pair?
+      true
+    end
+
+  end
+
+end

data/lib/debug_helper/each_with_index_handler.rb

@@ -0,0 +1,11 @@
+class DebugHelper
+
+  class EachWithIndexHandler < Handler
+
+    def each_with_index?
+      true
+    end
+
+  end
+
+end

data/lib/debug_helper/exception_handler.rb

@@ -0,0 +1,14 @@
+class DebugHelper
+
+  class ExceptionHandler < Handler
+
+    def calls_for_instance
+      [
+          [:message],
+          [:cause],
+          [:backtrace],
+      ]
+    end
+  end
+
+end

data/lib/debug_helper/file_handler.rb

@@ -0,0 +1,29 @@
+class DebugHelper
+
+  class FileHandler < Handler
+
+    def calls_for_class
+      path = obj.path
+      [
+          [:absolute_path, path],
+          [:atime, path],
+          [:ctime, path],
+          [:executable?, path],
+          [:exist?, path],
+          [:ftype, path],
+          [:mtime, path],
+          [:path, path],
+          [:pipe?, path],
+          [:readable?, path],
+          [:realpath, path],
+          [:setgid?, path],
+          [:setuid?, path],
+          [:size, path],
+          [:socket?, path],
+          [:symlink?, path],
+          [:writable?, path],
+      ]
+    end
+  end
+
+end

data/lib/debug_helper/generic_handler.rb

@@ -0,0 +1,12 @@
+class DebugHelper
+
+  class GenericHandler < Handler
+
+    def show
+      message_info = message.nil? ? '' : " (message='#{message}')"
+      "#{obj.class.name}#{message_info} #{obj.inspect}"
+    end
+
+  end
+
+end

data/lib/debug_helper/handler.rb

@@ -0,0 +1,102 @@
+class DebugHelper
+
+  class Handler
+
+    attr_accessor :show_method, :obj, :message, :info, :attrs, :content
+
+    def initialize(show_method, obj, message, info)
+      self.show_method = show_method
+      self.obj = obj
+      self.message = message
+      self.info = info
+      self.attrs = {}
+      self.content = {}
+      show
+    end
+
+    def show
+      gather
+      finish
+    end
+
+    def gather
+      calls_for_instance.each do |call_info|
+        method = call_info.shift
+        unless obj.respond_to?(method)
+          message = "Instance of #{obj.class} does not respond to method #{method}"
+          raise NoMethodError.new(message, method)
+        end
+        args = call_info
+        if args.empty?
+          value = obj.send(method)
+        else
+          value = obj.send(method, *args)
+        end
+        content.store(method.to_s, value)
+      end
+      calls_for_class.each do |call_info|
+        klass = Object.const_get(obj.class.name)
+        method = call_info.shift
+        unless klass.respond_to?(method)
+          message = "#{obj.class} does not respond to method #{method}"
+          raise NoMethodError.new(message, method)
+        end
+        args = call_info
+        if args.empty?
+          value = klass.send(method)
+        else
+          value = klass.send(method, *args)
+        end
+        content.store(method.to_s, value)
+      end
+      if each_with_index?
+        obj.each_with_index do |item, i|
+          self.content.store("Element #{i}", show_method.call(item, nil, {}))
+        end
+      end
+      if each_pair?
+        pair_name, key_name, value_name = *pair_names
+        i = 0
+        obj.each_pair do |key, value|
+          pair = {key_name => show_method.call(key, nil, {}), value_name => show_method.call(value, nil, {})}
+          self.content.store("#{pair_name} #{i}", pair)
+          i += 1
+        end
+      end
+    end
+
+    def finish
+      attrs[:message] = "'#{message}'" unless message.nil?
+      self.info.store(label, content)
+      info
+    end
+
+    def label
+      a = []
+      attrs.each_pair do |key, value|
+        a.push("#{key}=#{value}") unless value.nil?
+      end
+      return self.obj.class.name if a.empty?
+      attrs_s = a.join(' ')
+      "#{self.obj.class.name} (#{attrs_s})"
+    end
+
+    def calls_for_instance
+      []
+    end
+
+    def calls_for_class
+      []
+    end
+
+    def each_with_index?
+      false
+    end
+
+    def each_pair?
+      false
+    end
+
+  end
+
+end