appmap 0.77.3 → 0.79.0

data/lib/appmap/handler/rails/template.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'appmap/handler/function'
 require 'appmap/event'
 
 module AppMap
@@ -9,7 +10,7 @@ module AppMap
         LOG = (ENV['APPMAP_TEMPLATE_DEBUG'] == 'true' || ENV['DEBUG'] == 'true')
 
         # All the code which is touched by the AppMap is recorded in the classMap.
-        # This duck-typed 'method' is used to represent a view template as a package, 
+        # This duck-typed 'method' is used to represent a view template as a package,
         # class, and method in the classMap.
         # The class name is generated from the template path. The package name is
         # 'app/views', and the method name is 'render'. The source location of the method
@@ -41,31 +42,31 @@ module AppMap
           def package
             'app/views'
           end
-  
+
           def name
             'render'
           end
-  
+
           def source_location
             path
           end
-  
+
           def static
             true
           end
-  
+
           def comment
             nil
           end
-  
+
           def labels
             [ 'mvc.template' ]
           end
         end
-  
+
         # TemplateCall is a type of function call which is specialized to view template rendering. Since
         # there isn't really a perfect method in Rails to hook, this one is synthesized from the available
-        # information. 
+        # information.
         class TemplateCall < AppMap::Event::MethodEvent
           # This is basically the +self+ parameter.
           attr_reader :render_instance
@@ -75,19 +76,19 @@ module AppMap
           attr_accessor :ready
 
           alias ready? ready
- 
+
           def initialize(render_instance)
             super :call
-  
+
             AppMap::Event::MethodEvent.build_from_invocation(:call, event: self)
             @ready = false
             @render_instance = render_instance
           end
-  
+
           def static?
             true
           end
-    
+
           def to_h
             super.tap do |h|
               h[:defined_class] = path ? path.parameterize.underscore : 'inline_template'
@@ -103,71 +104,76 @@ module AppMap
             end.compact
           end
         end
- 
+
         TEMPLATE_RENDERER = 'appmap.handler.rails.template.renderer'
 
         # Hooks the ActionView::Resolver methods +find_all+, +find_all_anywhere+. The resolver is used
         # during template rendering to lookup the template file path from parameters such as the
         # template name, prefix, and partial (boolean).
-        class ResolverHandler
-          class << self
-            # Handled as a normal function call.
-            def handle_call(defined_class, hook_method, receiver, args)
-              name, prefix, partial = args
-              warn "Resolver: #{{ name: name, prefix: prefix, partial: partial }}" if LOG
-
-              AppMap::Handler::Function.handle_call(defined_class, hook_method, receiver, args)
-            end
+        class ResolverHandler < AppMap::Handler::Function
+          def handle_call(receiver, args)
+            name, prefix, partial = args
+            warn "Resolver: #{{ name: name, prefix: prefix, partial: partial }}" if LOG
 
-            # When the resolver returns, look to see if there is template rendering underway.
-            # If so, populate the template path. In all cases, add a TemplateMethod so that the
-            # template will be recorded in the classMap.
-            def handle_return(call_event_id, elapsed, return_value, exception)
-              renderer = Array(Thread.current[TEMPLATE_RENDERER]).last
-              path_obj = Array(return_value).first
-              
-              warn "Resolver return: #{path_obj}" if LOG
-
-              if path_obj
-                path = if path_obj.respond_to?(:identifier) && path_obj.inspect.index('#<')
-                  path_obj.identifier
-                else
-                  path_obj.inspect
-                end
-                path = path[Dir.pwd.length + 1..-1] if path.index(Dir.pwd) == 0
-                AppMap.tracing.record_method(TemplateMethod.new(path))
-                renderer.path ||= path if renderer
-              end
+            super
+          end
 
-              AppMap::Handler::Function.handle_return(call_event_id, elapsed, return_value, exception)
-            end
+          # When the resolver returns, look to see if there is template rendering underway.
+          # If so, populate the template path. In all cases, add a TemplateMethod so that the
+          # template will be recorded in the classMap.
+          def handle_return(call_event_id, elapsed, return_value, exception)
+            renderer = Array(Thread.current[TEMPLATE_RENDERER]).last
+            path_obj = Array(return_value).first
+
+            warn "Resolver return: #{path_obj}" if LOG
+
+            record_template_path renderer, path_obj
+
+            super
+          end
+
+          def record_template_path(renderer, path_obj)
+            return unless path_obj
+
+            path = path_from_obj path_obj
+            AppMap.tracing.record_method(TemplateMethod.new(path))
+            renderer.path ||= path if renderer
+          end
+
+          def path_from_obj(path_obj)
+            path =
+              if path_obj.respond_to?(:identifier) && path_obj.inspect.index('#<')
+                path_obj.identifier
+              else
+                path_obj.inspect
+              end
+            path = path[Dir.pwd.length + 1..] if path.index(Dir.pwd) == 0
+            path
           end
         end
 
         # Hooks the ActionView::Renderer method +render+. This method is used by Rails to perform
         # template rendering. The TemplateCall event which is emitted by this handler has a
