rshade 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: efdbfc08fca88589c49b580abbbeb36687b68986e365291c2c4758633b33943d
-  data.tar.gz: 78e8147a5539bb79216281763274c676d916729b62af681b2811caa1772f7031
+  metadata.gz: e267f5e11b2c8624bc38c88c031a12e9b252b5581b803fe4076f40d532d75c81
+  data.tar.gz: 153c3b896ce3701be9bc26a9501f987220e23c8ebb4e253d42a0968cf2e43709
 SHA512:
-  metadata.gz: 39fad4c1cb0663e510aaee89100090a10e689880da9f2fb2422fc404094337bad4bcbd5bb72a96270b284a3709392d4d9879cb1410d8f912d8e55db2962a8e4f
-  data.tar.gz: de5d785cfe183f5a7109aeebb128086e0173ce126788165b7dc18b818de066909830e628b5322c84ff6c9655696cb34cc8c7d289aafff036965f6a7caeb7bda0
+  metadata.gz: a0c00f405183f7f3a5a33d7e9fd9b5bf4cc4692aabc6cf7400bc32b4fb3e704c0e94b583da98447a868f5c7079b290df835e8f0ed75d8ec66544404748df5466
+  data.tar.gz: 273df7e4c8b3107bb8fb5a09c1ef36c8489caf2f5e87550aaa9631b79bd0cdc3a7f4a5641db2f38107e6c28203e0f21a7a51f4e2e47d5da47ab7d3f5d1d89e66

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rshade (0.2.1)
+    rshade (0.2.2)
       binding_of_caller
       colorize
       prism

data/README.md

@@ -16,6 +16,14 @@ gem install rshade
 Simple wrap code that you want to check in to block and it will pretty print all of the calls which was made in this block with pointing line of executions, variables what was pass
 inside methods and variables what was return
 ```ruby
+# config
+::RShade::Config::Registry.instance.trace_config do |config|
+   config.exclude_gems!
+   filepath = File.join(Rails.root, 'log', 'rshade-trace.json.log')
+   config.formatter!(:json, { filepath: filepath, pretty: false })
+end
+
+# execute
 RShade::Trace.reveal do  
   #your code here
 end.show
@@ -34,25 +42,41 @@ change this behaviour or add your own filter. Even when some piece of code are n
 
 ### Configuration
 ```ruby
-config = ::RShade::Config.default
-
-RShade::Trace.reveal(config) do
-end.show
+::RShade::Config::Registry.instance.trace_config do |config|
+   # exclude gems 
+   config.exclude_gems!
+   # path where save output
+   filepath = File.join(Rails.root, 'log', 'rshade-trace.json.log')
+   # output can be json or stdout
+   config.formatter!(:json, { filepath: filepath, pretty: false })
+end
 ```
 ### Filters
 Filters by default represent by expression `(include_path or variable_match) or (not exclude_path)`
 Filters can be chained like:
 ```ruby
-config = ::RShade::Config.default.include_paths { |paths| paths << /devise/ }
-                                  .exclude_paths { |paths| paths << /warden/ } 
-                                  .match_variable { |name, value| name == :current_user }
+::RShade::Config::Registry.instance.trace_config do |config|
+   config.filter!(RShade::Filter::VariableFilter) do |name, value|
+      name == :current_user
+   end
+   config.filter!(::RShade::Filter::ExcludePathFilter) do |paths|
+      paths.concat(/gems/)
+   end
+   config.filter!(::RShade::Filter::IncludePathFilter) do |paths|
+      paths.concat(/devise/)
+   end
+end
 ```
 #### Filter by path include
 `paths` - is array which accept regex or string
 ```ruby
-config = ::RShade::Config.default.include_paths { |paths| paths << /devise/ }
+::RShade::Config::Registry.instance.trace_config do |config|
+   config.filter!(::RShade::Filter::IncludePathFilter) do |paths|
+      paths.concat(/devise/)
+   end
+end
 
-RShade::Trace.reveal(config) do
+RShade::Trace.reveal do
    #your code
 end.show
 
@@ -60,9 +84,13 @@ end.show
 #### Filter by path exclude
 `paths` - is array which accept regex or string
 ```ruby
-config = ::RShade::Config.default.exclude_paths { |paths| paths << /devise/ }
+::RShade::Config::Registry.instance.trace_config do |config|
+   config.filter!(::RShade::Filter::ExcludePathFilter) do |paths|
+      paths.concat(/gems/)
+   end
+end
 
-RShade::Trace.reveal(config) do
+RShade::Trace.reveal do
    #your code
 end.show
 ```
