rshade 0.2.0 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 39758f070ab0a6b6e7dc0bdc09aa03bb107130f84fe7115331189a31c0e013eb
-  data.tar.gz: 0331bdd526cd0155df7d210603bb07a15c9541bcce62197b2754731e640060c3
+  metadata.gz: e267f5e11b2c8624bc38c88c031a12e9b252b5581b803fe4076f40d532d75c81
+  data.tar.gz: 153c3b896ce3701be9bc26a9501f987220e23c8ebb4e253d42a0968cf2e43709
 SHA512:
-  metadata.gz: b0c97b53d02f997d05484e850655dfe561c82da1d110a111022885278ece826b5fc75b2e5d70260ff59095ca29178e681c85915301a6b171efe263aa42c82f64
-  data.tar.gz: ed9a95bceb71f94cd17587bd88086a6e26d77b5a19fe14ed96b4cfbd559fa1574ffaca380ec3fc49167e788197008bc08b581f83fb5997fb058dedba77e49bf8
+  metadata.gz: a0c00f405183f7f3a5a33d7e9fd9b5bf4cc4692aabc6cf7400bc32b4fb3e704c0e94b583da98447a868f5c7079b290df835e8f0ed75d8ec66544404748df5466
+  data.tar.gz: 273df7e4c8b3107bb8fb5a09c1ef36c8489caf2f5e87550aaa9631b79bd0cdc3a7f4a5641db2f38107e6c28203e0f21a7a51f4e2e47d5da47ab7d3f5d1d89e66

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

@@ -9,6 +9,9 @@ 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,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rshade (0.2.0)
+    rshade (0.2.2)
       binding_of_caller
       colorize
       prism
@@ -12,7 +12,7 @@ GEM
     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)

data/README.md

@@ -16,6 +16,14 @@ gem install rshade
 Simple wrap code that you want to check in to block and it will pretty print all of the calls which was made in this block with pointing line of executions, variables what was pass
 inside methods and variables what was return
 ```ruby
+# config
+::RShade::Config::Registry.instance.trace_config do |config|
+   config.exclude_gems!
+   filepath = File.join(Rails.root, 'log', 'rshade-trace.json.log')
+   config.formatter!(:json, { filepath: filepath, pretty: false })
+end
+
+# execute
 RShade::Trace.reveal do  
   #your code here
 end.show
@@ -34,25 +42,41 @@ change this behaviour or add your own filter. Even when some piece of code are n
 
 ### Configuration
 ```ruby
-config = ::RShade::Config.default
-
-RShade::Trace.reveal(config) do
-end.show
+::RShade::Config::Registry.instance.trace_config do |config|
+   # exclude gems 
+   config.exclude_gems!
+   # path where save output
+   filepath = File.join(Rails.root, 'log', 'rshade-trace.json.log')
+   # output can be json or stdout
+   config.formatter!(:json, { filepath: filepath, pretty: false })
+end
 ```
 ### Filters
 Filters by default represent by expression `(include_path or variable_match) or (not exclude_path)`
 Filters can be chained like:
 ```ruby
-config = ::RShade::Config.default.include_paths { |paths| paths << /devise/ }
-                                  .exclude_paths { |paths| paths << /warden/ } 
-                                  .match_variable { |name, value| name == :current_user }
+::RShade::Config::Registry.instance.trace_config do |config|
+   config.filter!(RShade::Filter::VariableFilter) do |name, value|
+      name == :current_user
+   end
+   config.filter!(::RShade::Filter::ExcludePathFilter) do |paths|
+      paths.concat(/gems/)
+   end
+   config.filter!(::RShade::Filter::IncludePathFilter) do |paths|
+      paths.concat(/devise/)
+   end
+end
 ```
 #### Filter by path include
 `paths` - is array which accept regex or string
 ```ruby
-config = ::RShade::Config.default.include_paths { |paths| paths << /devise/ }
+::RShade::Config::Registry.instance.trace_config do |config|
+   config.filter!(::RShade::Filter::IncludePathFilter) do |paths|
+      paths.concat(/devise/)
+   end
+end
 
-RShade::Trace.reveal(config) do
+RShade::Trace.reveal do
    #your code
 end.show
 
@@ -60,9 +84,13 @@ end.show
 #### Filter by path exclude
 `paths` - is array which accept regex or string
 ```ruby
-config = ::RShade::Config.default.exclude_paths { |paths| paths << /devise/ }
+::RShade::Config::Registry.instance.trace_config do |config|
+   config.filter!(::RShade::Filter::ExcludePathFilter) do |paths|
+      paths.concat(/gems/)
+   end
+end
 
-RShade::Trace.reveal(config) do
+RShade::Trace.reveal do
    #your code
 end.show
 ```
