rshade 0.1.8 → 0.1.9

data/lib/rshade/filter/filter_builder.rb

@@ -0,0 +1,28 @@
+module RShade
+  module Filter
+    class FilterBuilder
+      def self.build(arr)
+        new.traverse(arr)
+      end
+
+      def map
+        {
+          or: [RShade::Filter::FilterComposition::OR_OP, 2],
+          and: [RShade::Filter::FilterComposition::AND_OP, 2],
+          unary: [RShade::Filter::FilterComposition::UNARY_OP, 1]
+        }
+      end
+
+      def traverse(arr)
+        op, arity = map[arr[0]]
+        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)
+
+        RShade::Filter::FilterComposition.new(op, arg1, arg2)
+      end
+    end
+  end
+end

data/lib/rshade/filter/filter_composition.rb

@@ -0,0 +1,57 @@
+module RShade
+  module Filter
+    class FilterComposition
+      include Enumerable
+      AND_OP = :and
+      OR_OP = :or
+      UNARY_OP = :unary
+      attr_reader :op, :left, :right, :parent
+      attr_accessor :parent
+
+      # @param [#call, Enumerable] left
+      # @param [#call, Enumerable] right
+      def initialize(op=UNARY_OP, left=nil, right=nil)
+        @op = op
+        @left = left
+        @right = right
+      end
+
+      def call(event)
+        case op
+        when UNARY_OP
+          return left&.call(event)
+        when AND_OP
+          return left&.call(event) && right&.call(event)
+        when OR_OP
+          l = left&.call(event)
+          r = right&.call(event)
+          # puts "#{left} => #{l} OR #{right} => #{r}"
+          return l || r
+        else
+          raise 'undefined op'
+        end
+      end
+
+      def each(&block)
+        if left&.respond_to?(:each)
+          left&.each(&block)
+        else
+          yield left
+        end
+
+        if right&.respond_to?(:each)
+          right&.each(&block)
+        else
+          yield right
+        end
+      end
+
+      def config_filter(type, &block)
+        filter = find do |filter|
+          filter.is_a? type
+        end
+        filter.config(&block) if filter
+      end
+    end
+  end
+end

data/lib/rshade/filter/include_path_filter.rb

@@ -0,0 +1,43 @@
+module RShade
+  module Filter
+    class IncludePathFilter < AbstractFilter
+      attr_reader :paths
+
+      NAME = :include_paths
+
+      def initialize
+        @paths = []
+      end
+
+      def name
+        NAME
+      end
+
+      def priority
+        1
+      end
+
+      def call(event)
+        event_path = event.path
+        paths.any? do |path|
+          next str?(path, event_path) if path.is_a? String
+          next regexp?(path, event_path) if path.is_a? Regexp
+          false
+        end
+      end
+
+      def config_call(&block)
+        block.call(@paths)
+      end
+
+      private
+      def str?(str, event_path)
+        event_path.include?(str)
+      end
+
+      def regexp?(regex, event_path)
+        regex.match?(event_path)
+      end
+    end
+  end
+end

data/lib/rshade/filter/variable_filter.rb

@@ -0,0 +1,33 @@
+module RShade
+  module Filter
+    class VariableFilter < AbstractFilter
+      attr_reader :matchers
+      NAME = :variable_filter
+
+      def initialize
+        @matchers = []
+      end
+
+      def name
+        :variable_filter
+      end
+
+      def priority
+        2
+      end
+
+      def call(event)
+        matchers.each do |match|
+          event.vars.each do |name, value|
+            return true if match.call(name, value)
+          end
+        end
+        false
+      end
+
+      def config_call(&block)
+        matchers << block
+      end
+    end
+  end
+end

data/lib/rshade/formatter/file.rb

@@ -1,15 +1,15 @@
 module RShade
   module Formatter
-    class File < ::RShade::Base
-      attr_reader :formatter, :event_store
+    class File
+      attr_reader :formatter
       FILE_NAME = 'stacktrace.json'.freeze
 
-      def initialize(event_store, args={})
-        @event_store = event_store
+      def initialize(args={})
         @formatter = args.fetch(:format, Json)
       end
 
-      def call
+      # @param [RShade::EventProcessor] event_store
+      def call(event_store)
         data = formatter.call(event_store)
         if formatter == Json
           write_to_file(JSON.pretty_generate(data))
@@ -19,7 +19,7 @@ module RShade
       end
 
       def write_to_file(data)
-        ::File.open(::File.join(RShade.config.store_dir, FILE_NAME), "w+") do |f|
+        ::File.open(::File.join(RShade::Config.store_dir, FILE_NAME), "w+") do |f|
           f.write data
         end
       end

