trace2 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4f7e6874b292e5edcc36ba88b1f9f13798765d1682852a64b0be5667807a3b15
+  data.tar.gz: a3548111fdb9a4efb25f4303df014a9d3e1dc974f0dae15a517f2bafe505e4da
+SHA512:
+  metadata.gz: 35d7b742f6f9908f9ccc168551f8e7318bcde9d710cac0cb2e5eb1ffbccae0cf93ea4e1b3634e335f1bae412c2f1b0914f84c93cef4a94b0f2fd66e58cca5e6b
+  data.tar.gz: efb0c1e6c3a1fa059ee6d4ae4aa0a528e374f34771d6502782712196f6bfa25c30afdda57c1eecf730690b08ae57d1084325a4d8bff6e568962490a88d7e3f8b

data/bin/trace2

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'trace2'
+
+Trace2::Runner.run

data/ext/trace2/extconf.rb

@@ -0,0 +1,4 @@
+require 'mkmf'
+
+create_header
+create_makefile 'trace2/trace2'

data/lib/trace2.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+begin
+  RUBY_VERSION =~ /(\d+\.\d+)/
+  require "trace2/#{Regexp.last_match(1)}/trace2"
+rescue LoadError
+  require 'trace2/trace2'
+end
+
+require 'trace2/class_lister'
+require 'trace2/class_use'
+require 'trace2/class_use_factory'
+require 'trace2/event_processor'
+require 'trace2/executable_runner'
+require 'trace2/filter_parser'
+require 'trace2/option_parser'
+require 'trace2/options'
+require 'trace2/query_use'
+require 'trace2/runner'
+require 'trace2/version'
+require 'trace2/graph_generator'
+require 'trace2/reporting_tools_factory'
+require 'trace2/dot_wrapper'

data/lib/trace2/class_lister.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Trace2
+  # Responsable for listing all accessed classes
+  # along with their dependencies
+  class ClassLister
+    extend Forwardable
+
+    attr_accessor :classes_uses
+
+    def_delegators :@trace_point, :enable
+
+    def initialize(event_processor, trace_point = TracePoint)
+      @event_processor = event_processor
+      @classes_uses = []
+      @trace_point = trace_point.new(*@event_processor.events) do |tp|
+        @event_processor.process_event(tp)
+      end
+    end
+
+    def disable
+      @trace_point.disable
+      @event_processor.aggregate_uses
+      @classes_uses = @event_processor.classes_uses
+    end
+  end
+end

data/lib/trace2/class_use.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Trace2
+  # Registers how a class was used during run time
+  class ClassUse
+    attr_reader :name, :method, :stack_level, :path, :line, :callees, :event
+    attr_accessor :caller_class
+
+    def initialize(params)
+      @name = params[:name]
+      @method = params[:method]
+      @caller_class = params[:caller_class]
+      @stack_level = params[:stack_level]
+      @path = params[:path]
+      @line = params[:line]
+      @callees = params[:callees] || []
+      @event = params[:event]
+    end
+
+    def callers_stack(options = {})
+      curr_class = caller_class
+      callers_stack = []
+      until curr_class.nil?
+        curr_caller = run_options(curr_class, options)
+        callers_stack.push(curr_caller) unless curr_caller.nil?
+        curr_class = curr_class.caller_class
+      end
+      callers_stack
+    end
+
+    def matches_method?(methods_names)
+      methods_names.any? { |method_name| method.match(method_name) }
+    end
+
+    def matches_name?(classes_names)
+      classes_names.any? { |class_name| name.match(class_name) }
+    end
+
+    def matches_path?(paths_patterns)
+      paths_patterns.any? { |path_pattern| path.match(path_pattern) }
+    end
+
+    def matches_bottom_of_stack?(is_bottom)
+      caller_class.nil? == is_bottom
+    end
+
+    def matches_top_of_stack?(is_top)
+      callees.empty? == is_top
+    end
+
+    def matches_caller_class?(caller_attributes)
+      callers_stack.any? do |current_caller|
+        valid_caller?(current_caller, caller_attributes)
+      end
+    end
+
+    def add_callee(callee)
+      callees << callee
+    end
+
+    private
+
+    def run_options(class_use, options)
+      options.reduce(class_use) do |acc_use, option|
+        option_method = "run_#{option.first}"
+        send(option_method, acc_use, option.last) unless acc_use.nil?
+      end
+    end
+
+    def run_selector(class_use, selector)
+      return class_use if selector.nil?
+
+      selector.filter(class_use)
+    end
+
+    def run_compact(class_use, compact)
+      compact ? compact_callers(class_use) : class_use
+    end
+
+    def compact_callers(class_use)
+      class_use.dup.tap do |compacted_use|
+        compacted_use.caller_class = nil
+      end
+    end
+
+    def valid_caller?(current_caller, caller_attributes)
+      caller_attributes.all? do |attribute, values|
+        validation = "matches_#{attribute}?"
+        current_caller.send(validation, values)
+      end
+    end
+
+    def respond_to_missing?(method, _)
+      method.match?(/^matches_\S+?\?$/)
+    end
+
+    def method_missing(method, *args, &block)
+      return true if respond_to_missing?(method, args)
+
+      super
+    end
+  end
+end