-        # +path+ parameter, which is nil until it's filled in by a ResolverHandler. 
-        class RenderHandler
-          class << self
-            def handle_call(defined_class, hook_method, receiver, args)
-              # context, options
-              _, options = args
-
-              warn "Renderer: #{options}" if LOG
-
-              TemplateCall.new(receiver).tap do |call|
-                Thread.current[TEMPLATE_RENDERER] ||= []
-                Thread.current[TEMPLATE_RENDERER] << call
-              end
-            end
-  
-            def handle_return(call_event_id, elapsed, return_value, exception)
-              template_call = Array(Thread.current[TEMPLATE_RENDERER]).pop
-              template_call.ready = true
+        # +path+ parameter, which is nil until it's filled in by a ResolverHandler.
+        class RenderHandler < AppMap::Hook::Method
+          def handle_call(receiver, args)
+            # context, options
+            _, options = args
+
+            warn "Renderer: #{options}" if LOG
 
-              AppMap::Event::MethodReturnIgnoreValue.build_from_invocation(call_event_id, elapsed: elapsed)
+            TemplateCall.new(receiver).tap do |call|
+              Thread.current[TEMPLATE_RENDERER] ||= []
+              Thread.current[TEMPLATE_RENDERER] << call
             end
           end
+
+          def handle_return(call_event_id, elapsed, _return_value, _exception)
+            template_call = Array(Thread.current[TEMPLATE_RENDERER]).pop
+            template_call.ready = true
+
+            AppMap::Event::MethodReturnIgnoreValue.build_from_invocation(call_event_id, elapsed: elapsed)
+          end
         end
       end
     end

data/lib/appmap/hook/method/ruby2.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+def ruby2_keywords(*); end unless respond_to?(:ruby2_keywords, true)
+
+module AppMap
+  class Hook
+    # Delegation methods for Ruby 2.
+    # cf. https://eregon.me/blog/2019/11/10/the-delegation-challenge-of-ruby27.html
+    class Method
+      ruby2_keywords def call(receiver, *args, &block)
+        return do_call(receiver, *args, &block) unless trace?
+
+        call_event = with_disabled_hook { before_hook receiver, *args }
+        trace_call call_event, receiver, *args, &block
+      end
+
+      protected
+
+      def before_hook(receiver, *args)
+        call_event = handle_call(receiver, args)
+        if call_event
+          AppMap.tracing.record_event \
+            call_event,
+            package: hook_package,
+            defined_class: defined_class,
+            method: hook_method
+        end
+        call_event
+      end
+
+      ruby2_keywords def do_call(receiver, *args, &block)
+        hook_method.bind(receiver).call(*args, &block)
+      end
+
+      ruby2_keywords def trace_call(call_event, receiver, *args, &block)
+        start_time = gettime
+        begin
+          return_value = do_call(receiver, *args, &block)
+        rescue # rubocop:disable Style/RescueStandardError
+          exception = $ERROR_INFO
+          raise
+        ensure
+          with_disabled_hook { after_hook receiver, call_event, gettime - start_time, return_value, exception } \
+            if call_event
+        end
+      end
+
+      def hook_method_def
+        this = self
+        proc { |*args, &block| this.call self, *args, &block }.tap do |hook|
+          hook.ruby2_keywords if hook.respond_to? :ruby2_keywords
+        end
+      end
+    end
+  end
+end