data/lib/rshade/formatter/html.rb

@@ -1,16 +1,18 @@
+require 'json'
+
 module RShade
   module Formatter
-    class Html < ::RShade::Base
-      attr_reader :formatter, :event_store
+    class Html
+      attr_reader :formatter
       FILE_NAME = 'stacktrace.html'.freeze
       TEMPLATE = 'html/template.html.erb'
 
-      def initialize(event_store, args={})
-        @event_store = event_store
+      def initialize(args={})
         @formatter = args.fetch(:formatter, Json)
       end
 
-      def call
+      # @param [RShade::EventProcessor] event_store
+      def call(event_store)
         data = formatter.call(event_store)
         erb_template = ERB.new(template)
         content = erb_template.result_with_hash({json: data.to_json})
@@ -18,13 +20,13 @@ module RShade
       end
 
       def write_to_file(data)
-        ::File.open(::File.join(RShade.config.store_dir, FILE_NAME), "w+") do |f|
+        ::File.open(::File.join(RShade::Config.store_dir, FILE_NAME), "w+") do |f|
           f.write data
         end
       end
 
       def template
-        @template ||=::File.read(::File.join(::RShade.config.root_dir, TEMPLATE))
+        @template ||=::File.read(::File.join(::RShade::Config.root_dir, TEMPLATE))
       end
     end
   end

data/lib/rshade/formatter/json.rb

@@ -1,27 +1,26 @@
 module RShade
   module Formatter
-    class Json < ::RShade::Base
-      attr_reader :event_store
+    class Json
+      attr_reader :event_processor
 
-      def initialize(event_store)
+      # @param [RShade::EventProcessor] event_store
+      def call(event_store)
         @event_store = event_store
-      end
-
-      def call
         flat
       end
 
       def flat
         arr = []
-        event_store.iterate do |node, depth|
-          arr << item(node)
+        event_store.each do |node|
+          arr << item(node.event)
         end
-        arr.sort_by { |item| item[:depth]}
+        arr.sort_by { |item| item[:level]}
       end
 
       def hierarchical
         hash = {}
-        event_store.iterate do |node, depth|
+        event_store.each do |node|
+          depth = node.level
           ref = hash_iterate(hash, depth)
           ref[:data] = item(node)
         end
@@ -48,11 +47,11 @@ module RShade
 
       def item(value)
         {
-            class: value.klass.to_s,
-            method_name: value.method_name,
-            full_path: "#{value.path}:#{value.lineno}",
-            depth: value.depth,
-            vars: value.vars
+          class: value.klass.to_s,
+          method_name: value.method_name,
+          full_path: "#{value.path}:#{value.lineno}",
+          level: value.depth,
+          vars: value.vars
         }
       end
     end

data/lib/rshade/formatter/stdout.rb

@@ -1,9 +1,9 @@
 module RShade
   module Formatter
     class Stdout < String
-      def call
-        buffer = super
-        puts buffer
+      # @param [RShade::EventProcessor] event_store
+      def call(event_store)
+        puts super(event_store)
       end
     end
   end

data/lib/rshade/formatter/string.rb

@@ -1,29 +1,35 @@
 module RShade
   module Formatter
-    class String < ::RShade::Base
-      attr_reader :event_store
+    class String
       ROOT_SEP = "---\n"
 
-      def initialize(event_store)
-        @event_store = event_store
+      def initialize(opts= {})
       end
 
-      def call
+      # @param [RShade::EventProcessor] event_store
+      def call(event_store)
         buffer = StringIO.new
-        event_store.iterate do |node, depth|
+        event_store.each_with_index do |node, idx|
+          depth = node.level
+          event = node.value
           if depth == 1
             buffer << ROOT_SEP
             next
           end
-          puts line(node, depth)
+          next unless event
+          buffer.write line(idx, event, node.vlevel)
         end
         buffer.string
       end
 
-      def line(value, depth)
-        class_method = "#{value.klass}##{value.method_name}".colorize(:green)
-        full_path = "#{value.path}:#{value.lineno}".colorize(:blue)
-        "#{'  ' * depth}#{class_method}(#{value.vars}) -> #{full_path}\n"
+      def line(line_idx, value, depth)
+        vars = value.vars
+        returned = ColorizedString["=> |#{value.return_value}|"].colorize(:magenta)
+
+        class_method = ColorizedString["#{value.klass}##{value.method_name}"].colorize(:green)
+        full_path = ColorizedString["#{value.path}:#{value.lineno}"].colorize(:blue)
+        line_idx = ColorizedString["[#{line_idx}] "].colorize(:red)
+        "#{'  ' * depth}#{line_idx}#{class_method}(#{vars}) #{returned} -> #{full_path}\n"
       end
     end
   end

