rshade 0.1.9 → 0.2.0

data/lib/rshade/filter/filter_composition.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RShade
   module Filter
     class FilterComposition
@@ -5,53 +7,53 @@ module RShade
       AND_OP = :and
       OR_OP = :or
       UNARY_OP = :unary
-      attr_reader :op, :left, :right, :parent
+      attr_reader :value, :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
+      def initialize(value, left = nil, right = nil)
+        @value = value
         @left = left
         @right = right
       end
 
       def call(event)
-        case op
+        case value
         when UNARY_OP
-          return left&.call(event)
+          left&.call(event)
         when AND_OP
-          return left&.call(event) && right&.call(event)
+          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
+          left&.call(event) || right&.call(event)
         else
-          raise 'undefined op'
+          value.call(event)
         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
+        yield value unless left && right
+        left&.each(&block)
+        right&.each(&block)
       end
 
       def config_filter(type, &block)
         filter = find do |filter|
           filter.is_a? type
         end
-        filter.config(&block) if filter
+        filter&.config(&block)
+      end
+
+      # for debug purposes, show each filter and result of evaluation
+      def filter_results(event)
+        each_with_object([]) do |filter, arr|
+          arr << [filter, filter.call(event)]
+        end
+      end
+
+      def self.build(arr)
+        ::RShade::Filter::FilterBuilder.build(arr)
       end
     end
   end
-end
+end

data/lib/rshade/filter/include_path_filter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RShade
   module Filter
     class IncludePathFilter < AbstractFilter
@@ -22,6 +24,7 @@ module RShade
         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
@@ -31,6 +34,7 @@ module RShade
       end
 
       private
+
       def str?(str, event_path)
         event_path.include?(str)
       end
@@ -40,4 +44,4 @@ module RShade
       end
     end
   end
-end
+end

data/lib/rshade/filter/variable_filter.rb

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 module RShade
   module Filter
     class VariableFilter < AbstractFilter
       attr_reader :matchers
+
       NAME = :variable_filter
 
       def initialize
@@ -30,4 +33,4 @@ module RShade
       end
     end
   end
-end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RShade
+  module Formatter
+    module Stack
+      class Json
+        attr_reader :filepath, :pretty
+
+        def initialize(filepath:, pretty: false)
+          @filepath = filepath
+          @pretty = pretty
+        end
+
+        # @param [Array<RShade::StackFrame>] stack_frames
+        def call(stack_frames)
+          payload = stack_frames.map.with_index do |frame, idx|
+            serialize(idx, frame)
+          end
+
+          File.open(filepath, 'a+') do |file|
+            record = {
+              time: Time.now.getutc,
+              thread_id: Thread.current,
+              thread_list: Thread.list,
+              frames: payload
+            }
+            file.puts(convert_to_json(record, pretty))
+          end
+        end
+
+        private
+
+        def convert_to_json(object, pretty)
+          return JSON.pretty_generate(object) if pretty
+
+          JSON.generate(object)
+        end
+
+        # @param [RShade::StackFrame] frame
+        def serialize(idx, frame)
+          {
+            frame: idx,
+            source_location: "#{frame.source_location[:path]}:#{frame.source_location[:line]}",
+            local_variables: frame.local_vars,
+            receiver_variables: frame.receiver_variables
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RShade
+  module Formatter
+    module Stack
+      class Stdout < String
+        def call(stack)
+          puts super(stack)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RShade
+  module Formatter
+    module Stack
+      class String
+        ROOT_SEP = "---\n"
+
+        def initialize(opts = {}); end
+
+        # @param [RShade::EventProcessor] stack
+        def call(stack)
+          buffer = StringIO.new
+          stack.each_with_index do |frame, idx|
+            if idx.zero?
+              buffer << ROOT_SEP
+              next
+            end
+            next unless frame
+
+            buffer.write line(idx, frame, idx)
+          end
+          buffer.string
+        end
+
+        # @param [RShade::StackFrame] frame
+        def line(line_idx, frame, depth)
+          source_location = ColorizedString["(#{frame.source_location[:path]}:#{frame.source_location[:line]})"].colorize(:green)
+          var_str = frame.local_vars.map do |_, val|
+            var_name = val[:name]
+            var_value = val[:value]
+            var_type = val[:type]
+            "#{var_type} #{var_name} => (#{var_value})"
+          end.join(', ')
+          colorized_var_str = ColorizedString[var_str].colorize(:blue)
+          "#{'  ' * depth}[frame: #{line_idx}]#{source_location} => local vars: (#{colorized_var_str})\n"
+        end
+      end
+    end
+  end
+end

data/lib/rshade/formatter/trace/file.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RShade
+  module Formatter
+    module Trace
+      class File
+        attr_reader :formatter
+
+        FILE_NAME = 'stacktrace.json'
+
+        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
+end

data/lib/rshade/formatter/trace/html.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module RShade
+  module Formatter
+    module Trace
+      class Html
+        attr_reader :formatter
+
+        FILE_NAME = 'stacktrace.html'
+        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
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RShade
+  module Formatter
+    module Trace
+      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|
+            hash[:inner] = {} unless hash[:inner]
+            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
+end

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

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

data/lib/rshade/formatter/trace/string.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RShade
+  module Formatter
+    module Trace
+      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_value = value.return_value || {}
+          returned_str = "#{returned_value[:type]} #{returned_value[:value]}"
+          returned = ColorizedString["=> |#{returned_str}|"].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)
+          var_str = vars.map do |_, val|
+            var_name = val[:name]
+            var_value = val[:value]
+            var_type = val[:type]
+            "#{var_type} #{var_name} => (#{var_value})"
+          end.join(', ')
+          "#{'  ' * depth}#{line_idx}#{class_method}(#{var_str}) #{returned} -> #{full_path}\n"
+        end
+      end
+    end
+  end
+end