data/lib/trace2/class_use_factory.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Trace2
+  # Builds a ClassUse from TracePoint
+  class ClassUseFactory
+    CLASS_POINTER_FORMAT = '0x[0-9abcdef]+'
+
+    def self.build(trace_point:, caller_class:, stack_level:)
+      ClassUse.new(
+        trace_point_params(trace_point)
+        .merge(caller_class: caller_class)
+        .merge(stack_level: stack_level)
+      )
+    end
+
+    def self.class_name(trace_point)
+      Trace2::NameFinder.class_name(trace_point.self)
+    end
+
+    class << self
+      def trace_point_params(trace_point)
+        {
+          name: class_name(trace_point),
+          method: trace_point.callee_id.to_s,
+          path: trace_point.path,
+          line: trace_point.lineno,
+          event: trace_point.event
+        }
+      end
+    end
+  end
+end

data/lib/trace2/dot_wrapper.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Trace2
+  # A class to abstract the usage of the dot executable
+  # that comes with graphviz
+  class DotWrapper
+    def initialize(kernel: Kernel)
+      @kernel = kernel
+    end
+
+    def render_graph(input_path, output_path, format)
+      return warn_graphviz_not_installed unless graphviz_installed?
+
+      execute_graph_render(input_path, output_path, format)
+    end
+
+    private
+
+    DOT_VERSION = 'dot -V'
+    DOT_RENDER = 'dot %s -T%s -o %s'
+
+    def graphviz_installed?
+      @kernel.system(DOT_VERSION)
+    end
+
+    def warn_graphviz_not_installed
+      @kernel.puts 'Graphviz is not installed on the system. '\
+        'Skipping graph rendering...'
+
+      false
+    end
+
+    def execute_graph_render(input_path, output_path, format)
+      graph_render_command = format(
+        DOT_RENDER, input_path, format, output_path
+      )
+      @kernel.system(graph_render_command)
+    end
+  end
+end