data/lib/rshade/trace.rb

@@ -1,54 +1,34 @@
 module RShade
   class Trace
-    attr_accessor :event_store, :formatter, :filter
-    EVENTS = %i[call return].freeze
-
-    def initialize(options={})
-      @event_store = EventStore.new
-      @formatter = options.fetch(:formatter, RShade.config.formatter)
-      @filter = options.fetch(:filter, RShade.config.filter)
-      @tp = TracePoint.new(*EVENTS, &method(:process_trace))
-      @level = 1
-      @stat = {}
-      @calls = 0
-      @returns = 0
+    attr_reader :config, :event_store
+    
+    # @param [RShade::Config,RShade::Config::Store] config
+    def initialize(config)
+      @config = fetch_config(config)
+      @event_store = EventTree.new
     end
 
-    def self.reveal(options={}, &block)
-      new(options).reveal(&block)
+    def self.reveal(config=nil, &block)
+      new(config).reveal(&block)
     end
 
-    def reveal
-      return unless block_given?
-
-      @tp.enable
-      yield
+    def reveal(&block)
+      processor = EventProcessor.new(@event_store)
+      observer = EventObserver.new(config, processor)
+      observable = RShade::TraceObservable.new([observer], config)
+      observable.reveal &block
       self
-    ensure
-      @tp.disable
     end
 
     def show
-      formatter.call(event_store)
+      config.formatter.call(event_store)
     end
 
-    def stat
-      { calls: @calls, returns: @returns }
-    end
-
-    def process_trace(tp)
-      if tp.event == :call
-        @level +=1
-        hash = EventSerializer.call(tp, @level)
-        return unless filter.call(hash)
-        @calls += 1
-        event_store << Event.new(hash)
-      end
-
-      if tp.event == :return && @level > 0
-        @returns += 1
-        @level -=1
-      end
+    private
+    def fetch_config(config)
+      config = config || ::RShade::Config.default
+      config = config.value if config.is_a?(::RShade::Config)
+      config
     end
   end
 end

data/lib/rshade/trace_observable.rb

@@ -0,0 +1,40 @@
+module RShade
+  class TraceObservable
+    include Observable
+    attr_reader :trace_p
+    CALL_EVENTS = Set[:call, :c_call, :b_call]
+    RETURN_EVENTS = Set[:return, :c_return, :b_return]
+
+    # @param [Enumerable<#call>, #call] observers
+    # @param [::RShade::Config::Store] config
+    def initialize(observers, config)
+      @trace_p = TracePoint.new(*config.tp_events, &method(:process))
+      observers = [observers] unless observers.is_a?(Enumerable)
+
+      observers.each do |observer|
+        add_observer(observer, :call)
+      end
+    end
+
+    def reveal
+      return unless block_given?
+
+      trace_p.enable
+      yield
+      self
+    ensure
+      trace_p.disable
+    end
+
+    private
+    # more info https://rubyapi.org/3.1/o/tracepoint
+    # @param [TracePoint] tp
+    def process(tp)
+      changed
+      event = Event.from_trace_point(tp)
+      return notify_observers(event, :enter) if CALL_EVENTS.include?(tp.event)
+      return notify_observers(event, :leave) if RETURN_EVENTS.include?(tp.event)
+      notify_observers(event, :other)
+    end
+  end
+end

data/lib/rshade/version.rb

@@ -1,3 +1,3 @@
 module RShade
-  VERSION = "0.1.8"
+  VERSION = "0.1.9"
 end

data/lib/rshade.rb

@@ -1,34 +1,32 @@
-require 'colorize'
+require 'colorized_string'
 require 'erb'
-require 'rshade/configuration'
-require 'rshade/base'
-require 'rshade/event_serializer'
-require 'rshade/filter/app_filter'
+require 'weakref'
+require 'set'
+require 'observer'
+require 'rshade/config'
+require 'rshade/config/store'
+require 'rshade/event_tree'
+require 'rshade/event_processor'
+require 'rshade/binding_serializer'
+require 'rshade/event_observer'
+require 'rshade/trace_observable'
+require 'rshade/filter/abstract_filter'
+require 'rshade/filter/filter_builder'
+require 'rshade/filter/filter_composition'
+require 'rshade/filter/include_path_filter'
+require 'rshade/filter/exclude_path_filter'
+require 'rshade/filter/variable_filter'
+require 'rshade/filter/default'
 require 'rshade/formatter/string'
 require 'rshade/formatter/json'
 require 'rshade/formatter/file'
 require 'rshade/formatter/html'
 require 'rshade/formatter/stdout'
 require 'rshade/event'