data/lib/rshade/rspec/rspec.rb

@@ -1,13 +1,14 @@
+# frozen_string_literal: true
+
 module RShade
-  REPORTS = []
+  REPORTS = [].freeze
 
   module RSpecHelper
-    def rshade_reveal(options = {})
+    def rshade_reveal(options = {}, &block)
       raise 'No block given' unless block_given?
-      options.merge!(formatter: Formatter::String) { |_key,v1, _v2| v1 }
-      result = Trace.reveal(options) do
-        yield
-      end
+
+      options.merge!(formatter: Formatter::String) { |_key, v1, _v2| v1 }
+      result = Trace.reveal(options, &block)
       REPORTS.push result.show
     end
   end

data/lib/rshade/serializer/traversal.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+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: lambda(&:to_s),
+          Integer => ->(value) { value },
+          Float => ->(value) { value },
+          Numeric => ->(value) { value },
+          String => ->(value) { value },
+          Hash => lambda do |value|
+            hash = {}
+            begin
+              value.each do |k, v|
+                hash[k] = traverse(v)
+              end
+            rescue Exception => e
+              binding.pry
+            end
+
+            hash
+          end,
+          Array => lambda do |value|
+            value.map { |item| traverse(item) }
+          end
+        }
+      end
+
+      def traverse(value)
+        klass = Class
+        klass = value.class unless value.is_a?(Class)
+        serializer = types[klass]
+        serializer ||= types[:default]
+        serializer.call(value)
+      end
+    end
+  end
+end

data/lib/rshade/stack.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RShade
+  class Stack
+    attr_reader :config
+
+    def initialize(config: nil, registry: ::RShade::Config::Registry.instance)
+      @config = config || registry.default_stack_config
+    end
+
+    def self.trace(config: nil)
+      new(config:).trace
+    end
+
+    def trace
+      config.exclude_gems!
+      result = binding.callers.drop(2).map do |bind|
+        frame = StackFrame.from_binding(bind)
+        next nil unless config.filter.call(frame)
+
+        frame
+      end.compact.reverse
+      config.formatter.call(result)
+    end
+  end
+end

data/lib/rshade/stack_frame.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RShade
+  # nodoc
+  class StackFrame
+    attr_reader :hash
+
+    def initialize(hash)
+      @hash = hash
+    end
+
+    %i[source_location source local_vars receiver_variables].each do |method_name|
+      define_method method_name do
+        fetch method_name
+      end
+    end
+
+    def path
+      source_location[:path]
+    end
+
+    # @param [Binding] binding_frame
+    def self.from_binding(binding_frame)
+      source_location = {
+        path: binding_frame.source_location[0],
+        line: binding_frame.source_location[1]
+      }
+      local_vars = binding_frame.local_variables.each_with_object({}) do |var_name, memo|
+        value = binding_frame.local_variable_get(var_name)
+        type = value.is_a?(Class) ? value : value.class
+        memo[var_name] = {
+          name: var_name,
+          value:,
+          type: type.to_s
+        }
+      end
+      receiver_variables = binding_frame.receiver.instance_variables.each_with_object({}) do |var_name, memo|
+        value = binding_frame.receiver.instance_variable_get(var_name)
+        type = value.is_a?(Class) ? value : value.class
+        memo[var_name] = {
+          name: var_name,
+          value:,
+          type: type.to_s
+        }
+      end
+      hash = { source_location:, local_vars:, source: {}, receiver_variables: }
+      new(hash)
+    end
+
+    def to_s
+      "#{source_location} - #{local_vars} - #{source}"
+    end
+
+    private
+
+    def fetch(key)
+      @hash[key]
+    end
+  end
+end

data/lib/rshade/trace.rb

@@ -1,22 +1,24 @@
+# frozen_string_literal: true
+
 module RShade
   class Trace
     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(config=nil, &block)
+    def self.reveal(config = nil, &block)
       new(config).reveal(&block)
     end
 
     def reveal(&block)
-      processor = EventProcessor.new(@event_store)
+      processor = EventProcessor.new(event_store, config)
       observer = EventObserver.new(config, processor)
       observable = RShade::TraceObservable.new([observer], config)
-      observable.reveal &block
+      observable.reveal(&block)
       self
     end
 
@@ -25,8 +27,9 @@ module RShade
     end
 
     private
+
     def fetch_config(config)
-      config = config || ::RShade::Config.default
+      config ||= ::RShade::Config.default
       config = config.value if config.is_a?(::RShade::Config)
       config
     end

data/lib/rshade/trace_observable.rb

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 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]
 
@@ -27,6 +30,7 @@ module RShade
     end
 
     private
+
     # more info https://rubyapi.org/3.1/o/tracepoint
     # @param [TracePoint] tp
     def process(tp)
@@ -34,6 +38,7 @@ module RShade
       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

data/lib/rshade/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RShade
-  VERSION = "0.1.9"
+  VERSION = '0.2.0'
 end