data/lib/appmap/hook/method/ruby3.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module AppMap
+  class Hook
+    # Delegation methods for Ruby 3.
+    class Method
+      def call(receiver, *args, **kwargs, &block)
+        return do_call(receiver, *args, **kwargs, &block) unless trace?
+
+        call_event = with_disabled_hook { before_hook receiver, *args, **kwargs }
+        trace_call call_event, receiver, *args, **kwargs, &block
+      end
+
+      protected
+
+      def before_hook(receiver, *args, **kwargs)
+        args = [*args, kwargs] if !kwargs.empty? || keyrest?
+        call_event = handle_call(receiver, args)
+        if call_event
+          AppMap.tracing.record_event \
+            call_event,
+            package: hook_package,
+            defined_class: defined_class,
+            method: hook_method
+        end
+        call_event
+      end
+
+      def keyrest?
+        @keyrest ||= parameters.map(&:last).include? :keyrest
+      end
+
+      def do_call(receiver, *args, **kwargs, &block)
+        hook_method.bind_call(receiver, *args, **kwargs, &block)
+      end
+
+      def trace_call(call_event, receiver, *args, **kwargs, &block)
+        start_time = gettime
+        begin
+          return_value = do_call(receiver, *args, **kwargs, &block)
+        rescue # rubocop:disable Style/RescueStandardError
+          exception = $ERROR_INFO
+          raise
+        ensure
+          with_disabled_hook { after_hook receiver, call_event, gettime - start_time, return_value, exception } \
+            if call_event
+        end
+      end
+
+      def hook_method_def
+        this = self
+        proc { |*args, **kwargs, &block| this.call self, *args, **kwargs, &block }
+      end
+    end
+  end
+end

data/lib/appmap/hook/method.rb

@@ -1,17 +1,11 @@
 # frozen_string_literal: true
 
 module AppMap
-  NEW_RUBY = Util.ruby_minor_version >= 2.7
-  if NEW_RUBY && !Proc.instance_methods.include?(:ruby2_keywords)
-    warn "Ruby is #{RUBY_VERSION}, but Procs don't respond to #ruby2_keywords"
-  end
-
   class Hook
     SIGNATURES = {}
-
     LOOKUP_SIGNATURE = lambda do |id|
       method = super(id)
-    
+
       signature = SIGNATURES[[ method.owner, method.name ]]
       if signature
         method.singleton_class.module_eval do
@@ -20,36 +14,24 @@ module AppMap
           end
         end
       end
-    
+
       method
     end
-    
-    class Method
-      attr_reader :hook_package, :hook_class, :hook_method
 
-      # +method_display_name+ may be nil if name resolution gets
-      # deferred until runtime (e.g. for a singleton method on an
-      # embedded Struct).
-      attr_reader :method_display_name
+    # Single hooked method.
+    # Call #activate to override the original.
+    class Method
+      attr_reader :hook_package, :hook_class, :hook_method, :parameters, :arity
 
       HOOK_DISABLE_KEY = 'AppMap::Hook.disable'
       private_constant :HOOK_DISABLE_KEY
 
-      # Grab the definition of Time.now here, to avoid interfering
-      # with the method we're hooking.
-      TIME_NOW = Time.method(:now)
-      private_constant :TIME_NOW
-
-      ARRAY_OF_EMPTY_HASH = [{}.freeze].freeze
-
       def initialize(hook_package, hook_class, hook_method)
         @hook_package = hook_package
         @hook_class = hook_class
         @hook_method = hook_method
-
-        # Get the class for the method, if it's known.
-        @defined_class, method_symbol = Hook.qualify_method_name(@hook_method)
-        @method_display_name = [@defined_class, method_symbol, @hook_method.name].join if @defined_class
+        @parameters = hook_method.parameters
+        @arity = hook_method.arity
       end
 
       def activate
@@ -62,64 +44,6 @@ module AppMap
           warn "AppMap: Hooking #{msg} at line #{(hook_method.source_location || []).join(':')}"
         end
 