data/lib/trace2/event_processor.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Trace2
+  # Processes a TracePoint event, generating an array
+  # of ClassUse
+  class EventProcessor
+    attr_accessor :classes_uses
+    EVENTS = %i[call b_call].freeze
+
+    def initialize(filter_by, kernel: Kernel, query_use: QueryUse,
+                   class_use_factory: ClassUseFactory)
+      @callers_stack = []
+      @classes_uses = []
+      @class_use_factory = class_use_factory
+      @kernel = kernel
+      @selector = query_use.where(filter_by)
+      @stack_level = @kernel.caller.length
+    end
+
+    def aggregate_uses
+      @classes_uses = @callers_stack
+                      .map { |caller_class| @selector.filter(caller_class) }
+                      .concat(@classes_uses)
+                      .reject(&:nil?)
+      @callers_stack = []
+    end
+
+    def process_event(trace_point)
+      @stack_level = @kernel.caller.length
+
+      remove_exited_callers_from_stack
+      current_class_use = build_class_use(trace_point, current_caller)
+      update_top_of_stack(current_class_use)
+
+      @callers_stack.unshift(current_class_use)
+    end
+
+    def events
+      EVENTS
+    end
+
+    private
+
+    def remove_exited_callers_from_stack
+      while class_exited?(@callers_stack.first)
+        @classes_uses << @selector.filter(@callers_stack.shift)
+      end
+    end
+
+    def build_class_use(trace_point, caller_class)
+      @class_use_factory.build(
+        trace_point: trace_point,
+        stack_level: @stack_level,
+        caller_class: caller_class
+      )
+    end
+
+    def update_top_of_stack(callee)
+      caller_class = callee.caller_class
+      return if caller_class.nil?
+
+      caller_class.add_callee(callee) unless @selector.filter(callee).nil?
+    end
+
+    def class_exited?(current_class)
+      current_class && current_class.stack_level >= @stack_level
+    end
+
+    def current_caller
+      @callers_stack.drop_while do |possible_caller|
+        possible_caller.nil? || @selector.filter(possible_caller).nil?
+      end.first
+    end
+  end
+end

data/lib/trace2/executable_runner.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Trace2
+  # Class that runs the executable whose runtime will be
+  # used to analyze the relationship between classes
+  class ExecutableRunner
+    def initialize(system_path: ENV['PATH'], argv: ARGV)
+      @system_path = system_path
+      @argv = argv
+    end
+
+    def run(executable, args)
+      update_argv(args)
+      executable_path = find_executable(executable)
+      load(executable_path)
+    rescue SyntaxError
+      raise SyntaxError, "#{executable} is not a valid Ruby script"
+    end
+
+    private
+
+    def find_executable(executable)
+      possible_paths = @system_path.split(':').unshift('.').map do |path|
+        "#{path}/#{executable}"
+      end
+
+      executable_path = possible_paths.find do |path|
+        File.exist?(path)
+      end
+
+      if executable_path.nil?
+        raise ArgumentError, "#{executable} does not exist"
+      end
+
+      executable_path
+    end
+
+    def update_argv(args)
+      @argv.clear.concat(args)
+    end
+  end
+end

data/lib/trace2/filter_parser.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Trace2
+  # Class that queries ClassUse by parameters
+  # passed as a hash
+  class FilterParser
+    FILTER = 'filter'
+    VALIDATE = 'validate_%s'
+    PARSE = 'parse_%s'
+
+    def parse(filters)
+      @filters = filters
+      @parsed_filter = [filters.length]
+      parse_filters
+      @parsed_filter.map(&:to_s)
+    end
+
+    private
+
+    def parse_filters
+      @filters.each do |filter|
+        @parsed_filter.push(filter.length)
+        filter.each do |action, validations|
+          parse_validations(validations)
+          @parsed_filter.push(action.to_s)
+        end
+        @parsed_filter.push(FILTER)
+      end
+    end
+
+    def parse_validations(validations)
+      @parsed_filter.push(validations.length)
+      validations.each do |validation|
+        @parsed_filter.push(validation.length)
+        parse_validation(validation)
+      end
+    end
+
+    def parse_validation(validation)
+      validation.each do |attribute, values|
+        @parsed_filter.push(format(VALIDATE, attribute))
+        current_parser = parse_values_method(values)
+        if respond_to?(current_parser, true)
+          send(current_parser, values)
+        else
+          @parsed_filter.push(1)
+          @parsed_filter.push(values.to_s)
+        end
+      end
+    end
+
+    def parse_values_method(values)
+      format(PARSE, values.class.to_s.downcase)
+    end
+
+    def parse_array(values)
+      @parsed_filter.push(values.length)
+      @parsed_filter.concat(values)
+    end
+
+    def parse_hash(values)
+      @parsed_filter.push(values.keys.length)
+      parse_validation(values)
+    end
+  end
+end

