rshade 0.1.6 → 0.1.9

data/lib/rshade/filter/default.rb

@@ -0,0 +1,28 @@
+module RShade
+  module Filter
+    class Default
+      RUBY_VERSION_PATTERN = /ruby-[0-9.]*/
+
+      def self.create
+        new.create
+      end
+
+      def create
+        [create_exclude]
+      end
+
+      def create_exclude
+        filter = ExcludePathFilter.new
+        filter.config do |paths|
+          excluded_paths.each do |path|
+            paths << path
+          end
+        end
+      end
+
+      def excluded_paths
+        [ENV['GEM_PATH'].split(':'), RUBY_VERSION_PATTERN, /internal/].flatten.compact
+      end
+    end
+  end
+end

data/lib/rshade/filter/exclude_path_filter.rb

@@ -0,0 +1,24 @@
+module RShade
+  module Filter
+    class ExcludePathFilter < IncludePathFilter
+      NAME = :exclude_paths
+
+      def name
+        NAME
+      end
+
+      def priority
+        0
+      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/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

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

data/lib/rshade/formatter/html.rb

@@ -0,0 +1,33 @@
+require 'json'
+
+module RShade
+  module Formatter
+    class Html
+      attr_reader :formatter
+      FILE_NAME = 'stacktrace.html'.freeze
+      TEMPLATE = 'html/template.html.erb'
+
+      def initialize(args={})
+        @formatter = args.fetch(:formatter, Json)
+      end
+
+      # @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})
+        write_to_file(content)
+      end
+
+      def write_to_file(data)
+        ::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))
+      end
+    end
+  end
+end

data/lib/rshade/formatter/json.rb

@@ -0,0 +1,59 @@
+module RShade
+  module Formatter
+    class Json
+      attr_reader :event_processor
+
+      # @param [RShade::EventProcessor] event_store
+      def call(event_store)
+        @event_store = event_store
+        flat
+      end
+
+      def flat
+        arr = []
+        event_store.each do |node|
+          arr << item(node.event)
+        end
+        arr.sort_by { |item| item[:level]}
+      end
+
+      def hierarchical
+        hash = {}
+        event_store.each do |node|
+          depth = node.level
+          ref = hash_iterate(hash, depth)
+          ref[:data] = item(node)
+        end
+        sort_hash(hash)
+      end
+
+      def sort_hash(h)
+        {}.tap do |h2|
+          h.sort.each do |k,v|
+            h2[k] = v.is_a?(Hash) ? sort_hash(v) : v
+          end
+        end
+      end
+
+      def hash_iterate(hash, depth)
+        (0..depth).each do |lvl|
+          unless hash[:inner]
+            hash[:inner] = {}
+          end
+          hash = hash[:inner]
+        end
+        hash
+      end
+
+      def item(value)
+        {
+          class: value.klass.to_s,
+          method_name: value.method_name,
+          full_path: "#{value.path}:#{value.lineno}",
+          level: value.depth,
+          vars: value.vars
+        }
+      end
+    end
+  end
+end

data/lib/rshade/formatter/stdout.rb

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

data/lib/rshade/formatter/string.rb

@@ -0,0 +1,36 @@
+module RShade
+  module Formatter
+    class String
+      ROOT_SEP = "---\n"
+
+      def initialize(opts= {})
+      end
+
+      # @param [RShade::EventProcessor] event_store
+      def call(event_store)
+        buffer = StringIO.new
+        event_store.each_with_index do |node, idx|
+          depth = node.level
+          event = node.value
+          if depth == 1
+            buffer << ROOT_SEP
+            next
+          end
+          next unless event
+          buffer.write line(idx, event, node.vlevel)
+        end
+        buffer.string
+      end
+
+      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
+end

data/lib/rshade/{rspec.rb → rspec/rspec.rb}

@@ -2,15 +2,13 @@ module RShade
   REPORTS = []
 
   module RSpecHelper
