rshade 0.1.9.1 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91ab4d11c9af8066bff925ab208f10e20c5bf7fd5685418b0c8ef01880c13d2f
-  data.tar.gz: 7c0e95c99b1707e5290440cf3459e02cd465c653bdbfbfdc3f216d77a3647c66
+  metadata.gz: efdbfc08fca88589c49b580abbbeb36687b68986e365291c2c4758633b33943d
+  data.tar.gz: 78e8147a5539bb79216281763274c676d916729b62af681b2811caa1772f7031
 SHA512:
-  metadata.gz: 21fe1fa50bf9c63261fbed6651ad8999edc22734567c3f33b2ba872ba95640cb70b3cff8fa0c640fd13faa8cf73371bb107ee8d0303e3e1322bba06a87f30d58
-  data.tar.gz: 2b657588399858bcc1aa9f60cac2baf92ea3427b341542c40f15c7a7a26cbfb17cabfa3b98a2c5465c1905a3c8dfeb9500ed772351d89bdd7c2b6ca3ac223392
+  metadata.gz: 39fad4c1cb0663e510aaee89100090a10e689880da9f2fb2422fc404094337bad4bcbd5bb72a96270b284a3709392d4d9879cb1410d8f912d8e55db2962a8e4f
+  data.tar.gz: de5d785cfe183f5a7109aeebb128086e0173ce126788165b7dc18b818de066909830e628b5322c84ff6c9655696cb34cc8c7d289aafff036965f6a7caeb7bda0

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/.rubocop.yml

@@ -0,0 +1,31 @@
+# The behavior of RuboCop can be controlled via the .rubocop.yml
+# configuration file. It makes it possible to enable/disable
+# certain cops (checks) and to alter their behavior if they accept
+# any parameters. The file can be placed either in your home
+# directory or in some project directory.
+#
+# RuboCop will start looking for the configuration file in the directory
+# where the inspected file is and continue its way up to the root directory.
+#
+# See https://docs.rubocop.org/rubocop/configuration
+AllCops:
+  NewCops: enable
+  Exclude:
+    - 'spec/fixture/**/*'
+Style/HashSyntax:
+  EnforcedShorthandSyntax: never
+
+Naming/MethodParameterName:
+  Exclude:
+    - spec/**/*
+    - test.rb
+Style/Documentation:
+  Enabled: false
+Metrics/BlockLength:
+  Max: 75
+Metrics/MethodLength:
+  Max: 30
+Metrics/PerceivedComplexity:
+  Max: 10
+Metrics/AbcSize:
+  Max: 30

data/Gemfile

@@ -1,10 +1,17 @@
-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 'bundler', '~> 2.2.33'
+  gem 'prism'
   gem 'pry'
+  gem 'rake', '>= 12.3.3'
+  gem 'rspec', '~> 3.0'
 end

data/Gemfile.lock

@@ -1,16 +1,22 @@
 PATH
   remote: .
   specs:
-    rshade (0.1.9.1)
+    rshade (0.2.1)
+      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)
+    colorize (1.1.0)
+    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,22 @@ 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.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,40 @@
+# frozen_string_literal: true
+
+module RShade
+  class Config
+    class Registry
+      include Singleton
+      attr_reader :map, :mutex
+
+      def initialize
+        @map = {}
+        @mutex = Mutex.new
+        defaults
+      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,63 @@
+# frozen_string_literal: true
+
+module RShade
+  class Config
+    class StackStore
+      attr_reader :filter, :formatter, :custom_serializers
+
+      DEFAULT_FORMATTER = {
+        json: ::RShade::Formatter::Stack::Json,
+        stdout: ::RShade::Formatter::Stack::Stdout
+      }.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 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
+        variable_filter = RShade::Filter::VariableFilter.new
+        include_filter = RShade::Filter::IncludePathFilter.new
+        exclude_filter = RShade::Filter::ExcludePathFilter.new
+
+        RShade::Filter::FilterBuilder.build([:or,
+                                             [:or, variable_filter, include_filter], exclude_filter])
+      end
+    end
+  end
+end

data/lib/rshade/config/store.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 module RShade
   class Config
@@ -8,14 +9,14 @@ module RShade
       # @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)
+      def tp_events!(tp_events)
         @tp_events = tp_events
         self
       end
@@ -25,13 +26,12 @@ module RShade
         self
       end
 
-
       def config_filter(filter_type, &block)
         filter_composition.config_filter(filter_type, &block)
         self
       end
 
-      def set_formatter(formatter)
+      def formatter!(formatter)
         @formatter = formatter
         self
       end
@@ -39,7 +39,12 @@ 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])
+        variable_filter = RShade::Filter::VariableFilter.new
+        include_filter = RShade::Filter::IncludePathFilter.new
+        exclude_filter = RShade::Filter::ExcludePathFilter.new
+
+        RShade::Filter::FilterBuilder.build([:or,
+                                             [:or, variable_filter, include_filter], exclude_filter])
       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.]*/
+    RUBY_VERSION_PATTERN = /ruby-[0-9.]*/.freeze
 
     def self.default
-      ::RShade::Config::Store.new.set_formatter(::RShade::Formatter::Stdout.new)
+      ::RShade::Config::Store.new.formatter!(::RShade::Formatter::Trace::Stdout.new)
                              .config_filter(::RShade::Filter::ExcludePathFilter) do |paths|
         default_excluded_path.each do |path|
           paths << path
@@ -20,13 +22,13 @@ 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
 
     def tp_events(&block)
       events = block.call
-      @config_store.set_tp_events(events)
+      @config_store.tp_events!(events)
       self
     end
 
@@ -47,7 +49,7 @@ module RShade
 
     def formatter(&block)
       formatter = block.call
-      @config_store.set_formatter(formatter)
+      @config_store.formatter!(formatter)
       self
     end
 
@@ -68,9 +70,8 @@ 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
+      [ENV['GEM_PATH'].split(':'), RUBY_VERSION_PATTERN, /internal/, %r{/gems/}].flatten.compact
     end
   end
 end

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

@@ -1,8 +1,40 @@
+# frozen_string_literal: true
+
 class Object
-  def reveal(&block)
-    trace = ::RShade::Trace.reveal do
-      block.call
+  # rubocop:disable Metrics/MethodLength
+  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)
+          super
+          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
+  # rubocop:enable Metrics/MethodLength
+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
@@ -20,7 +22,7 @@ module RShade
       self
     end
 
-    def set_return_value!(return_value)
+    def return_value!(return_value)
       @hash[:return_value] = return_value
       self
     end
@@ -38,12 +40,20 @@ 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,
                event_type: evt.event }
-      hash.merge!({return_value: evt.return_value}) if RETURN_EVENTS.include?(evt.event)
+
+      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
 

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,36 +1,37 @@
+# frozen_string_literal: true
+
 module RShade
   # nodoc
   class EventProcessor
-    attr_reader :store
+    attr_reader :store, :serializer
 
     def initialize(store, config)
       @store = store
       custom_serializers = config.custom_serializers
-      @var_serializer = ::RShade::Serializer::Traversal.new(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.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
@@ -8,6 +10,7 @@ module RShade
       @current = @head = EventTreeNode.new(nil, 0, nil)
     end
 
+    # rubocop:disable Metrics/AbcSize
     def add(value, level)
       if current.level + 1 == level
         current.children << EventTreeNode.new(value, level, current)
@@ -16,22 +19,19 @@ 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
+    # rubocop:enable Metrics/AbcSize
 
     def current!(&block)
       block.call(current.children.last) if current.children.last
@@ -47,29 +47,29 @@ 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
       @value = value
-      @vlevel = set_vlevel(parent)
+      @vlevel = vlevel!(parent)
     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
+    def vlevel!(node)
+      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)
+        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,7 +1,9 @@
+# frozen_string_literal: true
+
 module RShade
   module Filter
     class Default
-      RUBY_VERSION_PATTERN = /ruby-[0-9.]*/
+      RUBY_VERSION_PATTERN = /ruby-[0-9.]*/.freeze
 
       def self.create
         new.create
@@ -25,4 +27,4 @@ module RShade
       end
     end
   end
-end
+end