@@ -71,9 +99,14 @@ end.show
 `name` - represent variable name as symbol
 `value` - actual variable value
 ```ruby
-config = ::RShade::Config.default.match_variable { |name, value| name == :current_user }
 
-RShade::Trace.reveal(config) do
+::RShade::Config::Registry.instance.trace_config do |config|
+   config.filter!(RShade::Filter::VariableFilter) do |name, value|
+      name == :current_user
+   end
+end
+
+RShade::Trace.reveal do
    #your code
 end.show
 ```
@@ -102,11 +135,18 @@ As you can see all code that have been in use is printed.
 
 ## 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 })
+   config.exclude_gems!
+   filepath = File.join(Rails.root, 'log', 'rshade-stack.json.log')
+   config.formatter!(:json, { filepath: filepath, pretty: false })
+
+   config.serializer!({
+                              ActionDispatch::Request => ->(value) do
+                                 "#{value.to_s} -> #{value.method} -> #{value.path}"
+                              end
+                      })
 end
 ```
 

data/lib/rshade/config/event_store.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RShade
+  class Config
+    class EventStore
+      attr_reader :filter, :formatter, :tp_events, :variable_serializer
+
+      DEFAULT_FORMATTER = {
+        json: ::RShade::Formatter::Trace::Json,
+        stdout: ::RShade::Formatter::Trace::Stdout
+      }.freeze
+
+      def self.default
+        new.exclude_gems!
+      end
+
+      # @param [Array<Symbol>] tp_events
+      # @param [RShade::Formatter::Trace::Stdout] formatter
+      # @param [RShade::Filter::FilterComposition] filter
+      # @param [Hash] serializers
+      def initialize(tp_events: %i[call return], formatter: RShade::Formatter::Trace::Stdout.new,
+                     filter: default_filter_composition,
+                     serializers: {})
+        @filter = filter
+        @formatter = formatter
+        @tp_events = tp_events
+        @variable_serializer = serializers
+      end
+
+      def tp_events!(tp_events)
+        @tp_events = tp_events
+        self
+      end
+
+      def serializer!(hash)
+        variable_serializer.merge!(hash)
+        self
+      end
+
+      def filter!(filter_type, &block)
+        filter.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!
+        filter!(::RShade::Filter::ExcludePathFilter) do |paths|
+          paths.concat(RShade::Utils.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/registry.rb

@@ -3,9 +3,11 @@
 module RShade
   class Config
     class Registry
+      include Singleton
       attr_reader :map, :mutex
 
-      include Singleton
+      DEFAULT_EVENT_STORE = :event_store_default
+      DEFAULT_STACK_STORE = :stack_store_default
 
       def initialize
         @map = {}
@@ -13,33 +15,51 @@ module RShade
         defaults
       end
 
-      def set_default_stack(config)
+      def default_stack_config
+        val = nil
         mutex.synchronize do
-          map[:store_default] = config
+          val = map[DEFAULT_STACK_STORE]
         end
+        val
       end
 
-      def default_stack_config
+      def stack_config(&block)
+        val = nil
+        mutex.synchronize do
+          val = ::RShade::Config::StackStore.new
+          block.call(val)
+          map[DEFAULT_STACK_STORE] = val
+        end
+        val
+      end
+
+      def default_trace_config
         val = nil
         mutex.synchronize do
-          val = map[:store_default]
+          val = map[DEFAULT_EVENT_STORE]
         end
         val
       end
 
-      def stack_config(&block)
+      def trace_config(&block)
         val = nil
         mutex.synchronize do
-          val = ::RShade::Config::StackStore.new
+          val = ::RShade::Config::EventStore.new
           block.call(val)
-          map[:store_default] = val
+          map[DEFAULT_EVENT_STORE] = val
         end
         val
       end
 
       def defaults
         mutex.synchronize do
-          map[:store_default] = ::RShade::Config::StackStore.new
+          stack_store = ::RShade::Config::StackStore.new
+          stack_store.exclude_gems!
+          map[DEFAULT_STACK_STORE] = stack_store
+
+          event_store = ::RShade::Config::EventStore.new
+          event_store.exclude_gems!
+          map[DEFAULT_EVENT_STORE] = event_store
         end
       end
     end

data/lib/rshade/config/stack_store.rb

@@ -3,39 +3,41 @@
 module RShade
   class Config
     class StackStore
-      attr_reader :filter, :formatter, :custom_serializers
+      attr_reader :filter, :formatter, :variable_serializer
 
       DEFAULT_FORMATTER = {
-        json: ::RShade::Formatter::Stack::Json
+        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, {})
+      # @param [RShade::Formatter::Stack::Stdout] formatter
+      # @param [RShade::Filter::FilterComposition] filter
+      # @param [Hash] serializers
+      def initialize(formatter: RShade::Formatter::Stack::Stdout.new, filter: default_filter_composition,
+                     serializers: {})
+        @filter = filter
+        @formatter = formatter
+        @variable_serializer = ::RShade::Serializer::Traversal.new(serializers)
       end
 
-      def add_custom_serializers(hash)
-        custom_serializers.merge!(hash)
+      def serializer!(hash)
+        variable_serializer.merge!(hash)
         self
       end
 
-      def config_filter(filter_type, &block)
-        filter.config_filter(filter_type, &block)
+      def filter!(filter_type, &block)
+        filter.filter(filter_type, &block)
         self
       end
 
-      def set_formatter(formatter, opts = {})
+      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)
+        filter!(::RShade::Filter::ExcludePathFilter) do |paths|
+          paths.concat(RShade::Utils.default_excluded_path)
         end
         self
       end
@@ -50,8 +52,12 @@ module RShade
       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, RShade::Filter::VariableFilter.new, RShade::Filter::IncludePathFilter.new], RShade::Filter::ExcludePathFilter.new])
+                                             [:or, variable_filter, include_filter], exclude_filter])
       end
     end
   end

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

@@ -1,13 +1,15 @@
 # frozen_string_literal: true
 
 class Object
+  # rubocop:disable Metrics/MethodLength
   def reveal(method_name = nil, **opts, &block)
     if method_name
       @__cache_rshade_reveal ||= {}
-      config = opts.fetch(:config, ::RShade::Config.default)
+      config = opts.fetch(:config, ::RShade::Config::Registry.instance.default_trace_config)
       @__cache_rshade_reveal[method_name] = config
       instance_eval do
         def method_added(name)
+          super
           return unless @__cache_rshade_reveal[name]
 
           if @__reveal_rewrite
@@ -19,7 +21,7 @@ class Object
           origin_method = instance_method(name)
           define_method(name) do |*args, &fn|
             val = nil
-            trace = ::RShade::Trace.reveal(config) do
+            trace = ::RShade::Trace.reveal(config: config) do
               val = origin_method.bind(self).call(*args, &fn)
             end
             trace.show
@@ -34,4 +36,5 @@ class Object
       trace.show
     end
   end
+  # rubocop:enable Metrics/MethodLength
 end

data/lib/rshade/event.rb

@@ -22,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
@@ -46,7 +46,7 @@ module RShade
         vars[var_name] = hash
       end
 
-      hash = { path: evt.path, lineno: evt.lineno, klass: evt.defined_class, method_name: evt.method_id, vars:,
+      hash = { path: evt.path, lineno: evt.lineno, klass: evt.defined_class, method_name: evt.method_id, vars: vars,
                event_type: evt.event }
 
       if RETURN_EVENTS.include?(evt.event)

data/lib/rshade/event_observer.rb

@@ -4,7 +4,7 @@ module RShade
   class EventObserver
     attr_reader :event_processor, :config
 
-    # @param [RShade::Config::Store] config
+    # @param [RShade::Config::EventStore] config
     # @param [RShade::EventProcessor] event_store
     def initialize(config, event_processor)
       @event_processor = event_processor
@@ -41,7 +41,7 @@ module RShade
     end
 
     def pass?(event)
-      config.filter_composition.call(event)
+      config.filter.call(event)
     end
   end
 end

data/lib/rshade/event_processor.rb

@@ -7,7 +7,7 @@ module RShade
 
     def initialize(store, config)
       @store = store
-      custom_serializers = config.custom_serializers
+      custom_serializers = config.variable_serializer
       @serializer = ::RShade::Serializer::Traversal.new(custom_serializers)
     end
 
@@ -22,7 +22,7 @@ module RShade
     # @param [Integer] level
     def leave(event, _level)
       store.current! do |node|
-        node.value.set_return_value!(event.return_value)
+        node.value.return_value!(event.return_value)
             .with_serialized_return!(serializer)
       end
     rescue StandardError

data/lib/rshade/event_tree.rb

@@ -10,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)
@@ -30,6 +31,7 @@ module RShade
       @current = current.parent
       add(value, level)
     end
+    # rubocop:enable Metrics/AbcSize
 
     def current!(&block)
       block.call(current.children.last) if current.children.last
@@ -50,7 +52,7 @@ module RShade
       @level = level
       @parent = parent
       @value = value
-      @vlevel = set_vlevel(parent)
+      @vlevel = vlevel!(parent)
     end
 
     def each(&block)
@@ -60,13 +62,13 @@ module RShade
 
     private
 
-    def set_vlevel(node)
+    def vlevel!(node)
       return 0 if node.nil?
 
       if node.value || node.level.zero?
         node.vlevel + 1
       else
-        set_vlevel(node.parent)
+        vlevel!(node.parent)
       end
     end
   end

data/lib/rshade/filter/default.rb

@@ -3,7 +3,7 @@
 module RShade
   module Filter
     class Default
-      RUBY_VERSION_PATTERN = /ruby-[0-9.]*/
+      RUBY_VERSION_PATTERN = /ruby-[0-9.]*/.freeze
 
       def self.create
         new.create

data/lib/rshade/filter/filter_composition.rb

@@ -7,7 +7,7 @@ module RShade
       AND_OP = :and
       OR_OP = :or
       UNARY_OP = :unary
-      attr_reader :value, :left, :right, :parent
+      attr_reader :value, :left, :right
       attr_accessor :parent
 
       # @param [#call, Enumerable] left
@@ -18,6 +18,7 @@ module RShade
         @right = right
       end
 
+      # rubocop:disable Metrics/CyclomaticComplexity
       def call(event)
         case value
         when UNARY_OP
@@ -30,6 +31,7 @@ module RShade
           value.call(event)
         end
       end
+      # rubocop:enable Metrics/CyclomaticComplexity
 
       def each(&block)
         yield value unless left && right
@@ -37,9 +39,9 @@ module RShade
         right&.each(&block)
       end
 
-      def config_filter(type, &block)
-        filter = find do |filter|
-          filter.is_a? type
+      def filter(type, &block)
+        filter = find do |f|
+          f.is_a? type
         end
         filter&.config(&block)
       end

data/lib/rshade/filter/include_path_filter.rb

@@ -8,6 +8,7 @@ module RShade
       NAME = :include_paths
 
       def initialize
+        super
         @paths = []
       end
 

data/lib/rshade/filter/variable_filter.rb

@@ -8,6 +8,7 @@ module RShade
       NAME = :variable_filter
 
       def initialize
+        super
         @matchers = []
       end
 
@@ -21,8 +22,8 @@ module RShade
 
       def call(event)
         matchers.each do |match|
-          event.vars.each do |name, value|
-            return true if match.call(name, value)
+          event.vars.each do |name, hash|
+            return true if match.call(name, hash[:value])
           end
         end
         false

data/lib/rshade/formatter/stack/json.rb

@@ -4,7 +4,7 @@ module RShade
   module Formatter
     module Stack
       class Json
-        attr_reader :filepath, :pretty
+        attr_reader :filepath, :pretty, :variable_serializer
 
         def initialize(filepath:, pretty: false)
           @filepath = filepath
@@ -12,9 +12,9 @@ module RShade
         end
 
         # @param [Array<RShade::StackFrame>] stack_frames
-        def call(stack_frames)
+        def call(stack_frames, variable_serializer: nil)
           payload = stack_frames.map.with_index do |frame, idx|
-            serialize(idx, frame)
+            serialize(idx, frame, variable_serializer)
           end
 
           File.open(filepath, 'a+') do |file|
@@ -37,12 +37,14 @@ module RShade
         end
 
         # @param [RShade::StackFrame] frame
-        def serialize(idx, frame)
+        def serialize(idx, frame, variable_serializer)
+          local_vars = variable_serializer.nil? ? frame.local_vars : variable_serializer.call(frame.local_vars)
+          receiver_variables = variable_serializer.call(frame.receiver_variables) unless variable_serializer.nil?
           {
             frame: idx,
             source_location: "#{frame.source_location[:path]}:#{frame.source_location[:line]}",
-            local_variables: frame.local_vars,
-            receiver_variables: frame.receiver_variables
+            local_variables: local_vars,
+            receiver_variables: receiver_variables
           }
         end
       end

data/lib/rshade/formatter/stack/stdout.rb

@@ -4,8 +4,8 @@ module RShade
   module Formatter
     module Stack
       class Stdout < String
-        def call(stack)
-          puts super(stack)
+        def call(stack_frames, variable_serializer: nil)
+          puts super
         end
       end
     end