-    def rshade_reveal(type = ::RShade::APP_TRACE, options = {})
+    def rshade_reveal(options = {})
       raise 'No block given' unless block_given?
-
-      trace = Trace.new
-      trace.reveal(options) do
+      options.merge!(formatter: Formatter::String) { |_key,v1, _v2| v1 }
+      result = Trace.reveal(options) do
         yield
       end
-
-      REPORTS.push trace.show(type)
+      REPORTS.push result.show
     end
   end
 end

data/lib/rshade/trace.rb

@@ -1,69 +1,34 @@
 module RShade
   class Trace
-    attr_accessor :source_tree, :options
-    EVENTS = %i[call return].freeze
-
-    def initialize
-      @source_tree = SourceNode.new(nil)
-      @tp = TracePoint.new(*EVENTS, &method(:process_trace))
-      @stack = [@source_tree]
-    end
-
-    def reveal(options = {})
-      return unless block_given?
-
-      @tp.enable
-      yield
-    ensure
-      @tp.disable
+    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 show(type = ::RShade::APP_TRACE)
-      return show_app_trace if type == ::RShade::APP_TRACE
-
-      show_full_trace
+    def self.reveal(config=nil, &block)
+      new(config).reveal(&block)
     end
 
-    def show_full_trace(tree = nil)
-      buffer = StringIO.new
-      tree ||= source_tree
-      tree.pre_order_traverse do |node, depth|
-        if node.root?
-          buffer << "---\n"
-          next
-        end
-
-        buffer << "#{'  ' * depth} #{node.value.pretty}\n" if node.value
-      end
-      puts buffer.string
+    def reveal(&block)
+      processor = EventProcessor.new(@event_store)
+      observer = EventObserver.new(config, processor)
+      observable = RShade::TraceObservable.new([observer], config)
+      observable.reveal &block
+      self
     end
 
-    def show_app_trace
-      clone = source_tree.clone_by do |node|
-        next true if node.root?
-
-        node.value.app_code?
-      end
-      show_full_trace(clone)
+    def show
+      config.formatter.call(event_store)
     end
 
-    def process_trace(tp)
-      if tp.event == :call
-        parent = @stack.last
-        vars = {}
-        tp.binding.local_variables.each do |var|
-          vars[var] = tp.binding.local_variable_get var
-        end
-        hash = { level: @stack.size, path: tp.path, lineno: tp.lineno, klass: tp.defined_class, method_name: tp.method_id, vars: vars }
-        node = SourceNode.new(Source.new(hash))
-        node.parent = parent
-        parent << node
-        @stack.push node
-      end
-
-      if tp.event == :return && @stack.size > 1
-        @stack.pop
-      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.6"
+  VERSION = "0.1.9"
 end

data/lib/rshade.rb

@@ -1,26 +1,32 @@
-require 'colorize'
-require 'rshade/configuration'
-require 'rshade/source'
-require 'rshade/tree'
-require 'rshade/source_node'
+require 'colorized_string'
+require 'erb'
+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/trace'
-require 'rshade/rspec'
+require 'rshade/rspec/rspec'
 require 'rshade/version'
 
 
 module RShade
-  APP_TRACE = :app_trace
-  FULL_TRACE = :full_trace
-
-  class << self
-    attr_writer :config
-
-    def configuration
-      @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 "rake", "~> 10.0"
+  spec.add_development_dependency "bundler", "~> 2.2.33"
+  spec.add_development_dependency "rake", ">= 12.3.3"
   spec.add_development_dependency "rspec", "~> 3.0"
 end

data/todo.md

@@ -0,0 +1,8 @@
+1. Should I use rails way organizing module/file naming or not?
+2. Reduce global state usage
+3. Problem with stack deep
+4. Problem when have binary values error in serialization (Encoding problems)
+5. Make filter while tracing that will be more efficient
+6. sort depth and than replace values
+7. tree not working bcz of vars serialization
+8. Some classes in Rails can't serialize safely produce StackTraceTooDeep