contrast-agent 5.1.0 → 6.0.0

data/ext/cs__contrast_patch/cs__contrast_patch.c

@@ -3,6 +3,7 @@
 
 #include "cs__contrast_patch.h"
 #include "../cs__common/cs__common.h"
+#include "../cs__scope/cs__scope.h"
 #include <ruby.h>
 
 VALUE build_preshift(const VALUE method_policy, const VALUE object,
@@ -34,25 +35,29 @@ VALUE contrast_patch_call_original(const VALUE *args) {
     method = args[3];
     method_id = SYM2ID(method);
 
-    /* It looks like we can find the last Ruby block given so long as we don't
-     * change Ruby method scope (always call this function from C, not Ruby),
-     * which is the point of this C call.
-     */
-    /* Ruby >= 2.7 */
-    #ifdef RB_PASS_CALLED_KEYWORDS
-        if (rb_block_given_p()) {
-            return rb_funcall_with_block_kw(object, method_id, argc, params, rb_block_proc(), RB_PASS_CALLED_KEYWORDS);
-        } else {
-            return rb_funcallv_kw(object, method_id, argc, params, RB_PASS_CALLED_KEYWORDS);
-        }
-    /* Ruby < 2.7 */
-    #else
-        if (rb_block_given_p()) {
-            return rb_funcall_with_block(object, method_id, argc, params, rb_block_proc());
-        } else {
-            return rb_funcall2(object, method_id, argc, params);
-        }
-    #endif
+/* It looks like we can find the last Ruby block given so long as we don't
+ * change Ruby method scope (always call this function from C, not Ruby),
+ * which is the point of this C call.
+ */
+/* Ruby >= 2.7 */
+#ifdef RB_PASS_CALLED_KEYWORDS
+    if (rb_block_given_p()) {
+        return rb_funcall_with_block_kw(object, method_id, argc, params,
+                                        rb_block_proc(),
+                                        RB_PASS_CALLED_KEYWORDS);
+    } else {
+        return rb_funcallv_kw(object, method_id, argc, params,
+                              RB_PASS_CALLED_KEYWORDS);
+    }
+/* Ruby < 2.7 */
+#else
+    if (rb_block_given_p()) {
+        return rb_funcall_with_block(object, method_id, argc, params,
+                                     rb_block_proc());
+    } else {
+        return rb_funcall2(object, method_id, argc, params);
+    }
+#endif
 }
 
 VALUE contrast_call_pre_patch(const VALUE method_policy, const VALUE method,
@@ -84,15 +89,22 @@ VALUE contrast_call_post_patch(const VALUE method_policy, const VALUE preshift,
                       method_policy, preshift, object, ret, send, block);
 }
 
-VALUE contrast_patch_call_rescue(const VALUE *args) {
-    int argc;
-    VALUE exception, object, preshift, method_policy, method;
-    VALUE *argv;
-
+/* wrap rb_ensure so we can rescue an exception */
+VALUE rescue_func(VALUE arg1) {
+    VALUE exception;
     /* rb_errinfo() gives the value of $!, the exception that
      * triggered a rescue block.
      */
     exception = rb_errinfo();
+    rb_exc_raise(exception);
+
+    return Qnil;
+}
+
+VALUE contrast_patch_call_ensure(const VALUE *args) {
+    int argc;
+    VALUE object, preshift, method_policy, method;
+    VALUE *argv;
 
     object = args[0];
     method = args[1];
@@ -103,12 +115,20 @@ VALUE contrast_patch_call_rescue(const VALUE *args) {
 
     contrast_call_post_patch(method_policy, preshift, object, Qnil, argc, argv);
 
-    /* reraise the exception that got us here */
-    rb_exc_raise(exception);
-
     return Qnil;
 }
 
+VALUE ensure_wrapper(const VALUE *args) {
+    VALUE original_method, original_args, ensure_args;
+
+    original_method = args[0];
+    original_args = (VALUE)args[1];
+    ensure_args = (VALUE)args[2];
+
+    return rb_ensure(original_method, original_args, contrast_patch_call_ensure,
+                     (VALUE)ensure_args);
+}
+
 VALUE contrast_call_super(const VALUE *args) {
     int argc;
     VALUE *argv;
@@ -119,10 +139,12 @@ VALUE contrast_call_super(const VALUE *args) {
 }
 
 VALUE contrast_run_patches(const VALUE *wrapped_args) {
-    VALUE impl, method, method_policy, object, original_args, original_ret, preshift, transformed_ret;
+    VALUE impl, method, method_policy, object, original_args, original_ret,
+        preshift, transformed_ret;
     int argc;
     VALUE *argv;
-    VALUE rescue_args[6];
+    VALUE ensure_args[6];
+    VALUE rescue_wrapper_args[3];
 
     impl = wrapped_args[0];
     original_args = wrapped_args[1];
@@ -132,18 +154,22 @@ VALUE contrast_run_patches(const VALUE *wrapped_args) {
     argc = NUM2INT(wrapped_args[5]);
     argv = (VALUE *)wrapped_args[6];
 
-    rescue_args[0] = object;
-    rescue_args[1] = method;
-    rescue_args[2] = INT2NUM(argc);
-    rescue_args[3] = (VALUE)argv;
-    rescue_args[4] = method_policy;
+    rescue_wrapper_args[0] = contrast_patch_call_original;
+    rescue_wrapper_args[1] = original_args;
+    rescue_wrapper_args[2] = ensure_args;
+
+    ensure_args[0] = object;
+    ensure_args[1] = method;
+    ensure_args[2] = INT2NUM(argc);
+    ensure_args[3] = (VALUE)argv;
+    ensure_args[4] = method_policy;
 
     /* Tracking, triggering, and propagation here. */
     contrast_call_pre_patch(method_policy, method, object, argc, argv, Qnil);
 
     /* Capture pre-call state */
     preshift = build_preshift(method_policy, object, argc, argv);
-    rescue_args[5] = preshift;
+    ensure_args[5] = preshift;
 
     /* We wrap a call to the original method with a rescue block, and we use
      * rb_rescue2 to capture all Exception-inheriting exceptions (and if your
@@ -178,15 +204,14 @@ VALUE contrast_run_patches(const VALUE *wrapped_args) {
     switch (impl) {
     case IMPL_ALIAS_INSTANCE:
     case IMPL_ALIAS_SINGLETON:
-        original_ret = rb_rescue2(contrast_patch_call_original, original_args,
-                                  contrast_patch_call_rescue,
-                                  (VALUE)rescue_args, rb_eException, 0);
+        original_ret =
+            rb_rescue(ensure_wrapper, rescue_wrapper_args, rescue_func, Qnil);
         break;
     case IMPL_PREPEND_INSTANCE:
     case IMPL_PREPEND_SINGLETON:
-        original_ret = rb_rescue2(contrast_call_super, original_args,
-                                  contrast_patch_call_rescue,
-                                  (VALUE)rescue_args, rb_eException, 0);
+        rescue_wrapper_args[0] = contrast_call_super;
+        original_ret =
+            rb_rescue(ensure_wrapper, rescue_wrapper_args, rescue_func, Qnil);
         break;
     };
 
@@ -214,8 +239,10 @@ VALUE contrast_run_patches(const VALUE *wrapped_args) {
 
 VALUE contrast_ensure_function(const VALUE method_policy) {
     /* exit scope */
-    rb_funcall(contrast_patcher(), rb_sym_exit_method_scope, 1, method_policy);
-    rb_funcall(contrast_patcher(), rb_sym_exit_scope, 0);
+    VALUE scopes = rb_funcall(method_policy, rb_sym_scopes_to_exit, 0);
+
+    inst_methods_exit_method_scope(contrast_patcher(), scopes);
+    inst_methods_exit_cntr_scope(contrast_patcher(), 0);
 
     return Qnil;
 }
@@ -235,10 +262,10 @@ VALUE contrast_patch_dispatch(const int argc, const VALUE *argv,
      * which is unnecessary, or run Contrast analysis on Contrast code,
      * which will never terminate.
      */
-    nested_scope = RTEST(rb_funcall(contrast_patcher(), rb_sym_in_scope, 0));
+    nested_scope = inst_methods_in_cntr_scope(contrast_patcher(), 0);
 
     /* enter scope */
-    rb_funcall(contrast_patcher(), rb_sym_enter_scope, 0);
+    inst_methods_enter_cntr_scope(contrast_patcher(), 0);
 
     /* Get the name of the calling method */
     method = rb_funcall(object, rb_sym_method, 0);
@@ -253,9 +280,9 @@ VALUE contrast_patch_dispatch(const int argc, const VALUE *argv,
             rb_funcall(patch_status, rb_sym_info_for, 3, object, method, Qtrue);
         break;
     case IMPL_PREPEND_SINGLETON:
-       known =
-           rb_funcall(patch_status, rb_sym_info_for, 3, object, method, Qfalse);
-       break;
+        known = rb_funcall(patch_status, rb_sym_info_for, 3, object, method,
+                           Qfalse);
+        break;
     case IMPL_ALIAS_SINGLETON:
         known = rb_funcall(patch_status, rb_sym_info_for, 3, object, method,
                            Qfalse);
@@ -270,7 +297,7 @@ VALUE contrast_patch_dispatch(const int argc, const VALUE *argv,
     }
 
     /* Check conditions for not doing Contrast analysis */
-    if (nested_scope) {
+    if (nested_scope == Qtrue) {
         /* if we were in scope */
         do_contrast = 0;
     } else if (!RTEST(known)) {
@@ -299,7 +326,9 @@ VALUE contrast_patch_dispatch(const int argc, const VALUE *argv,
     }
 
     /* Enter any scopes specific to method policy */
-    rb_funcall(contrast_patcher(), rb_sym_enter_method_scope, 1, method_policy);
+    VALUE scopes = rb_funcall(method_policy, rb_sym_scopes_to_enter, 0);
+
+    inst_methods_enter_method_scope(contrast_patcher(), scopes);
 
     /* If we're not doing Contrast analysis, exit scope and treat as normal. */
     if (!do_contrast) {
@@ -316,14 +345,14 @@ VALUE contrast_patch_dispatch(const int argc, const VALUE *argv,
     wrapped_args[5] = INT2NUM(argc);
     wrapped_args[6] = (VALUE)argv;
 
-    return rb_ensure(contrast_run_patches, (VALUE)wrapped_args, contrast_ensure_function, method_policy);
+    return rb_ensure(contrast_run_patches, (VALUE)wrapped_args,
+                     contrast_ensure_function, method_policy);
 
 call_original:
 
     /* exit scope */
     contrast_ensure_function(method_policy);
 
-
     switch (impl) {
     case IMPL_ALIAS_INSTANCE:
     case IMPL_ALIAS_SINGLETON:
@@ -345,19 +374,22 @@ VALUE contrast_alias_singleton_patch(const int argc, const VALUE *argv,
 }
 
 VALUE contrast_prepend_instance_patch(const int argc, const VALUE *argv,
-                             const VALUE object) {
+                                      const VALUE object) {
     return contrast_patch_dispatch(argc, argv, IMPL_PREPEND_INSTANCE, object);
 }
 
 VALUE contrast_prepend_singleton_patch(const int argc, const VALUE *argv,
-                             const VALUE object) {
+                                       const VALUE object) {
     return contrast_patch_dispatch(argc, argv, IMPL_PREPEND_SINGLETON, object);
 }
 
-VALUE contrast_patch_define_method(const VALUE self, const VALUE clazz, const VALUE method_policy,
+VALUE contrast_patch_define_method(const VALUE self, const VALUE clazz,
+                                   const VALUE method_policy,
                                    const VALUE cs_method) {
-    const VALUE original_method_name = rb_funcall(method_policy, rb_sym_method_name, 0);
-    const VALUE is_instance_method = rb_funcall(method_policy, rb_sym_instance_method, 0);
+    const VALUE original_method_name =
+        rb_funcall(method_policy, rb_sym_method_name, 0);
+    const VALUE is_instance_method =
+        rb_funcall(method_policy, rb_sym_instance_method, 0);
     char *cStr;
     VALUE str;
     rb_funcall(patch_status, rb_sym_set_info_for, 5, clazz,
@@ -423,8 +455,8 @@ VALUE contrast_patch_prepend(const VALUE self, const VALUE originalModule,
     const VALUE is_instance_method =
         rb_funcall(method_policy, rb_sym_instance_method, 0);
 
-// Set the value for instance or singleton method
-    if (RTEST(is_instance_method)){
+    // Set the value for instance or singleton method
+    if (RTEST(is_instance_method)) {
         rb_funcall(patch_status, rb_sym_set_info_for, 5, originalModule,
                    original_method_name, method_policy, instance, Qnil);
 
@@ -441,17 +473,19 @@ VALUE contrast_patch_prepend(const VALUE self, const VALUE originalModule,
             rb_define_private_method(module, cMethodName,
                                      contrast_prepend_instance_patch, -1);
         } else {
-            rb_define_method(module, cMethodName, contrast_prepend_instance_patch, -1);
+            rb_define_method(module, cMethodName,
+                             contrast_prepend_instance_patch, -1);
         }
     } else {
-        rb_define_singleton_method(module, cMethodName, contrast_prepend_singleton_patch,
-                                   -1);
+        rb_define_singleton_method(module, cMethodName,
+                                   contrast_prepend_singleton_patch, -1);
     }
     rb_prepend_module(originalModule, module);
 
     if (rb_ver_below_three()) {
         VALUE module_at;
-        VALUE rb_incl_in_mod_ary = rb_funcall(originalModule, rb_intern("included_in"), 0);
+        VALUE rb_incl_in_mod_ary =
+            rb_funcall(originalModule, rb_intern("included_in"), 0);
         if (RB_TYPE_P(rb_incl_in_mod_ary, T_ARRAY)) {
             int i = 0;
             int size = rb_funcall(rb_incl_in_mod_ary, rb_intern("length"), 0);
@@ -462,7 +496,7 @@ VALUE contrast_patch_prepend(const VALUE self, const VALUE originalModule,
                 }
             }
         }
-   }
+    }
     return Qtrue;
 }
 
@@ -488,6 +522,8 @@ void Init_cs__contrast_patch(void) {
 
     rb_sym_enter_method_scope = rb_intern("enter_method_scope!");
     rb_sym_exit_method_scope = rb_intern("exit_method_scope!");
+    rb_sym_scopes_to_enter = rb_intern("scopes_to_enter");
+    rb_sym_scopes_to_exit = rb_intern("scopes_to_exit");
 
     rb_define_module_function(contrast_patcher(), "contrast_define_method",
                               contrast_patch_define_method, 3);

data/ext/cs__contrast_patch/cs__contrast_patch.h

@@ -18,6 +18,8 @@ static VALUE rb_sym_cs_to_s;
 
 static VALUE rb_sym_enter_method_scope;
 static VALUE rb_sym_exit_method_scope;
+static VALUE rb_sym_scopes_to_enter;
+static VALUE rb_sym_scopes_to_exit;
 
 static VALUE rb_sym_build_method_name;
 static VALUE rb_sym_info_for;

data/ext/cs__os_information/cs__os_information.c

@@ -8,24 +8,27 @@
 
 VALUE contrast, utils, os;
 
-VALUE contrast_get_system_information()
-{
+VALUE contrast_get_system_information() {
     struct utsname uname_pointer;
 
-    uname (&uname_pointer);
+    uname(&uname_pointer);
 
     VALUE rb_data_hash = rb_hash_new();
-    rb_hash_aset(rb_data_hash, rb_str_new2("os_type"), rb_str_new2(uname_pointer.sysname));
-    rb_hash_aset(rb_data_hash, rb_str_new2("os_version"), rb_str_new2(uname_pointer.release));
-    rb_hash_aset(rb_data_hash, rb_str_new2("os_complete_version"), rb_str_new2(uname_pointer.version));
-    rb_hash_aset(rb_data_hash, rb_str_new2("os_arch"), rb_str_new2(uname_pointer.machine));
+    rb_hash_aset(rb_data_hash, rb_str_new2("os_type"),
+                 rb_str_new2(uname_pointer.sysname));
+    rb_hash_aset(rb_data_hash, rb_str_new2("os_version"),
+                 rb_str_new2(uname_pointer.release));
+    rb_hash_aset(rb_data_hash, rb_str_new2("os_complete_version"),
+                 rb_str_new2(uname_pointer.version));
+    rb_hash_aset(rb_data_hash, rb_str_new2("os_arch"),
+                 rb_str_new2(uname_pointer.machine));
     return rb_data_hash;
 }
 
-void Init_cs__os_information(void)
-{
+void Init_cs__os_information(void) {
     contrast = rb_define_module("Contrast");
     utils = rb_define_module_under(contrast, "Utils");
     os = rb_define_module_under(utils, "OS");
-    rb_define_module_function(os, "get_system_information", contrast_get_system_information, 0);
+    rb_define_module_function(os, "get_system_information",
+                              contrast_get_system_information, 0);
 }