-require 'rshade/event_store'
 require 'rshade/trace'
 require 'rshade/rspec/rspec'
 require 'rshade/version'
 
 
 module RShade
-  APP_TRACE = :app_trace
-  FULL_TRACE = :full_trace
-
-  class << self
-    attr_writer :config
-
-    def config
-      @config ||= Configuration.new
-    end
-
-    def configure
-      yield configuration
-    end
-  end
 end

data/rshade.gemspec

@@ -38,7 +38,7 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency 'colorize'
 
-  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "bundler", "~> 2.2.33"
   spec.add_development_dependency "rake", ">= 12.3.3"
   spec.add_development_dependency "rspec", "~> 3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rshade
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.9
 platform: ruby
 authors:
 - Ivan Lopatin
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-06-25 00:00:00.000000000 Z
+date: 2022-03-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: 2.2.33
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: 2.2.33
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -85,12 +85,21 @@ files:
 - bin/setup
 - html/template.html.erb
 - lib/rshade.rb
-- lib/rshade/base.rb
-- lib/rshade/configuration.rb
+- lib/rshade/binding_serializer.rb
+- lib/rshade/config.rb
+- lib/rshade/config/store.rb
+- lib/rshade/core_extensions/object/reveal.rb
 - lib/rshade/event.rb
-- lib/rshade/event_serializer.rb
-- lib/rshade/event_store.rb
-- lib/rshade/filter/app_filter.rb
+- lib/rshade/event_observer.rb
+- lib/rshade/event_processor.rb
+- lib/rshade/event_tree.rb
+- lib/rshade/filter/abstract_filter.rb
+- lib/rshade/filter/default.rb
+- lib/rshade/filter/exclude_path_filter.rb
+- lib/rshade/filter/filter_builder.rb
+- lib/rshade/filter/filter_composition.rb
+- lib/rshade/filter/include_path_filter.rb
+- lib/rshade/filter/variable_filter.rb
 - lib/rshade/formatter/file.rb
 - lib/rshade/formatter/html.rb
 - lib/rshade/formatter/json.rb
@@ -98,8 +107,8 @@ files:
 - lib/rshade/formatter/string.rb
 - lib/rshade/rails/rails.rb
 - lib/rshade/rspec/rspec.rb
-- lib/rshade/storage.rb
 - lib/rshade/trace.rb
+- lib/rshade/trace_observable.rb
 - lib/rshade/version.rb
 - rshade.gemspec
 - shade.jpg
@@ -112,7 +121,7 @@ metadata:
   homepage_uri: https://github.com/gingray/rshade
   source_code_uri: https://github.com/gingray/rshade
   changelog_uri: https://github.com/gingray/rshade/CHANGELOG.md
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -128,7 +137,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.0.8
-signing_key: 
+signing_key:
 specification_version: 4
 summary: https://github.com/gingray/rshade
 test_files: []

data/lib/rshade/base.rb

@@ -1,13 +0,0 @@
-module RShade
-  class Base
-    def initialize(*args); end
-
-    def self.call(*args)
-      new(*args).call
-    end
-
-    def call
-      raise NotImplementedError
-    end
-  end
-end

data/lib/rshade/configuration.rb

@@ -1,43 +0,0 @@
-module RShade
-  class Configuration
-    RUBY_VERSION_PATTERN = /ruby-[0-9.]*/
-
-    attr_accessor :track_gems, :filter, :formatter
-
-    def initialize
-      @track_gems = Set.new
-    end
-
-    def excluded_paths
-      @excluded_paths ||= begin
-        paths = [ENV['GEM_PATH'].split(':'), parse_ruby_version].flatten.compact
-        paths.reject do |v|
-          track_gems.any? { |gem_name| v.include? gem_name }
-        end
-      end
-    end
-
-    def parse_ruby_version
-      val = RUBY_VERSION_PATTERN.match(ENV['GEM_PATH'])
-      return nil unless val
-
-      val[0]
-    end
-
-    def filter
-      @filter ||= ::RShade::Filter::AppFilter
-    end
-
-    def formatter
-      @formatter ||= ::RShade::Formatter::Stdout
-    end
-
-    def store_dir
-      File.expand_path('../../tmp', __dir__)
-    end
-
-    def root_dir
-      @root_dir ||= File.expand_path('../../', __dir__)
-    end
-  end
-end