rshade 0.1.9 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e5ef0c31c59c3ed46f44326e1e28f6a5b2b2ccbdbce32152e6b54233f875d6d0
-  data.tar.gz: f394a28db1cda3274954309996eaea895bf715737f34aecbb09c0d0873fd09fb
+  metadata.gz: 39758f070ab0a6b6e7dc0bdc09aa03bb107130f84fe7115331189a31c0e013eb
+  data.tar.gz: 0331bdd526cd0155df7d210603bb07a15c9541bcce62197b2754731e640060c3
 SHA512:
-  metadata.gz: 956a68bec41feea89513eab5e0002fadb70d9d0f9e57f1c47f316d2c30c6e801cb510a80312e54b9d075c4fa7f768ad6b2acc881dc3db03680a9351abe56dda4
-  data.tar.gz: 4bafb27714ffaf13734f99522897b3057da42f5bf4eb05929b824af9c67f19076f304373ab835f1cf0b0bb3ef5a253a1fd23ec343236596255b64f34290702b3
+  metadata.gz: b0c97b53d02f997d05484e850655dfe561c82da1d110a111022885278ece826b5fc75b2e5d70260ff59095ca29178e681c85915301a6b171efe263aa42c82f64
+  data.tar.gz: ed9a95bceb71f94cd17587bd88086a6e26d77b5a19fe14ed96b4cfbd559fa1574ffaca380ec3fc49167e788197008bc08b581f83fb5997fb058dedba77e49bf8

data/.gitignore

@@ -5,6 +5,7 @@
 /doc/
 /pkg/
 /spec/reports/
+/spec/store/
 /tmp/
 .idea
 
@@ -12,4 +13,4 @@
 .rspec_status
 .ruby-version
 .DS_Store
-test.rb
+test.rb

data/Gemfile

@@ -1,10 +1,14 @@
-source "https://rubygems.org"
+# frozen_string_literal: true
 
-git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
 
 # Specify your gem's dependencies in rshade.gemspec
 gemspec
 
 group :development, :test do
+  gem 'binding_of_caller'
+  gem 'prism'
   gem 'pry'
 end

data/Gemfile.lock

@@ -1,16 +1,22 @@
 PATH
   remote: .
   specs:
-    rshade (0.1.9)
+    rshade (0.2.0)
+      binding_of_caller
       colorize
+      prism
 
 GEM
   remote: https://rubygems.org/
   specs:
+    binding_of_caller (1.0.1)
+      debug_inspector (>= 1.2.0)
     coderay (1.1.3)
     colorize (0.8.1)
+    debug_inspector (1.2.0)
     diff-lcs (1.5.0)
     method_source (1.0.0)
+    prism (1.3.0)
     pry (0.14.1)
       coderay (~> 1.1)
       method_source (~> 1.0)
@@ -32,9 +38,12 @@ GEM
 PLATFORMS
   x86_64-darwin-19
   x86_64-darwin-20
+  x86_64-darwin-22
 
 DEPENDENCIES
+  binding_of_caller
   bundler (~> 2.2.33)
+  prism
   pry
   rake (>= 12.3.3)
   rshade!

data/README.md

@@ -1,6 +1,7 @@
 # RShade  