@@ -71,9 +99,14 @@ end.show
 `name` - represent variable name as symbol
 `value` - actual variable value
 ```ruby
-config = ::RShade::Config.default.match_variable { |name, value| name == :current_user }
 
-RShade::Trace.reveal(config) do
+::RShade::Config::Registry.instance.trace_config do |config|
+   config.filter!(RShade::Filter::VariableFilter) do |name, value|
+      name == :current_user
+   end
+end
+
+RShade::Trace.reveal do
    #your code
 end.show
 ```
@@ -108,6 +141,12 @@ Config
    config.exclude_gems!
    filepath = File.join(Rails.root, 'log', 'rshade-stack.json.log')
    config.formatter!(:json, { filepath: filepath, pretty: false })
+
+   config.serializer!({
+                              ActionDispatch::Request => ->(value) do
+                                 "#{value.to_s} -> #{value.method} -> #{value.path}"
+                              end
+                      })
 end
 ```
 

data/lib/rshade/config/event_store.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RShade
+  class Config
+    class EventStore
+      attr_reader :filter, :formatter, :tp_events, :variable_serializer
+
+      DEFAULT_FORMATTER = {
+        json: ::RShade::Formatter::Trace::Json,
+        stdout: ::RShade::Formatter::Trace::Stdout
+      }.freeze
+
+      def self.default
+        new.exclude_gems!
+      end
+
+      # @param [Array<Symbol>] tp_events
+      # @param [RShade::Formatter::Trace::Stdout] formatter
+      # @param [RShade::Filter::FilterComposition] filter
+      # @param [Hash] serializers
+      def initialize(tp_events: %i[call return], formatter: RShade::Formatter::Trace::Stdout.new,
+                     filter: default_filter_composition,
+                     serializers: {})
+        @filter = filter
+        @formatter = formatter
+        @tp_events = tp_events
+        @variable_serializer = serializers
+      end
+
+      def tp_events!(tp_events)
+        @tp_events = tp_events
+        self
+      end
+
+      def serializer!(hash)
+        variable_serializer.merge!(hash)
+        self
+      end
+
+      def filter!(filter_type, &block)
+        filter.filter(filter_type, &block)
+        self
+      end
+
+      def formatter!(formatter, opts = {})
+        @formatter = formatter.is_a?(Symbol) ? set_symbol_formatter(formatter, opts) : formatter
+        self
+      end
+
+      def exclude_gems!
+        filter!(::RShade::Filter::ExcludePathFilter) do |paths|
+          paths.concat(RShade::Utils.default_excluded_path)
+        end
+        self
+      end
+
+      private
+
+      def set_symbol_formatter(type, opts)
+        formatter_class = DEFAULT_FORMATTER[type]
+        return formatter_class unless formatter_class
+
+        @formatter = formatter_class.new(**opts)
+      end
+
+      def default_filter_composition
+        variable_filter = RShade::Filter::VariableFilter.new
+        include_filter = RShade::Filter::IncludePathFilter.new
+        exclude_filter = RShade::Filter::ExcludePathFilter.new
+
+        RShade::Filter::FilterBuilder.build([:or,
+                                             [:or, variable_filter, include_filter], exclude_filter])
+      end
+    end
+  end
+end

data/lib/rshade/config/registry.rb

@@ -6,6 +6,9 @@ module RShade
       include Singleton
       attr_reader :map, :mutex
 
+      DEFAULT_EVENT_STORE = :event_store_default
+      DEFAULT_STACK_STORE = :stack_store_default
+
       def initialize
         @map = {}
         @mutex = Mutex.new
@@ -15,7 +18,7 @@ module RShade
       def default_stack_config
         val = nil
         mutex.synchronize do
-          val = map[:store_default]
+          val = map[DEFAULT_STACK_STORE]
         end
         val
       end
@@ -25,14 +28,38 @@ module RShade
         mutex.synchronize do
           val = ::RShade::Config::StackStore.new
           block.call(val)
-          map[:store_default] = val
+          map[DEFAULT_STACK_STORE] = val
+        end
+        val
+      end
+
+      def default_trace_config
+        val = nil
+        mutex.synchronize do
+          val = map[DEFAULT_EVENT_STORE]
+        end
+        val
+      end
+
+      def trace_config(&block)
+        val = nil
+        mutex.synchronize do
+          val = ::RShade::Config::EventStore.new
+          block.call(val)
+          map[DEFAULT_EVENT_STORE] = val
         end
         val
       end
 
       def defaults
         mutex.synchronize do
-          map[:store_default] = ::RShade::Config::StackStore.new
+          stack_store = ::RShade::Config::StackStore.new
+          stack_store.exclude_gems!
+          map[DEFAULT_STACK_STORE] = stack_store
+
+          event_store = ::RShade::Config::EventStore.new
+          event_store.exclude_gems!
+          map[DEFAULT_EVENT_STORE] = event_store
         end
       end
     end

data/lib/rshade/config/stack_store.rb

@@ -3,29 +3,30 @@
 module RShade
   class Config
     class StackStore
-      attr_reader :filter, :formatter, :custom_serializers
+      attr_reader :filter, :formatter, :variable_serializer
 
       DEFAULT_FORMATTER = {
         json: ::RShade::Formatter::Stack::Json,
         stdout: ::RShade::Formatter::Stack::Stdout
       }.freeze
 
-      # @param [Hash] options
-      # @option options [::RShade::Filter::FilterComposition] :filter_composition
-      # @option options [#call(event_store)] :formatter
-      def initialize(options = {})
-        @filter = options.fetch(:filter, default_filter_composition)
-        @formatter = options.fetch(:formatter, ::RShade::Formatter::Stack::Stdout.new)
-        @custom_serializers = options.fetch(:custom_serializers, {})
+      # @param [RShade::Formatter::Stack::Stdout] formatter
+      # @param [RShade::Filter::FilterComposition] filter
+      # @param [Hash] serializers
+      def initialize(formatter: RShade::Formatter::Stack::Stdout.new, filter: default_filter_composition,
+                     serializers: {})
+        @filter = filter
+        @formatter = formatter
+        @variable_serializer = ::RShade::Serializer::Traversal.new(serializers)
       end
 
-      def add_custom_serializers(hash)
-        custom_serializers.merge!(hash)
+      def serializer!(hash)
+        variable_serializer.merge!(hash)
         self
       end
 
-      def config_filter(filter_type, &block)
-        filter.config_filter(filter_type, &block)
+      def filter!(filter_type, &block)
+        filter.filter(filter_type, &block)
         self
       end
 
@@ -35,8 +36,8 @@ module RShade
       end
 
       def exclude_gems!
-        config_filter(::RShade::Filter::ExcludePathFilter) do |paths|
-          paths.concat(RShade::Config.default_excluded_path)
+        filter!(::RShade::Filter::ExcludePathFilter) do |paths|
+          paths.concat(RShade::Utils.default_excluded_path)
         end
         self
       end

data/lib/rshade/core_extensions/object/reveal.rb

@@ -5,7 +5,7 @@ class Object
   def reveal(method_name = nil, **opts, &block)
     if method_name
       @__cache_rshade_reveal ||= {}
-      config = opts.fetch(:config, ::RShade::Config.default)
+      config = opts.fetch(:config, ::RShade::Config::Registry.instance.default_trace_config)
       @__cache_rshade_reveal[method_name] = config
       instance_eval do
         def method_added(name)
@@ -21,7 +21,7 @@ class Object
           origin_method = instance_method(name)
           define_method(name) do |*args, &fn|
             val = nil
-            trace = ::RShade::Trace.reveal(config) do
+            trace = ::RShade::Trace.reveal(config: config) do
               val = origin_method.bind(self).call(*args, &fn)
             end
             trace.show

data/lib/rshade/event_observer.rb

@@ -4,7 +4,7 @@ module RShade
   class EventObserver
     attr_reader :event_processor, :config
 
-    # @param [RShade::Config::Store] config
+    # @param [RShade::Config::EventStore] config
     # @param [RShade::EventProcessor] event_store
     def initialize(config, event_processor)
       @event_processor = event_processor
@@ -41,7 +41,7 @@ module RShade
     end
 
     def pass?(event)
-      config.filter_composition.call(event)
+      config.filter.call(event)
     end
   end
 end

data/lib/rshade/event_processor.rb

@@ -7,7 +7,7 @@ module RShade
 
     def initialize(store, config)
       @store = store
-      custom_serializers = config.custom_serializers
+      custom_serializers = config.variable_serializer
       @serializer = ::RShade::Serializer::Traversal.new(custom_serializers)
     end
 

data/lib/rshade/filter/filter_composition.rb

@@ -39,7 +39,7 @@ module RShade
         right&.each(&block)
       end
 
-      def config_filter(type, &block)
+      def filter(type, &block)
         filter = find do |f|
           f.is_a? type
         end

data/lib/rshade/filter/variable_filter.rb

@@ -22,8 +22,8 @@ module RShade
 
       def call(event)
         matchers.each do |match|
-          event.vars.each do |name, value|
-            return true if match.call(name, value)
+          event.vars.each do |name, hash|
+            return true if match.call(name, hash[:value])
           end
         end
         false

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

@@ -4,7 +4,7 @@ module RShade
   module Formatter
     module Stack
       class Json
-        attr_reader :filepath, :pretty
+        attr_reader :filepath, :pretty, :variable_serializer
 
         def initialize(filepath:, pretty: false)
           @filepath = filepath
@@ -12,9 +12,9 @@ module RShade
         end
 
         # @param [Array<RShade::StackFrame>] stack_frames
-        def call(stack_frames)
+        def call(stack_frames, variable_serializer: nil)
           payload = stack_frames.map.with_index do |frame, idx|
-            serialize(idx, frame)
+            serialize(idx, frame, variable_serializer)
           end
 
           File.open(filepath, 'a+') do |file|
@@ -37,12 +37,14 @@ module RShade
         end
 
         # @param [RShade::StackFrame] frame
-        def serialize(idx, frame)
+        def serialize(idx, frame, variable_serializer)
+          local_vars = variable_serializer.nil? ? frame.local_vars : variable_serializer.call(frame.local_vars)
+          receiver_variables = variable_serializer.call(frame.receiver_variables) unless variable_serializer.nil?
           {
             frame: idx,
             source_location: "#{frame.source_location[:path]}:#{frame.source_location[:line]}",
-            local_variables: frame.local_vars,
-            receiver_variables: frame.receiver_variables
+            local_variables: local_vars,
+            receiver_variables: receiver_variables
           }
         end
       end

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

@@ -4,7 +4,7 @@ module RShade
   module Formatter
     module Stack
       class Stdout < String
-        def call(stack)
+        def call(stack_frames, variable_serializer: nil)
           puts super
         end
       end

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

@@ -12,10 +12,10 @@ module RShade
           @colorize = colorize
         end
 
-        # @param [RShade::EventProcessor] stack
-        def call(stack)
+        # @param [RShade::EventProcessor] stack_frames
+        def call(stack_frames, variable_serializer: nil)
           buffer = StringIO.new
-          stack.each_with_index do |frame, idx|
+          stack_frames.each_with_index do |frame, idx|
             if idx.zero?
               buffer << ROOT_SEP
               next

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

@@ -24,11 +24,11 @@ module RShade
         end
 
         def write_to_file(data)
-          ::File.write(::File.join(RShade::Config.store_dir, FILE_NAME), data)
+          ::File.write(::File.join(RShade::Utils.store_dir, FILE_NAME), data)
         end
 
         def template
-          @template ||= ::File.read(::File.join(::RShade::Config.root_dir, TEMPLATE))
+          @template ||= ::File.read(::File.join(::RShade::Utils.root_dir, TEMPLATE))
         end
       end
     end

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

@@ -4,53 +4,43 @@ module RShade
   module Formatter
     module Trace
       class Json
-        attr_reader :event_processor
+        attr_reader :filepath, :pretty
 
-        # @param [RShade::EventProcessor] event_store
-        def call(event_store)
-          @event_store = event_store
-          flat
+        def initialize(filepath:, pretty: false)
+          @filepath = filepath
+          @pretty = pretty
         end
 
-        def flat
-          arr = event_store.map do |node|
-            item(node.event)
+        # @param [RShade::EventProcessor] event_store
+        def call(event_store)
+          ::File.open(filepath, 'a+') do |file|
+            file.puts(convert_to_json(flat(event_store), pretty))
           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
+        private
 
-        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
+        def convert_to_json(object, pretty)
+          return JSON.pretty_generate(object) if pretty
+
+          JSON.generate(object)
         end
 
-        def hash_iterate(hash, depth)
-          (0..depth).each do |_lvl|
-            hash[:inner] = {} unless hash[:inner]
-            hash = hash[:inner]
+        def flat(event_store)
+          arr = event_store.filter_map do |node|
+            next unless node.value
+
+            serialize(node.value)
           end
-          hash
+          arr.sort_by { |item| item[:level] }
         end
 
-        def item(value)
+        def serialize(value)
           {
             class: value.klass.to_s,
             method_name: value.method_name,
             full_path: "#{value.path}:#{value.lineno}",
-            level: value.depth,
+            level: value.level,
             vars: value.vars
           }
         end

data/lib/rshade/serializer/traversal.rb

@@ -17,6 +17,10 @@ module RShade
         new_val
       end
 
+      def merge!(new_types)
+        @types.merge!(new_types)
+      end
+
       def default_types
         {
           default: lambda(&:to_s),

data/lib/rshade/stack.rb

@@ -20,7 +20,7 @@ module RShade
 
         frame
       end.compact.reverse
-      config.formatter.call(result)
+      config.formatter.call(result, variable_serializer: config.variable_serializer)
     end
   end
 end

data/lib/rshade/trace.rb

@@ -4,14 +4,14 @@ module RShade
   class Trace
     attr_reader :config, :event_store
 
-    # @param [RShade::Config,RShade::Config::Store] config
-    def initialize(config)
-      @config = fetch_config(config)
+    # @param [RShade::Config,RShade::Config::EventStore] config
+    def initialize(config: ::RShade::Config::Registry.instance.default_trace_config)
+      @config = config
       @event_store = EventTree.new
     end
 
-    def self.reveal(config = nil, &block)
-      new(config).reveal(&block)
+    def self.reveal(config: ::RShade::Config::Registry.instance.default_trace_config, &block)
+      new(config: config).reveal(&block)
     end
 
     def reveal(&block)
@@ -25,13 +25,5 @@ module RShade
     def show
       config.formatter.call(event_store)
     end
-
-    private
-
-    def fetch_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

@@ -9,7 +9,7 @@ module RShade
     RETURN_EVENTS = Set[:return, :c_return, :b_return]
 
     # @param [Enumerable<#call>, #call] observers
-    # @param [::RShade::Config::Store] config
+    # @param [::RShade::Config::EventStore] config
     def initialize(observers, config)
       @trace_p = TracePoint.new(*config.tp_events, &method(:process))
       observers = [observers] unless observers.is_a?(Enumerable)

data/lib/rshade/utils.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RShade
+  module Utils
+    RUBY_VERSION_PATTERN = /ruby-[0-9.]*/.freeze
+
+    def self.store_dir
+      File.expand_path('../../tmp', __dir__)
+    end
+
+    def self.root_dir
+      @root_dir ||= File.expand_path('../../', __dir__)
+    end
+
+    def self.default_excluded_path
+      [ENV['GEM_PATH'].split(':'), RUBY_VERSION_PATTERN, /internal/, %r{/gems/}].flatten.compact
+    end
+  end
+end

data/lib/rshade/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RShade
-  VERSION = '0.2.1'
+  VERSION = '0.2.2'
 end

data/lib/rshade.rb

@@ -23,7 +23,6 @@ require 'rshade/filter/default'
 
 require 'rshade/formatter/trace/string'
 require 'rshade/formatter/trace/json'
-require 'rshade/formatter/trace/file'
 require 'rshade/formatter/trace/html'
 require 'rshade/formatter/trace/stdout'
 
@@ -31,8 +30,8 @@ require 'rshade/formatter/stack/string'
 require 'rshade/formatter/stack/stdout'
 require 'rshade/formatter/stack/json'
 
-require 'rshade/config'
-require 'rshade/config/store'
+require 'rshade/utils'
+require 'rshade/config/event_store'
 require 'rshade/config/stack_store'
 require 'rshade/config/registry'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rshade
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Ivan Lopatin
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-01-07 00:00:00.000000000 Z
+date: 2025-01-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: binding_of_caller
@@ -72,10 +72,9 @@ files:
 - bin/setup
 - html/template.html.erb
 - lib/rshade.rb
-- lib/rshade/config.rb
+- lib/rshade/config/event_store.rb
 - lib/rshade/config/registry.rb
 - lib/rshade/config/stack_store.rb
-- lib/rshade/config/store.rb
 - lib/rshade/core_extensions/object/reveal.rb
 - lib/rshade/event.rb
 - lib/rshade/event_observer.rb
@@ -91,7 +90,6 @@ files:
 - lib/rshade/formatter/stack/json.rb
 - lib/rshade/formatter/stack/stdout.rb
 - lib/rshade/formatter/stack/string.rb
-- lib/rshade/formatter/trace/file.rb
 - lib/rshade/formatter/trace/html.rb
 - lib/rshade/formatter/trace/json.rb
 - lib/rshade/formatter/trace/stdout.rb
@@ -102,6 +100,7 @@ files:
 - lib/rshade/stack_frame.rb
 - lib/rshade/trace.rb
 - lib/rshade/trace_observable.rb
+- lib/rshade/utils.rb
 - lib/rshade/version.rb
 - rshade.gemspec
 - shade.jpg

data/lib/rshade/config/store.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module RShade
-  class Config
-    class Store
-      attr_reader :filter_composition, :formatter, :tp_events, :custom_serializers
-
-      # @param [Hash] options
-      # @option options [RShade::Filter::FilterComposition] :filter_composition
-      # @option options [#call(event_store)] :formatter
-      # @option options [Array<Symbol>] :tp_events
-      def initialize(options = {})
-        @filter_composition = options.fetch(:filter_composition, default_filter_composition)
-        @formatter = options.fetch(:formatter, ::RShade::Formatter::Trace::Stdout)
-        @tp_events = options.fetch(:tp_events, %i[call return])
-        @custom_serializers = options.fetch(:custom_serializers, {})
-      end
-
-      def tp_events!(tp_events)
-        @tp_events = tp_events
-        self
-      end
-
-      def add_custom_serializers(hash)
-        custom_serializers.merge!(hash)
-        self
-      end
-
-      def config_filter(filter_type, &block)
-        filter_composition.config_filter(filter_type, &block)
-        self
-      end
-
-      def formatter!(formatter)
-        @formatter = formatter
-        self
-      end
-
-      private
-
-      def default_filter_composition
-        variable_filter = RShade::Filter::VariableFilter.new
-        include_filter = RShade::Filter::IncludePathFilter.new
-        exclude_filter = RShade::Filter::ExcludePathFilter.new
-
-        RShade::Filter::FilterBuilder.build([:or,
-                                             [:or, variable_filter, include_filter], exclude_filter])
-      end
-    end
-  end
-end

data/lib/rshade/config.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-module RShade
-  class Config
-    RUBY_VERSION_PATTERN = /ruby-[0-9.]*/.freeze
-
-    def self.default
-      ::RShade::Config::Store.new.formatter!(::RShade::Formatter::Trace::Stdout.new)
-                             .config_filter(::RShade::Filter::ExcludePathFilter) do |paths|
-        default_excluded_path.each do |path|
-          paths << path
-        end
-      end
-    end
-
-    # @param [RShade::Config::Store] config_store
-    def initialize(config_store)
-      @config_store = config_store
-    end
-
-    # @param [Hash] options
-    # @option options [RShade::Filter::FilterComposition] :filter_composition
-    # @option options [#call(event_store)] :formatter
-    # @option options [Array<Symbol>] :tp_events
-    def self.create(options = {})
-      new(Config::Store.new(options))
-    end
-
-    def tp_events(&block)
-      events = block.call
-      @config_store.tp_events!(events)
-      self
-    end
-
-    def include_paths(&block)
-      @config_store.config_filter(::RShade::Filter::IncludePathFilter, &block)
-      self
-    end
-
-    def exclude_paths(&block)
-      @config_store.config_filter(::RShade::Filter::ExcludePathFilter, &block)
-      self
-    end
-
-    def match_variable(&block)
-      @config_store.config_filter(::RShade::Filter::VariableFilter, &block)
-      self
-    end
-
-    def formatter(&block)
-      formatter = block.call
-      @config_store.formatter!(formatter)
-      self
-    end
-
-    def add_custom_serializers(hash)
-      @config_store.add_custom_serializers(hash)
-      self
-    end
-
-    def value
-      @config_store
-    end
-
-    def self.store_dir
-      File.expand_path('../../tmp', __dir__)
-    end
-
-    def self.root_dir
-      @root_dir ||= File.expand_path('../../', __dir__)
-    end
-
-    def self.default_excluded_path
-      [ENV['GEM_PATH'].split(':'), RUBY_VERSION_PATTERN, /internal/, %r{/gems/}].flatten.compact
-    end
-  end
-end

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

@@ -1,31 +0,0 @@
-# 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