data/lib/trace2/graph_generator.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Trace2
+  # Generates a graph in .dot format from an array of
+  # ClassUse
+  class GraphGenerator
+    def run(output_path, class_lister)
+      parsed_classes = parse_classes(class_lister.classes_uses)
+      File.write(output_path, base_graph(parsed_classes))
+    end
+
+    private
+
+    def base_graph(parsed_classes)
+      <<~FILE
+        digraph {
+        #{parsed_classes}
+        }
+      FILE
+    end
+
+    def parse_classes(classes_uses)
+      classes_uses.flat_map do |class_use|
+        caller_relationship(class_use) + callee_relationships(class_use)
+      end.uniq.join("\n")
+    end
+
+    def caller_relationship(class_use)
+      return [] unless class_use.caller_class
+
+      [to_graph(class_use.caller_class, class_use)]
+    end
+
+    def callee_relationships(class_use)
+      class_use.callees.map { |callee| to_graph(class_use, callee) }
+    end
+
+    def to_graph(caller_class, callee)
+      "\s\s\"#{caller_class.name}\" -> \"#{callee.name}\""
+    end
+  end
+end

data/lib/trace2/option_parser.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module Trace2
+  # Class that parses the options that will be used
+  # by trace2
+  class OptionParser < ::OptionParser
+    attr_reader :options_keys
+
+    def initialize(banner = nil, width = 32, indent = ' ' * 4)
+      @options_keys = {}
+      super(banner, width, indent)
+    end
+
+    def add_option(short: nil, long: nil, description: [])
+      @options_keys.merge!(**option_hash(short), **option_hash(long))
+      options = [short, long].compact
+      on(*options, *description) do |option_value|
+        yield option_value
+      end
+    end
+
+    def split_executables(args)
+      second_executable = second_executable_arguments(args)
+
+      [args.shift(args.length - second_executable.length), second_executable]
+    end
+
+    private
+
+    def second_executable_arguments(args)
+      argument = false
+      args.drop_while do |arg|
+        accepts_argument = @options_keys[arg.to_sym]
+        if accepts_argument.nil? && !argument
+          false
+        else
+          argument = accepts_argument
+          true
+        end
+      end
+    end
+
+    def option_hash(option)
+      return {} if option.nil?
+
+      arguments = option.split
+      option_name = arguments.first
+      has_arguments = arguments.length > 1
+      { option_name.to_sym => has_arguments }
+    end
+  end
+end