-        defined_class = @defined_class
-        hook_package = self.hook_package
-        hook_method = self.hook_method
-        before_hook = self.method(:before_hook)
-        after_hook = self.method(:after_hook)
-        with_disabled_hook = self.method(:with_disabled_hook)
-
-        is_array_containing_empty_hash = ->(obj) {
-          obj.is_a?(Array) && obj.length == 1 && obj[0].is_a?(Hash) && obj[0].size == 0
-        }
-
-        call_instance_method = lambda do |receiver, args, &block|
-          # https://github.com/applandinc/appmap-ruby/issues/153
-          if NEW_RUBY && is_array_containing_empty_hash.(args) && hook_method.arity == 1
-            hook_method.bind_call(receiver, {}, &block)
-          else
-            if NEW_RUBY
-              hook_method.bind_call(receiver, *args, &block)
-            else
-              hook_method.bind(receiver).call(*args, &block)
-            end
-          end
-        end
-
-        hook_method_def = Proc.new do |*args, &block|
-          # We may not have gotten the class for the method during
-          # initialization (e.g. for a singleton method on an embedded
-          # struct), so make sure we have it now.
-          defined_class, = Hook.qualify_method_name(hook_method) unless defined_class
-
-          reentrant = Thread.current[HOOK_DISABLE_KEY]
-          disabled_by_shallow_flag = \
-            -> { hook_package&.shallow? && AppMap.tracing.last_package_for_current_thread == hook_package }
-
-          enabled = true if AppMap.tracing.enabled? && !reentrant && !disabled_by_shallow_flag.call
-
-          enabled = false if %i[instance_eval instance_exec].member?(hook_method.name) && args.empty?
-
-          return call_instance_method.call(self, args, &block) unless enabled
-
-          call_event, start_time = with_disabled_hook.call do
-            before_hook.call(self, defined_class, args)
-          end
-          return_value = nil
-          exception = nil
-          begin
-            return_value = call_instance_method.call(self, args, &block)
-          rescue
-            exception = $ERROR_INFO
-            raise
-          ensure
-            with_disabled_hook.call do
-              after_hook.call(self, call_event, start_time, return_value, exception) if call_event
-            end
-          end
-        end
-        hook_method_def = hook_method_def.ruby2_keywords if hook_method_def.respond_to?(:ruby2_keywords)
-
         hook_method_parameters = hook_method.parameters.dup.freeze
         SIGNATURES[[ hook_class, hook_method.name ]] = hook_method_parameters
 
@@ -140,28 +64,42 @@ module AppMap
 
       protected
 
-      def before_hook(receiver, defined_class, args)
-        call_event = hook_package.handler_class.handle_call(defined_class, hook_method, receiver, args)
-        AppMap.tracing.record_event(call_event, package: hook_package, defined_class: defined_class, method: hook_method) if call_event
-        [ call_event, TIME_NOW.call ]
+      def gettime
+        Process.clock_gettime Process::CLOCK_MONOTONIC
+      end
+
+      def trace?
+        return false unless AppMap.tracing.enabled?
+        return false if Thread.current[HOOK_DISABLE_KEY]
+        return false if hook_package&.shallow? && AppMap.tracing.last_package_for_current_thread == hook_package
+
+        true
       end
 
-      def after_hook(_receiver, call_event, start_time, return_value, exception)
-        elapsed = TIME_NOW.call - start_time
-        return_event = hook_package.handler_class.handle_return(call_event.id, elapsed, return_value, exception)
+      def method_display_name
+        return @method_display_name if @method_display_name
+
+        return @method_display_name = [defined_class, method_symbol, hook_method.name].join if defined_class
+
+        "#{hook_method.name} (class resolution deferred)"
+      end
+
+      def defined_class
+        @defined_class ||= Hook.qualify_method_name(hook_method)&.first
+      end
+
+      def after_hook(_receiver, call_event, elapsed, return_value, exception)
+        return_event = handle_return(call_event.id, elapsed, return_value, exception)
         AppMap.tracing.record_event(return_event) if return_event
-        nil
       end
 
-      def with_disabled_hook(&function)
+      def with_disabled_hook
         # Don't record functions, such as to_s and inspect, that might be called
         # by the fn. Otherwise there can be a stack overflow.
         Thread.current[HOOK_DISABLE_KEY] = true
-        begin
-          function.call
-        ensure
-          Thread.current[HOOK_DISABLE_KEY] = false
-        end
+        yield
+      ensure
+        Thread.current[HOOK_DISABLE_KEY] = false
       end
     end
   end
@@ -189,3 +127,9 @@ unless ENV['APPMAP_NO_PATCH_MODULE'] == 'true'
     prepend AppMap::ModuleMethods
   end
 end
+
+if RUBY_VERSION < '3'
+  require 'appmap/hook/method/ruby2'
+else
+  require 'appmap/hook/method/ruby3'
+end

data/lib/appmap/hook.rb

@@ -118,7 +118,7 @@ module AppMap
                 cls, method = entry
                 return false if config.never_hook?(cls, method)
 
-                Hook::Method.new(hook.package, cls, method).activate
+                hook.package.handler_class.new(hook.package, cls, method).activate
               end
 
               methods = []
@@ -209,7 +209,7 @@ module AppMap
           package = config.lookup_package(hook_cls, method)
           next unless package
 
-          Hook::Method.new(package, hook_cls, method).activate
+          package.handler_class.new(package, hook_cls, method).activate
         end
       end
 

data/lib/appmap/version.rb

@@ -3,7 +3,7 @@
 module AppMap
   URL = 'https://github.com/applandinc/appmap-ruby'
 
