rshade 0.1.9.1 → 0.2.1

data/lib/rshade/filter/exclude_path_filter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RShade
   module Filter
     class ExcludePathFilter < IncludePathFilter
@@ -13,13 +15,13 @@ module RShade
 
       def call(event)
         event_path = event.path
-        !paths.any? do |path|
+        paths.none? 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
+end

data/lib/rshade/filter/filter_builder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RShade
   module Filter
     class FilterBuilder
@@ -18,11 +20,20 @@ module RShade
         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)
+        arg1 = if arg1.is_a?(Array)
+                 traverse(arg1)
+               else
+                 RShade::Filter::FilterComposition.new(arg1)
+               end
+
+        arg2 = if arg2.is_a?(Array)
+                 traverse(arg2)
+               else
+                 RShade::Filter::FilterComposition.new(arg2)
+               end
 
         RShade::Filter::FilterComposition.new(op, arg1, arg2)
       end
     end
   end
-end
+end

data/lib/rshade/filter/filter_composition.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RShade
   module Filter
     class FilterComposition
@@ -5,53 +7,55 @@ module RShade
       AND_OP = :and
       OR_OP = :or
       UNARY_OP = :unary
-      attr_reader :op, :left, :right, :parent
+      attr_reader :value, :left, :right
       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
 
+      # rubocop:disable Metrics/CyclomaticComplexity
       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
+      # rubocop:enable Metrics/CyclomaticComplexity
 
       def each(&block)
-        if left&.respond_to?(:each)
-          left&.each(&block)
-        else
-          yield left
-        end
+        yield value unless left && right
+        left&.each(&block)
+        right&.each(&block)
+      end
 
-        if right&.respond_to?(:each)
-          right&.each(&block)
-        else
-          yield right
+      def config_filter(type, &block)
+        filter = find do |f|
+          f.is_a? type
         end
+        filter&.config(&block)
       end
 
-      def config_filter(type, &block)
-        filter = find do |filter|
-          filter.is_a? type
+      # 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
-        filter.config(&block) if filter
+      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
@@ -6,6 +8,7 @@ module RShade
       NAME = :include_paths
 
       def initialize
+        super
         @paths = []
       end
 
@@ -22,6 +25,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 +35,7 @@ module RShade
       end
 
       private
+
       def str?(str, event_path)
         event_path.include?(str)
       end
@@ -40,4 +45,4 @@ module RShade
       end
     end
   end
-end
+end

data/lib/rshade/filter/variable_filter.rb

@@ -1,10 +1,14 @@
+# frozen_string_literal: true
+
 module RShade
   module Filter
     class VariableFilter < AbstractFilter
       attr_reader :matchers
+
       NAME = :variable_filter
 
       def initialize
+        super
         @matchers = []
       end
 
@@ -30,4 +34,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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RShade
+  module Formatter
+    module Stack
+      class String
+        attr_reader :colorize
+
+        ROOT_SEP = "---\n"
+
+        def initialize(colorize: true)
+          @colorize = colorize
+        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
+
+        private
+
+        # @param [RShade::StackFrame] frame
+        def line(line_idx, frame, depth)
+          source_location = apply_color("(#{frame.source_location[:path]}:#{frame.source_location[:line]})", :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 = apply_color(var_str, :blue)
+          "#{'  ' * depth}[frame: #{line_idx}]#{source_location} => local vars: (#{colorized_var_str})\n"
+        end
+
+        def apply_color(str, color)
+          return str unless colorize
+
+          ColorizedString[str].colorize(color)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# 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.write(::File.join(RShade::Config.store_dir, FILE_NAME), data)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# 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.write(::File.join(RShade::Config.store_dir, FILE_NAME), data)
+        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,60 @@
+# 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.map do |node|
+            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(hash)
+          {}.tap do |h2|
+            hash.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
+        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,16 @@
+# frozen_string_literal: true
+
 module RShade
+  # rubocop:disable Style/MutableConstant
   REPORTS = []
+  # rubocop:enable Style/MutableConstant
 
   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

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module RShade
   module Serializer
     class Traversal
       attr_reader :types
 
-      def initialize(custom_types={})
+      def initialize(custom_types = {})
         @types = default_types.merge(custom_types)
       end
 
@@ -17,31 +19,31 @@ module RShade
 
       def default_types
         {
-          default: ->(value) { value.to_s },
+          default: lambda(&:to_s),
           Integer => ->(value) { value },
           Float => ->(value) { value },
           Numeric => ->(value) { value },
           String => ->(value) { value },
-          Hash => ->(value) do
+          Hash => lambda do |value|
             hash = {}
-            value.each do |k,v|
+            value.each do |k, v|
               hash[k] = traverse(v)
             end
             hash
           end,
-          Array => ->(value) do
+          Array => lambda do |value|
             value.map { |item| traverse(item) }
           end
         }
       end
 
       def traverse(value)
-        klass = value
+        klass = Class
         klass = value.class unless value.is_a?(Class)
         serializer = types[klass]
-        serializer = types[:default] unless serializer
+        serializer ||= types[:default]
         serializer.call(value)
       end
     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: 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,61 @@
+# 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: 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: value,
+          type: type.to_s
+        }
+      end
+      hash = { source_location: source_location, local_vars: local_vars, source: {},
+               receiver_variables: receiver_variables }
+      new(hash)
+    end
+
+    def to_s
+      "#{source_location} - #{local_vars} - #{source}"
+    end
+
+    private
+
+    def fetch(key)
+      @hash[key]
+    end
+  end
+end