lib/cutter/inspection.rb in cutter-0.8.1 vs lib/cutter/inspection.rb in cutter-0.8.2

@@ -22,94 +22,99 @@
   # Binding is a Ruby class: http://www.ruby-doc.org/core/classes/Binding.html
   
   def inspect! *options, &block
     return true if Cutter::Inspection.quiet?
 
-    def __colors
-      Cutter::ColoredOutputs.colors_config
-    end
-
-    def to_cs obj
-      color = __colors[obj] || :default
-      color != :default ? to_s.send(color) : to_s
-    end
-
     # Getting binding
     _binding = options.first if options.first.class == Binding
     raise ArgumentError, "Try inspect(binding) or inspect! {}", caller if (!block_given? && !_binding)
     _binding ||= block.binding
     
-    # Want caller methods chain to be traced? - pass option :level to inspect!
     options = options.extract_options! 
     
     max = options[:max]
     options.maximize_options! if max 
-   
+
+    # Want caller methods chain to be traced? - pass option :level to inspect!
     level = options[:level]
     _caller = caller
    
     self_inspection = eval('self.inspect', _binding) if options[:inspect]
 
     # Basic info
     method_name = eval('__method__', _binding)
     class_name = eval('self.class', _binding)
     
-    puts "\n%s `%s' %s" % ['method:'.to_cs(:method), method_name.to_cs(:method_name), ('(maximal tracing)' if max)]
-    puts "  %s %s" % ['called from class:'.to_cs(:called_from), class_name.to_cs(:class_name)]
+    puts "\n%s `%s' %s" % ['method:'.__cs(:method), method_name.__cs(:method_name), ('(maximal tracing)' if max)]
+    puts "  %s %s" % ['called from class:'.__cs(:called_from), class_name.__cs(:class_name)]
 
     # Local Variables
     lvb = eval('local_variables',_binding)
-    puts "  %s %s" % ['local_variables:'.to_cs(:lv), ("[]" if lvb.empty?)]
+    puts "  %s %s" % ['local_variables:'.__cs(:lv), ("[]" if lvb.empty?)]
 
     lvb.map do |lv|
       local_variable = eval(lv.to_s, _binding)
-      local_variable = (max ? local_variable.inspect : local_variable.to_real_string)
+      local_variable = (max ? local_variable.inspect : local_variable.__rs)
 
-      puts "    %s: %s" % [lv.to_cs(:lv_names), local_variable.to_cs(:lv_values)] 
+      puts "    %s: %s" % [lv.__cs(:lv_names), local_variable.__cs(:lv_values)] 
     end if lvb
 
+    # Instance Variables
     ivb = eval('instance_variables',_binding)
     
-    puts "  %s %s" % ["instance_variables:".to_cs(:iv), ("[]" if ivb.empty?)]
+    puts "  %s %s" % ["instance_variables:".__cs(:iv), ("[]" if ivb.empty?)]
     
     ivb.map do |iv|
       instance_variable = eval(iv.to_s, _binding)
-      instance_variable = (max ? instance_variable.inspect : instance_variable.to_real_string)
+      instance_variable = (max ? instance_variable.inspect : instance_variable.__rs)
      
-      puts "    %s: %s" % [iv.to_cs(:iv_names), instance_variable.to_cs(:iv_values)] 
+      puts "    %s: %s" % [iv.__cs(:iv_names), instance_variable.__cs(:iv_values)] 
     end if ivb
 
     # Self inspection 
     begin
-      puts "  self inspection:".to_cs(:self_inspection)
-      puts "    %s" % self_inspection.to_cs(:self_inspection_trace)
+      puts "  self inspection:".__cs(:self_inspection)
+      puts "    %s" % self_inspection.__cs(:self_inspection_trace)
     end if self_inspection
 
     # Caller methods chain
     begin
-    puts "  caller methods: ".to_cs(:caller_methods)
+    puts "  caller methods: ".__cs(:caller_methods)
     0.upto(level).each {|index|
-      puts "    %s" % _caller[index].to_cs(:caller_method)
+      puts "    %s" % _caller[index].__cs(:caller_method)
     }
     end if level
    
     puts "\n"
     # Yield mysterious things if they exist in block.
     yield if block_given? 
   end
 
+  protected
+
   def caller_method_name(level = 1)
     caller[level][/`([^']*)'/,1].to_sym
   end
 
-  protected
-
   def maximize_options!
     self.merge!({:max => true, :inspect => true, :level => 2})
   end
 
-  def to_real_string
+  # ("real string") Now used to print Symbols with colons
+  def __rs
     return ":#{self.to_s}" if self.class == Symbol
     self
   end
+
+  def __cs obj
+    color = __colors[obj] || :default
+    color != :default ? to_s.send(color) : to_s
+  end
+
+  private
+
+  def __colors
+    Cutter::ColoredOutputs.colors_config
+  end
+
 end