appmap 0.34.4 → 0.34.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a3a509a94faa2a85ff11702ae55ab3df975f04416d93d169b0a24989fd520b9d
-  data.tar.gz: 3895b9c788413f85738ba487e717bf48e4dfc2e8c0792f30c6f9f6ba7dc5e9c8
+  metadata.gz: 3b4318e1ef7e025a8f616022cefd323784e7b8ee8ccf06b1b7167b9937e860df
+  data.tar.gz: c6a743f2c7f4ebe8cd58f7ae971b5dae15791bc808dab9d4dcf87f4971986818
 SHA512:
-  metadata.gz: 07fe201395cad27e731402b5b2ff0efd653056dad16b9301657034df0b6e7fd3a205768ef3656874f55109edfc4d788d752f8bc73f4ff6874c815104547ce281
-  data.tar.gz: cbbd1551c352519954e9ddc9dd27279d6d232663fb67fd5ed4369a603a382f140593aa195aa08f35a57b0a14d38bef07bfef0aa7bd942d660a865fb3682d500d
+  metadata.gz: 9f271a71bb8bffa7004d054ae91646c9c93a476b15cbe80c459a9cafcb13ab0169be6c8a2db9b8cc993c3bc767deef4c9c0ca4befe6bd6881cf2d93c7b692b64
+  data.tar.gz: 3b6c5067a325fa2a0aed71b5ed92179196061cd6cfa015f907a25dab798e757c2cd53efbd028513df1f22cc2e2b8aa9345f8d19aa27018eccfbee4cd39766ece

data/CHANGELOG.md

@@ -1,3 +1,6 @@
+# v0.34.5
+* Ensure that hooking a method doesn't change its arity.
+
 # v0.34.4
 * Make sure `AppMap:Rails::SQLExaminer::ActiveRecordExaminer.server_version` only calls
   `ActiveRecord::Base.connection.database_version` if it's available.

data/README.md

@@ -57,6 +57,15 @@ end
 
 Then install with `bundle`.
 
+**Railtie**
+
+If you are using Ruby on Rails, require the railtie after Rails is loaded. 
+
+```
+# application.rb is a good place to do this, along with all the other railties.
+require 'appmap/railtie'
+```
+
 # Configuration
 
 When you run your program, the `appmap` gem reads configuration settings from `appmap.yml`. Here's a sample configuration

data/ext/appmap/appmap.c

@@ -8,7 +8,12 @@
     (!SPECIAL_CONST_P(obj) && \
      (BUILTIN_TYPE(obj) == T_CLASS || BUILTIN_TYPE(obj) == T_MODULE))
 
-static VALUE singleton_method_owner_name(VALUE klass, VALUE method)
+#define ARITIES_KEY "__arities__"
+
+VALUE am_AppMapHook;
+
+static VALUE
+singleton_method_owner_name(VALUE klass, VALUE method)
 {
   VALUE owner = rb_funcall(method, rb_intern("owner"), 0);
   VALUE attached = rb_ivar_get(owner, rb_intern("__attached__"));
@@ -27,10 +32,64 @@ static VALUE singleton_method_owner_name(VALUE klass, VALUE method)
   // #to_s on the method's owner and hope for the best.
   return rb_funcall(owner, rb_intern("to_s"), 0);
 }
-    
+
+
+static VALUE
+am_define_method_with_arity(VALUE mod, VALUE name, VALUE arity, VALUE proc)
+{
+  VALUE arities_key = rb_intern(ARITIES_KEY);
+  VALUE arities = rb_ivar_get(mod, arities_key);
+  
+  if (arities == Qundef || NIL_P(arities)) {
+    arities = rb_hash_new();
+    rb_ivar_set(mod, arities_key, arities);
+  }
+  rb_hash_aset(arities, name, arity);
+
+  return rb_funcall(mod, rb_intern("define_method"), 2, name, proc);
+}
+
+static VALUE
+am_get_method_arity(VALUE method, VALUE orig_arity_method)
+{
+  VALUE owner = rb_funcall(method, rb_intern("owner"), 0);
+  VALUE arities = rb_ivar_get(owner, rb_intern(ARITIES_KEY));
+  VALUE name = rb_funcall(method, rb_intern("name"), 0);
+  VALUE arity = Qnil;
+  // See if we saved an arity for the method.
+  if (!NIL_P(arities)) {
+    arity = rb_hash_aref(arities, name);
+  }
+  // Didn't find one, call the original method.
+  if (NIL_P(arity)) {
+    VALUE bound_method = rb_funcall(orig_arity_method, rb_intern("bind"), 1, method);    
+    arity = rb_funcall(bound_method, rb_intern("call"), 0);
+  }
+
+  return arity;
+}
+
+static VALUE
+am_unbound_method_arity(VALUE method)
+{
+  VALUE orig_unbound_method_arity = rb_ivar_get(am_AppMapHook, rb_intern("@unbound_method_arity"));
+  return am_get_method_arity(method, orig_unbound_method_arity);
+}
+
+static VALUE
+am_method_arity(VALUE method)
+{
+  VALUE orig_method_arity = rb_ivar_get(am_AppMapHook, rb_intern("@method_arity"));
+  return am_get_method_arity(method, orig_method_arity);
+}
+
 void Init_appmap() {
   VALUE appmap = rb_define_module("AppMap");
-  VALUE hook = rb_define_class_under(appmap, "Hook", rb_cObject);
+  am_AppMapHook = rb_define_class_under(appmap, "Hook", rb_cObject);
+
+  rb_define_singleton_method(am_AppMapHook, "singleton_method_owner_name", singleton_method_owner_name, 1);
 
-  rb_define_singleton_method(hook, "singleton_method_owner_name", singleton_method_owner_name, 1);
+  rb_define_method(rb_cModule, "define_method_with_arity", am_define_method_with_arity, 3);
+  rb_define_method(rb_cUnboundMethod, "arity", am_unbound_method_arity, 0);
+  rb_define_method(rb_cMethod, "arity", am_method_arity, 0);
 }