- 
-![warcraft shade](https://github.com/gingray/rshade/raw/master/shade.jpg)
+<p align="center">
+  <img src="https://github.com/gingray/rshade/raw/master/shade.jpg">
+</p>
 
 RShade is a debugging/code exploration tool based on `TracePoint` functionality. 
 Recent years I've working with relatively huge legacy code and I need a tool which can help me to figure out what is going on due execution. 
@@ -85,7 +86,7 @@ On such huge codebase as spree it's helpful to know what callbacks are triggered
     context 'when cost currency is nil' do
       before { variant.cost_currency = nil }
 
-      it 'populates cost currency with the default value on save', focus: true do
+      it 'populates cost currency with the default value on save' do
          RShade::Trace.reveal do
           variant.save!
         end
@@ -99,6 +100,21 @@ Below is example how output will look like.
 As you can see all code that have been in use is printed.
 [![asciicast](https://asciinema.org/a/MR5KL7TmHmYRUhwBUWQjBI373.svg)](https://asciinema.org/a/MR5KL7TmHmYRUhwBUWQjBI373)
 
+## Stack reveal
+Config
+```ruby
+::RShade::Config::Registry.instance.stack_config do |config|
+  config.exclude_gems!
+  filepath = File.join(Rails.root, 'log', 'rshade-stack.json.log')
+  config.set_formatter(:json, { filepath: filepath, pretty: false })
+end
+```
+
+Execute (put in any place where you want reveal stack)
+```ruby
+::RShade::Stack.trace
+```
+
 ## TODO  
 Use stack to keep connections between current method and caller  
 take a look on https://github.com/matugm/visual-call-graph  

data/Rakefile

@@ -1,6 +1,8 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+task default: :spec

data/bin/console

@@ -1,7 +1,8 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-require "bundler/setup"
-require "rshade"
+require 'bundler/setup'
+require 'rshade'
 
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.
@@ -10,5 +11,5 @@ require "rshade"
 # require "pry"
 # Pry.start
 
-require "irb"
+require 'irb'
 IRB.start(__FILE__)

data/lib/rshade/config/registry.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RShade
+  class Config
+    class Registry
+      attr_reader :map, :mutex
+
+      include Singleton
+
+      def initialize
+        @map = {}
+        @mutex = Mutex.new
+        defaults
+      end
+
+      def set_default_stack(config)
+        mutex.synchronize do
+          map[:store_default] = config
+        end
+      end
+
+      def default_stack_config
+        val = nil
+        mutex.synchronize do
+          val = map[:store_default]
+        end
+        val
+      end
+
+      def stack_config(&block)
+        val = nil
+        mutex.synchronize do
+          val = ::RShade::Config::StackStore.new
+          block.call(val)
+          map[:store_default] = val
+        end
+        val
+      end
+
+      def defaults
+        mutex.synchronize do
+          map[:store_default] = ::RShade::Config::StackStore.new
+        end
+      end
+    end
+  end
+end

data/lib/rshade/config/stack_store.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RShade
+  class Config
+    class StackStore
+      attr_reader :filter, :formatter, :custom_serializers
+
+      DEFAULT_FORMATTER = {
+        json: ::RShade::Formatter::Stack::Json
+      }.freeze
+
+      # @param [Hash] options
+      # @option options [::RShade::Filter::FilterComposition] :filter_composition
+      # @option options [#call(event_store)] :formatter
+      def initialize(options = {})
+        @filter = options.fetch(:filter, default_filter_composition)
+        @formatter = options.fetch(:formatter, ::RShade::Formatter::Stack::Stdout.new)
+        @custom_serializers = options.fetch(:custom_serializers, {})
+      end
+
+      def add_custom_serializers(hash)
+        custom_serializers.merge!(hash)
+        self
+      end
+
+      def config_filter(filter_type, &block)
+        filter.config_filter(filter_type, &block)
+        self
+      end
+
+      def set_formatter(formatter, opts = {})
+        @formatter = formatter.is_a?(Symbol) ? set_symbol_formatter(formatter, opts) : formatter
+        self
+      end
+
+      def exclude_gems!
+        config_filter(::RShade::Filter::ExcludePathFilter) do |paths|
+          paths.concat(RShade::Config.default_excluded_path)
+        end
+        self
+      end
+
+      private
+
+      def set_symbol_formatter(type, opts)
+        formatter_class = DEFAULT_FORMATTER[type]
+        return formatter_class unless formatter_class
+
+        @formatter = formatter_class.new(**opts)
+      end
+
+      def default_filter_composition
+        RShade::Filter::FilterBuilder.build([:or,
+                                             [:or, RShade::Filter::VariableFilter.new, RShade::Filter::IncludePathFilter.new], RShade::Filter::ExcludePathFilter.new])
+      end
+    end
+  end
+end

data/lib/rshade/config/store.rb

@@ -1,21 +1,29 @@
+# frozen_string_literal: true
 
 module RShade
   class Config
     class Store
-      attr_reader :filter_composition, :formatter, :tp_events
+      attr_reader :filter_composition, :formatter, :tp_events, :custom_serializers
 
       # @param [Hash] options
       # @option options [RShade::Filter::FilterComposition] :filter_composition
       # @option options [#call(event_store)] :formatter
       # @option options [Array<Symbol>] :tp_events
-      def initialize(options={})
+      def initialize(options = {})
         @filter_composition = options.fetch(:filter_composition, default_filter_composition)
-        @formatter = options.fetch(:formatter, ::RShade::Formatter::Stdout)
-        @tp_events = options.fetch(:tp_events, [:call, :return])
+        @formatter = options.fetch(:formatter, ::RShade::Formatter::Trace::Stdout)
+        @tp_events = options.fetch(:tp_events, %i[call return])
+        @custom_serializers = options.fetch(:custom_serializers, {})
       end
 
       def set_tp_events(tp_events)
         @tp_events = tp_events
+        self
+      end
+
+      def add_custom_serializers(hash)
+        custom_serializers.merge!(hash)
+        self
       end
 
       def config_filter(filter_type, &block)
@@ -31,7 +39,8 @@ module RShade
       private
 
       def default_filter_composition
-        RShade::Filter::FilterBuilder.build([:or,[:or, RShade::Filter::VariableFilter.new, RShade::Filter::IncludePathFilter.new] , RShade::Filter::ExcludePathFilter.new])
+        RShade::Filter::FilterBuilder.build([:or,
+                                             [:or, RShade::Filter::VariableFilter.new, RShade::Filter::IncludePathFilter.new], RShade::Filter::ExcludePathFilter.new])
       end
     end
   end

data/lib/rshade/config.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module RShade
   class Config
     RUBY_VERSION_PATTERN = /ruby-[0-9.]*/
 
     def self.default
-      ::RShade::Config::Store.new.set_formatter(::RShade::Formatter::Stdout.new)
+      ::RShade::Config::Store.new.set_formatter(::RShade::Formatter::Trace::Stdout.new)
                              .config_filter(::RShade::Filter::ExcludePathFilter) do |paths|
         default_excluded_path.each do |path|
           paths << path
@@ -20,7 +22,7 @@ module RShade
     # @option options [RShade::Filter::FilterComposition] :filter_composition
     # @option options [#call(event_store)] :formatter
     # @option options [Array<Symbol>] :tp_events
-    def self.create(options={})
+    def self.create(options = {})
       new(Config::Store.new(options))
     end
 
@@ -51,6 +53,11 @@ module RShade
       self
     end
 
+    def add_custom_serializers(hash)
+      @config_store.add_custom_serializers(hash)
+      self
+    end
+
     def value
       @config_store
     end
@@ -63,7 +70,6 @@ module RShade
       @root_dir ||= File.expand_path('../../', __dir__)
     end
 
-    private
     def self.default_excluded_path
       [ENV['GEM_PATH'].split(':'), RUBY_VERSION_PATTERN, /internal/].flatten.compact
     end

data/lib/rshade/core_extensions/object/reveal.rb

@@ -1,8 +1,37 @@
+# frozen_string_literal: true
+
 class Object
-  def reveal(&block)
-    trace = ::RShade::Trace.reveal do
-      block.call
+  def reveal(method_name = nil, **opts, &block)
+    if method_name
+      @__cache_rshade_reveal ||= {}
+      config = opts.fetch(:config, ::RShade::Config.default)
+      @__cache_rshade_reveal[method_name] = config
+      instance_eval do
+        def method_added(name)
+          return unless @__cache_rshade_reveal[name]
+
+          if @__reveal_rewrite
+            @__reveal_rewrite = false
+            return
+          end
+          @__reveal_rewrite = true
+          config = @__cache_rshade_reveal[name]
+          origin_method = instance_method(name)
+          define_method(name) do |*args, &fn|
+            val = nil
+            trace = ::RShade::Trace.reveal(config) do
+              val = origin_method.bind(self).call(*args, &fn)
+            end
+            trace.show
+            val
+          end
+        end
+      end
+    else
+      trace = ::RShade::Trace.reveal do
+        block.call if block_given?
+      end
+      trace.show
     end
-    trace.show
   end
-end
+end

data/lib/rshade/event.rb

@@ -1,15 +1,17 @@
+# frozen_string_literal: true
+
 module RShade
   # nodoc
   class Event
     attr_reader :hash, :skipped
-    RETURN_EVENTS = [:return, :b_return, :c_return]
 
+    RETURN_EVENTS = %i[return b_return c_return].freeze
 
     def initialize(hash)
       @hash = hash
     end
 
-    [:klass, :path, :lineno, :method_name, :vars, :level, :return_value].each do |method_name|
+    %i[klass path lineno method_name vars level return_value].each do |method_name|
       define_method method_name do
         fetch method_name
       end
@@ -38,17 +40,21 @@ module RShade
     def self.from_trace_point(evt)
       vars = {}
       evt.binding.local_variables.each do |var_name|
-        vars[var_name] = evt.binding.local_variable_get var_name
+        local_val = evt.binding.local_variable_get(var_name)
+        local_val_type = local_val.is_a?(Class) ? local_val : local_val.class
+        hash = { name: var_name, value: local_val, type: local_val_type }
+        vars[var_name] = hash
       end
 
-      hash = { path: evt.path, lineno: evt.lineno, klass: evt.defined_class, method_name: evt.method_id, vars: vars,
+      hash = { path: evt.path, lineno: evt.lineno, klass: evt.defined_class, method_name: evt.method_id, vars:,
                event_type: evt.event }
-      hash.merge!({return_value: evt.return_value}) if RETURN_EVENTS.include?(evt.event)
-      new(hash)
-    end
 
-    def self.create_blank(level)
-      new({level: level}, true)
+      if RETURN_EVENTS.include?(evt.event)
+        ret_val = evt.return_value
+        ret_val_type  = evt.return_value.is_a?(Class) ? evt.return_value : evt.return_value.class
+        hash.merge!({ return_value: { value: ret_val, type: ret_val_type } })
+      end
+      new(hash)
     end
 
     private

data/lib/rshade/event_observer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RShade
   class EventObserver
     attr_reader :event_processor, :config
@@ -42,4 +44,4 @@ module RShade
       config.filter_composition.call(event)
     end
   end
-end
+end

data/lib/rshade/event_processor.rb

@@ -1,35 +1,37 @@
+# frozen_string_literal: true
+
 module RShade
   # nodoc
   class EventProcessor
-    attr_reader :store
+    attr_reader :store, :serializer
 
-    def initialize(store)
+    def initialize(store, config)
       @store = store
-      @var_serializer = BindingSerializer.new
+      custom_serializers = config.custom_serializers
+      @serializer = ::RShade::Serializer::Traversal.new(custom_serializers)
     end
 
     # @param [RShade::Event] event
     # @param [Integer] level
     def enter(event, level)
-      event.with_serialized_vars!(@var_serializer).with_level!(level)
+      event.with_serialized_vars!(serializer).with_level!(level)
       store.add(event, level)
     end
 
     # @param [RShade::Event] event
     # @param [Integer] level
-    def leave(event, level)
+    def leave(event, _level)
       store.current! do |node|
-          node.value.set_return_value!(event.return_value)
-              .with_serialized_return!(->(value) { value.inspect })
+        node.value.set_return_value!(event.return_value)
+            .with_serialized_return!(serializer)
       end
-    rescue => e
+    rescue StandardError
       # this rescue here due this issue which reproduce in ruby-2.6.6 at least
       # https://bugs.ruby-lang.org/issues/18060
     end
+
     # @param [RShade::Event] event
     # @param [Integer] level
-    def other(event, level)
-
-    end
+    def other(event, level); end
   end
-end
+end

data/lib/rshade/event_tree.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RShade
   class EventTree
     include Enumerable
@@ -16,21 +18,17 @@ module RShade
       if current.level + 1 < level
 
         last = current.children.last
-        unless last
-          current.children << EventTreeNode.new(nil, current.level + 1 , current)
-        end
+        current.children << EventTreeNode.new(nil, current.level + 1, current) unless last
         @current = current.children.last
         add(value, level)
         return
       end
 
-      if current.level + 1 > level
-        unless current.parent
-          return
-        end
-        @current = current.parent
-        add(value, level)
-      end
+      return unless current.level + 1 > level
+      return unless current.parent
+
+      @current = current.parent
+      add(value, level)
     end
 
     def current!(&block)
@@ -47,7 +45,7 @@ module RShade
     attr_reader :children, :level, :vlevel, :value
     attr_accessor :parent
 
-    def initialize(value, level, parent=nil)
+    def initialize(value, level, parent = nil)
       @children = []
       @level = level
       @parent = parent
@@ -56,20 +54,20 @@ module RShade
     end
 
     def each(&block)
-      block.call(self) if parent != nil || value != nil
+      block.call(self) if !parent.nil? || !value.nil?
       children.each { |item| item.each(&block) }
     end
 
     private
 
     def set_vlevel(node)
-      return 0 if node == nil
+      return 0 if node.nil?
 
-      if node.value || node.level == 0
+      if node.value || node.level.zero?
         node.vlevel + 1
       else
         set_vlevel(node.parent)
       end
     end
   end
-end
+end

data/lib/rshade/filter/abstract_filter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RShade
   module Filter
     class AbstractFilter
@@ -23,4 +25,4 @@ module RShade
       end
     end
   end
-end
+end

data/lib/rshade/filter/default.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RShade
   module Filter
     class Default
@@ -25,4 +27,4 @@ module RShade
       end
     end
   end
-end
+end

data/lib/rshade/filter/exclude_path_filter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RShade
   module Filter
     class ExcludePathFilter < IncludePathFilter
@@ -11,14 +13,15 @@ module RShade
         0
       end
 
-      private
-      def str?(str, event_path)
-        !event_path.include?(str)
-      end
+      def call(event)
+        event_path = event.path
+        paths.none? do |path|
+          next str?(path, event_path) if path.is_a? String
+          next regexp?(path, event_path) if path.is_a? Regexp
 
-      def regexp?(regex, event_path)
-        !regex.match?(event_path)
+          false
+        end
       end
     end
   end
-end
+end

data/lib/rshade/filter/filter_builder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RShade
   module Filter
     class FilterBuilder
@@ -18,11 +20,20 @@ module RShade
         arg1 = arr[1]
         arg2 = nil
         arg2 = arr[2] if arity == 2
-        arg1 = traverse(arg1) if arg1.is_a?(Array)
-        arg2 = traverse(arg2) if arg2.is_a?(Array)
+        arg1 = if arg1.is_a?(Array)
+                 traverse(arg1)
+               else
+                 RShade::Filter::FilterComposition.new(arg1)
+               end
+
+        arg2 = if arg2.is_a?(Array)
+                 traverse(arg2)
+               else
+                 RShade::Filter::FilterComposition.new(arg2)
+               end
 
         RShade::Filter::FilterComposition.new(op, arg1, arg2)
       end
     end
   end
-end
+end