data/lib/trace2/options.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Trace2
+  # Defines and returns options for Trace2's runner,
+  # given the arguments that were passed
+  # rubocop:disable Metrics/ClassLength
+  class Options
+    def self.parse(args)
+      new.parse(args)
+    end
+
+    # rubocop:disable Metrics/MethodLength
+    def initialize(option_parser: Trace2::OptionParser.new, kernel: Kernel)
+      @options = default_options
+      @kernel = kernel
+      @option_parser = option_parser
+      options_banner
+      help_option
+      version_option
+      filter_option
+      output_path_option
+      type_option
+      format_option
+      manual_option
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    def parse(args)
+      trace2, executable_args = @option_parser.split_executables(args)
+      executable = executable_args.shift
+
+      @option_parser.parse(trace2)
+
+      raise_missing_executable if executable.nil?
+
+      @options.merge(executable: executable, args: executable_args)
+    end
+
+    private
+
+    def default_options
+      {
+        tools_type: :native,
+        automatic_render: true,
+        graph_format: 'pdf',
+        output_path: 'trace2_report.dot',
+        filter_path: '.trace2.yml'
+      }
+    end
+
+    def options_banner
+      @option_parser.banner = 'Usage: trace2 [options] ' \
+       'RUBY_EXECUTABLE [executable options]'
+    end
+
+    def help_option
+      @option_parser.add_option(short: '-h',
+                                long: '--help',
+                                description: 'Display help') do
+        puts @option_parser.to_s
+        exit_runner
+      end
+    end
+
+    def version_option
+      @option_parser.add_option(short: '-v',
+                                long: '--version',
+                                description: 'Show trace2 version') do
+        puts VERSION
+        exit_runner
+      end
+    end
+
+    def filter_option
+      filter_description = 'Specify a filter file. Defaults to .trace2.yml'
+      @option_parser.add_option(description: filter_description,
+                                long: '--filter FILTER_PATH') do |filter|
+        @options[:filter_path] = filter
+      end
+    end
+
+    def output_path_option
+      output_path = ['Output path for the report file. Defaults to',
+                     './trace2_report.yml']
+      @option_parser.add_option(short: '-o OUTPUT_PATH',
+                                description: output_path,
+                                long: '--output OUTPUT_PATH') do |output|
+        @options[:output_path] = output
+      end
+    end
+
+    def type_option
+      tools_type = ['Type of the tools that will be used to generate the',
+                    'relationship between classes. Possible values:',
+                    'ruby or native. Defaults to native.']
+
+      @option_parser.add_option(short: '-t TOOLS_TYPE',
+                                description: tools_type,
+                                long: '--type TOOLS_TYPE') do |type|
+        @options[:tools_type] = type.to_sym
+      end
+    end
+
+    def manual_option
+      run_manually = 'Don\'t try to render the relationships ' \
+       'graph automatically'
+      @option_parser.add_option(short: '-m',
+                                description: run_manually,
+                                long: '--manual') do
+        @options[:automatic_render] = false
+      end
+    end
+
+    def format_option
+      output_format = ['Format that will be used to render the relationship\'s',
+                       'graph. Has no effect if the manual option is set.',
+                       'Defaults to pdf.']
+      @option_parser.add_option(long: '--format FORMAT',
+                                description: output_format) do |format|
+        @options[:graph_format] = format
+      end
+    end
+
+    def raise_missing_executable
+      raise ArgumentError, 'an executable or ruby script name'\
+       ' must be passed as argument'
+    end
+
+    def exit_runner
+      @kernel.exit
+    end
+  end
+  # rubocop:enable Metrics/ClassLength
+end

data/lib/trace2/query_use.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Trace2
+  # Class that queries ClassUse by parameters
+  # passed as a hash
+  class QueryUse
+    attr_reader :classes_uses
+
+    def initialize(queries)
+      @queries = queries
+    end
+
+    def self.where(queries)
+      QueryUse.new(queries)
+    end
+
+    def filter(class_use)
+      class_use if class_use && valid_use?(class_use)
+    end
+
+    def select(classes_uses)
+      classes_uses.select do |class_use|
+        valid_use?(class_use)
+      end
+    end
+
+    private
+
+    def valid_use?(class_use)
+      @queries.all? do |query|
+        query.all? do |action, validations|
+          send(action, matches_validations?(class_use, validations))
+        end
+      end
+    end
+
+    def allow(query_result)
+      query_result
+    end
+
+    def reject(query_result)
+      !query_result
+    end
+
+    def matches_validations?(class_use, validations)
+      validations.any? do |validation|
+        validation.all? do |attribute, values|
+          attribute_match = "matches_#{attribute}?"
+          class_use.send(attribute_match, values)
+        end
+      end
+    end
+  end
+end

data/lib/trace2/reporting_tools_factory.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Trace2
+  # Builds a ClassLister and GraphGenerator instance depending on the type
+  # that is passed.
+  class ReportingToolsFactory
+    def initialize(class_lister: ClassLister)
+      @class_lister = class_lister
+    end
+
+    def build(filter, type: :native)
+      @type = type
+      {
+        class_lister: build_class_lister(filter),
+        graph_generator: type_options[:graph_generator]
+      }
+    end
+
+    private
+
+    Trace2::NATIVE = {
+      event_processor: Trace2::EventProcessorC,
+      filter_parser: Trace2::FilterParser.new,
+      graph_generator: Trace2::GraphGeneratorC.new
+    }.freeze
+
+    Trace2::RUBY = {
+      event_processor: Trace2::EventProcessor,
+      filter_parser: nil,
+      graph_generator: Trace2::GraphGenerator.new
+    }.freeze
+
+    def build_class_lister(filter)
+      parsed_filter = build_filter(filter)
+      event_processor = type_options[:event_processor].new(parsed_filter)
+      @class_lister.new(event_processor)
+    end
+
+    def build_filter(unparsed_filter)
+      filter_parser = type_options[:filter_parser]
+      return filter_parser.parse(unparsed_filter) if filter_parser
+
+      unparsed_filter
+    end
+
+    def type_options
+      Object.const_get("Trace2::#{@type.upcase}")
+    end
+  end
+end

