Class: Sorbet::Private::GemGeneratorTracepoint::Tracer

Inherits:
Object
  • Object
show all
Defined in:
lib/gem-generator-tracepoint/tracer.rb

Defined Under Namespace

Modules: ClassOverride, ModuleOverride, ObjectOverride

Class Method Summary collapse

Class Method Details

.add_to_context(item) ⇒ Object 



118
119
120
121
122
123
124
 
# File 'lib/gem-generator-tracepoint/tracer.rb', line 118

def self.add_to_context(item)
  # The stack can be empty because we start the :c_return TracePoint inside a 'require' call.
  # In this case, it's okay to simply add something to the stack; it will be popped off when
  # the :c_return is traced.
  @context_stack << [] if @context_stack.empty?
  @context_stack.last << item
end

.disable_tracepoints ⇒ Object 



192
193
194
195
196
 
# File 'lib/gem-generator-tracepoint/tracer.rb', line 192

def self.disable_tracepoints
  @class_tracepoint.disable
  @c_call_tracepoint.disable
  @c_return_tracepoint.disable
end

.finish ⇒ Object 



92
93
94
 
# File 'lib/gem-generator-tracepoint/tracer.rb', line 92

def self.finish
  disable_tracepoints
end

.install_tracepoints ⇒ Object 



126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
 
# File 'lib/gem-generator-tracepoint/tracer.rb', line 126

def self.install_tracepoints
  @class_tracepoint = TracePoint.new(:class) do |tp|
    on_module_created(tp.self)
  end
  @c_call_tracepoint = TracePoint.new(:c_call) do |tp|

    # older version of JRuby unfortunately returned a String
    case tp.method_id.to_sym
    when :require, :require_relative
      @context_stack << []
    end
  end
  @c_return_tracepoint = TracePoint.new(:c_return) do |tp|

    # older version of JRuby unfortunately returned a String
    method_id_sym = tp.method_id.to_sym
    case method_id_sym
    when :require, :require_relative
      popped = @context_stack.pop

      next if popped.empty?

      path = $LOADED_FEATURES.last
      if tp.return_value != true # intentional true check
        next if popped.size == 1 && popped[0][:module].is_a?(LoadError)
        # warn("Unexpected: constants or methods were defined when #{tp.method_id} didn't return true; adding to #{path} instead")
      end

      # raise 'Unexpected: constants or methods were defined without a file added to $LOADED_FEATURES' if path.nil?
      # raise "Unexpected: #{path} is already defined in files" if files.key?(path)

      @files[path] ||= []
      @files[path] += popped

    # popped.each { |item| item[:path] = path }
    when :method_added, :singleton_method_added
      begin
        tp.disable

        singleton = method_id_sym == :singleton_method_added
        receiver = singleton ? Sorbet::Private::RealStdlib.real_singleton_class(tp.self) : tp.self

        # JRuby the main Object is not a module
        # so lets skip it, otherwise RealStdlib#real_instance_methods raises an exception since it expects one.
        next unless receiver.is_a?(Module)

        methods = Sorbet::Private::RealStdlib.real_instance_methods(receiver, false) + Sorbet::Private::RealStdlib.real_private_instance_methods(receiver, false)
        set = @modules[Sorbet::Private::RealStdlib.real_object_id(receiver)] ||= Set.new
        added = methods.find { |m| !set.include?(m) }
        if added.nil?
          # warn("Warning: could not find method added to #{tp.self} at #{tp.path}:#{tp.lineno}")
          next
        end
        set << added

        on_method_added(tp.self, added, singleton)
      ensure
        tp.enable
      end
    end
  end
  @class_tracepoint.enable
  @c_call_tracepoint.enable
  @c_return_tracepoint.enable
end

.on_method_added(mod, method, singleton) ⇒ Object 



73
74
75
 
# File 'lib/gem-generator-tracepoint/tracer.rb', line 73

def self.on_method_added(mod, method, singleton)
  add_to_context(type: :method, module: mod, method: method, singleton: singleton)
end

.on_module_created(mod) ⇒ Object 



61
62
63
 
# File 'lib/gem-generator-tracepoint/tracer.rb', line 61

def self.on_module_created(mod)
  add_to_context(type: :module, module: mod)
end

.on_module_extended(extended, extender) ⇒ Object 



69
70
71
 
# File 'lib/gem-generator-tracepoint/tracer.rb', line 69

def self.on_module_extended(extended, extender)
  add_to_context(type: :extend, module: extender, extend: extended)
end

.on_module_included(included, includer) ⇒ Object 



65
66
67
 
# File 'lib/gem-generator-tracepoint/tracer.rb', line 65

def self.on_module_included(included, includer)
  add_to_context(type: :include, module: includer, include: included)
end

.pre_cache_module_methods ⇒ Object 



111
112
113
114
115
116
 
# File 'lib/gem-generator-tracepoint/tracer.rb', line 111

def self.pre_cache_module_methods
  ObjectSpace.each_object(Module) do |mod_|
    mod = T.cast(mod_, Module)
    @modules[Sorbet::Private::RealStdlib.real_object_id(mod)] = (Sorbet::Private::RealStdlib.real_instance_methods(mod, false) + Sorbet::Private::RealStdlib.real_private_instance_methods(mod, false)).to_set
  end
end

.register_delegate_class(klass, delegate) ⇒ Object 



57
58
59
 
# File 'lib/gem-generator-tracepoint/tracer.rb', line 57

def self.register_delegate_class(klass, delegate)
  @delegate_classes[Sorbet::Private::RealStdlib.real_object_id(delegate)] = klass
end

.start ⇒ Object 



86
87
88
89
 
# File 'lib/gem-generator-tracepoint/tracer.rb', line 86

def self.start
  pre_cache_module_methods
  install_tracepoints
end

.trace ⇒ Object 



78
79
80
81
82
83
 
# File 'lib/gem-generator-tracepoint/tracer.rb', line 78

def self.trace
  start
  yield
  finish
  trace_results
end

.trace_results ⇒ Object 



97
98
99
100
101
102
 
# File 'lib/gem-generator-tracepoint/tracer.rb', line 97

def self.trace_results
  {
    files: @files,
    delegate_classes: @delegate_classes
  }
end