-  VERSION = '0.77.3'
+  VERSION = '0.79.0'
 
   APPMAP_FORMAT_VERSION = '1.5.1'
 

data/spec/config_spec.rb

@@ -3,7 +3,7 @@
 require 'rails_spec_helper'
 require 'appmap/config'
 
-describe AppMap::Config, docker: false do
+describe AppMap::Config do
   it 'loads as expected' do
     config_data = {
       name: 'test',

data/spec/depends/api_spec.rb

@@ -33,7 +33,7 @@ module AppMap
       end
     end
   end
-end 
+end
 
 describe 'Depends API' do
   let(:api) { AppMap::Depends::API.new(ENV['DEBUG'] == 'true') }
@@ -112,12 +112,12 @@ describe 'Depends API' do
       around do |test|
         @minitest_test_command_method = AppMap.configuration.depends_config.minitest_test_command_method
         AppMap.configuration.depends_config.minitest_test_command_method = 'AppMap::Depends::APISpec.minitest_test_command'
-  
+
         test.call
       ensure
         AppMap.configuration.depends_config.minitest_test_command_method = @minitest_test_command
       end
-  
+
       it 'passes a smoke test' do
         run_tests
       end
@@ -175,10 +175,18 @@ describe 'Depends API' do
         # At this point, we would run tests to bring the AppMaps up to date
         # Then once the tests have finished, remove any AppMaps that weren't refreshed
         removed = api.remove_out_of_date_appmaps(since, appmap_dir: DEPENDS_TEST_DIR, base_dir: DEPENDS_BASE_DIR)
-        expect(removed).to eq([ appmap_path.split('.')[0] ])  
+        expect(removed).to eq([ appmap_path.split('.')[0] ])
       ensure
-        File.write(appmap_path, appmap)        
+        File.write(appmap_path, appmap)
       end
     end
   end
+
+  before do
+    Dir.glob("#{DEPENDS_TEST_DIR}/*.appmap.json").each { |fname| FileUtils.touch fname }
+    update_appmap_index
+
+    FileUtils.rm_rf 'spec/tmp'
+    FileUtils.mkdir_p 'spec/tmp'
+  end
 end

data/spec/depends/spec_helper.rb

@@ -16,12 +16,3 @@ def update_appmap_index
   system cmd.join(' ') or raise "Failed to update AppMap index in #{DEPENDS_TEST_DIR}"
 end
 
-RSpec.configure do |rspec|
-  rspec.before do
-    Dir.glob("#{DEPENDS_TEST_DIR}/*.appmap.json").each { |fname| FileUtils.touch fname }
-    update_appmap_index
-
-    FileUtils.rm_rf 'spec/tmp'
-    FileUtils.mkdir_p 'spec/tmp'
-  end
-end

data/spec/fixtures/database.yml

@@ -0,0 +1,11 @@
+default: &default
+  url: <%= ENV['DATABASE_URL'] %>
+  adapter: postgresql
+  database: <%= ENV['TEST_DATABASE'] || 'appland-rails6-test' %>
+
+development:
+  <<: *default
+test:
+  <<: *default
+production:
+  <<: *default

data/spec/fixtures/rails5_users_app/config/database.yml

@@ -0,0 +1 @@
+../../database.yml

data/spec/fixtures/rails6_users_app/Gemfile

@@ -11,32 +11,8 @@ gem 'sequel', '>= 5.43.0', require: false
 gem 'sequel-rails', require: false
 gem 'sequel_secure_password', require: false
 
-appmap_path = \
-  # Support debugging inside the container with volume-mounted source
-  if File.directory?('/src/appmap-ruby')
-    '/src/appmap-ruby'
-  elsif File.exist?('../../../appmap.gemspec')
-    '../../..'
-  end
-
-if appmap_path
-  # Set the branch parameter, so that 'bundle config local.appmap' will work
-  appmap_branch = Dir.chdir appmap_path do
-    `git rev-parse --abbrev-ref HEAD`.strip
-  end
-end
-
-appmap_options = \
-  if appmap_path && appmap_branch
-    { git: appmap_path, branch: appmap_branch }
-  elsif appmap_path
-    { path: appmap_path }
-  else
-    {}
-  end.merge(require: %w[appmap])
-
 group :development, :test do
-  gem 'appmap', appmap_options
+  gem 'appmap', path: '../../..'
   gem 'cucumber-rails', require: false
   gem 'rspec-rails'
   # Call 'byebug' anywhere in the code to stop execution and get a debugger console

data/spec/fixtures/rails6_users_app/config/database.yml

@@ -0,0 +1 @@
+../../database.yml