data/lib/trace2/runner.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Trace2
+  # Base class for trace2's executable
+  class Runner
+    def self.run(args: ARGV, options: Options.new)
+      options_hash = options.parse(args)
+      new(options_hash).run
+    end
+
+    def initialize(options)
+      @args = options[:args]
+      @executable = options[:executable]
+      @output_path = options.fetch(:output_path)
+      @executable_runner = options[:executable_runner] || ExecutableRunner.new
+      @render_graph_automatically = options.fetch(:automatic_render, false)
+      @graph_format = options[:graph_format]
+      @filter_path = options[:filter_path]
+      @dot_wrapper = options.fetch(:dot_wrapper, DotWrapper.new)
+      build_class_lister(options)
+    end
+
+    def run
+      at_exit { end_class_listing }
+      class_lister.enable
+      executable_runner.run(executable, args)
+    end
+
+    private
+
+    attr_reader :args, :class_lister, :executable, :executable_runner,
+                :output_path, :graph_generator, :render_graph_automatically,
+                :dot_wrapper
+
+    def build_class_lister(options)
+      filter = load_filter
+      tools = options.fetch(:reporting_tools_factory, ReportingToolsFactory.new)
+                     .build(filter, type: options[:tools_type])
+
+      @class_lister = tools[:class_lister]
+      @graph_generator = tools[:graph_generator]
+    end
+
+    def load_filter
+      return YAML.load_file(@filter_path) if File.exist?(@filter_path)
+
+      []
+    end
+
+    def end_class_listing
+      class_lister.disable
+      graph_generator.run(output_path, class_lister)
+      run_graph_rendering
+    end
+
+    def run_graph_rendering
+      return unless render_graph_automatically
+
+      final_file = "#{output_path}.#{@graph_format}"
+      dot_wrapper.render_graph(output_path, final_file, @graph_format)
+    end
+  end
+end

data/lib/trace2/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Trace2
+  VERSION = '1.0.1'
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: trace2
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Raphael Montani
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-09-27 00:00:00.000000000 Z
+dependencies: []
+description: Check the runtime dependencies of your classes
+email: raphael.muntani@gmail.com
+executables:
+- trace2
+extensions:
+- ext/trace2/extconf.rb
+extra_rdoc_files: []
+files:
+- bin/trace2
+- ext/trace2/extconf.rb
+- lib/trace2.rb
+- lib/trace2/2.5/trace2.so
+- lib/trace2/2.6/trace2.so
+- lib/trace2/2.7/trace2.so
+- lib/trace2/class_lister.rb
+- lib/trace2/class_use.rb
+- lib/trace2/class_use_factory.rb
+- lib/trace2/dot_wrapper.rb
+- lib/trace2/event_processor.rb
+- lib/trace2/executable_runner.rb
+- lib/trace2/filter_parser.rb
+- lib/trace2/graph_generator.rb
+- lib/trace2/option_parser.rb
+- lib/trace2/options.rb
+- lib/trace2/query_use.rb
+- lib/trace2/reporting_tools_factory.rb
+- lib/trace2/runner.rb
+- lib/trace2/trace2.so
+- lib/trace2/version.rb
+homepage: https://github.com/rmuntani/trace2
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/rmuntani/trace2
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.4
+signing_key: 
+specification_version: 4
+summary: Check the runtime dependencies of your classes
+test_files: []