rshade 0.1.7 → 0.1.9.1

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

@@ -1,41 +1,30 @@
 module RShade
   module Formatter
-    class Json < ::RShade::Base
-      attr_reader :event_store
-      FILE_NAME = 'stacktrace.json'.freeze
+    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
-        write_to_file(JSON.pretty_generate(arr.sort_by { |item| item[:depth]}))
-        arr
+        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
-        hash = sort_hash(hash)
-        write_to_file(JSON.pretty_generate(hash))
-        hash
-      end
-
-      def write_to_file(data)
-        File.open(File.join(RShade.config.store_dir, FILE_NAME), "w+") do |f|
-          f.write data
-        end
+        sort_hash(hash)
       end
 
       def sort_hash(h)
@@ -58,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/serializer/traversal.rb

@@ -0,0 +1,47 @@
+module RShade
+  module Serializer
+    class Traversal
+      attr_reader :types
+
+      def initialize(custom_types={})
+        @types = default_types.merge(custom_types)
+      end
+
+      def call(hash)
+        new_val = {}
+        hash.each do |name, value|
+          new_val[name] = traverse(value)
+        end
+        new_val
+      end
+
+      def default_types
+        {
+          default: ->(value) { value.to_s },
+          Integer => ->(value) { value },
+          Float => ->(value) { value },
+          Numeric => ->(value) { value },
+          String => ->(value) { value },
+          Hash => ->(value) do
+            hash = {}
+            value.each do |k,v|
+              hash[k] = traverse(v)
+            end
+            hash
+          end,
+          Array => ->(value) do
+            value.map { |item| traverse(item) }
+          end
+        }
+      end
+
+      def traverse(value)
+        klass = value
+        klass = value.class unless value.is_a?(Class)
+        serializer = types[klass]
+        serializer = types[:default] unless serializer
+        serializer.call(value)
+      end
+    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, config)
+      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.7"
+  VERSION = "0.1.9.1"
 end

data/lib/rshade.rb

@@ -1,32 +1,31 @@
-require 'colorize'
-require 'rshade/configuration'
-require 'rshade/base'
-require 'rshade/event_serializer'
-require 'rshade/filter/app_filter'
+require 'colorized_string'
+require 'erb'
+require 'weakref'
+require 'set'
+require 'observer'
+require 'rshade/config'
+require 'rshade/config/store'
+require 'rshade/serializer/traversal'
+require 'rshade/event_tree'
+require 'rshade/event_processor'
+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/formatter/http'
 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