data/lib/appmap/hook.rb

@@ -6,6 +6,9 @@ module AppMap
   class Hook
     LOG = (ENV['DEBUG'] == 'true')
 
+    @unbound_method_arity = ::UnboundMethod.instance_method(:arity)
+    @method_arity = ::Method.instance_method(:arity)
+
     class << self
       def lock_builtins
         return if @builtins_hooked

data/lib/appmap/hook/method.rb

@@ -30,7 +30,7 @@ module AppMap
           msg = if method_display_name
                   "#{method_display_name}"
                 else
-                  "#{hook_method.name} (class resolution deferrred)"
+                  "#{hook_method.name} (class resolution deferred)"
                 end
           warn "AppMap: Hooking " + msg
         end
@@ -41,36 +41,39 @@ module AppMap
         after_hook = self.method(:after_hook)
         with_disabled_hook = self.method(:with_disabled_hook)
 
-        hook_class.define_method hook_method.name do |*args, &block|
-          instance_method = hook_method.bind(self).to_proc
+        hook_method_def = nil
+        hook_class.instance_eval do 
+          hook_method_def = Proc.new do |*args, &block|
+            instance_method = hook_method.bind(self).to_proc
 
-          # 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
+            # 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
 
-          hook_disabled = Thread.current[HOOK_DISABLE_KEY]
-          enabled = true if !hook_disabled && AppMap.tracing.enabled?
-          return instance_method.call(*args, &block) unless enabled
+            hook_disabled = Thread.current[HOOK_DISABLE_KEY]
+            enabled = true if !hook_disabled && AppMap.tracing.enabled?
+            return instance_method.call(*args, &block) unless enabled
 
-          call_event, start_time = with_disabled_hook.() do
-            before_hook.(self, defined_class, args)
-          end
-          return_value = nil
-          exception = nil
-          begin
-            return_value = instance_method.(*args, &block)
-          rescue
-            exception = $ERROR_INFO
-            raise
-          ensure
-            with_disabled_hook.() do
-              after_hook.(call_event, start_time, return_value, exception)
+            call_event, start_time = with_disabled_hook.() do
+              before_hook.(self, defined_class, args)
+            end
+            return_value = nil
+            exception = nil
+            begin
+              return_value = instance_method.(*args, &block)
+            rescue
+              exception = $ERROR_INFO
+              raise
+            ensure
+              with_disabled_hook.() do
+                after_hook.(call_event, start_time, return_value, exception)
+              end
             end
           end
         end
+        hook_class.define_method_with_arity(hook_method.name, hook_method.arity, hook_method_def)
       end
-
       protected
 
       def before_hook(receiver, defined_class, args)

data/lib/appmap/util.rb

@@ -43,7 +43,7 @@ module AppMap
         require 'hashie'
         h.extend(Hashie::Extensions::DeepLocate)
         keys = %i(path location)
-        entries = h.deep_locate ->(k,v,o) {
+        h.deep_locate ->(k,v,o) {
           next unless keys.include?(k)
           
           fix = ->(v) {v.gsub(%r{#{Gem.dir}/gems/.*(?=lib)}, '')}

data/lib/appmap/version.rb

@@ -3,7 +3,7 @@
 module AppMap
   URL = 'https://github.com/applandinc/appmap-ruby'
 
-  VERSION = '0.34.4'
+  VERSION = '0.34.5'
 
   APPMAP_FORMAT_VERSION = '1.2'
 end

data/spec/hook_spec.rb

@@ -669,4 +669,11 @@ describe 'AppMap class Hooking', docker: false do
       end
     end
   end
+
+  it "preserves the arity of hooked methods" do
+    invoke_test_file 'spec/fixtures/hook/instance_method.rb' do
+      expect(InstanceMethod.instance_method(:say_echo).arity).to be(1)
+      expect(InstanceMethod.new.method(:say_echo).arity).to be(1)
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: appmap
 version: !ruby/object:Gem::Version
-  version: 0.34.4
+  version: 0.34.5
 platform: ruby
 authors:
 - Kevin Gilpin
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-09-21 00:00:00.000000000 Z
+date: 2020-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport