contrast-agent 5.1.0 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c756fb0e7fe0433c7507c2cdb7082e635adabea8847c545333d65800225b1e3d
-  data.tar.gz: c71e1a8d020e3dfe98ea58d844924b0b0a9e1576b5f6899d186abc28e4efb152
+  metadata.gz: 47aa135a205e4a74d64b778ae543f892213ca70e47be654032147a8bfe16dc82
+  data.tar.gz: 60f0de0e2675578bfb735c4f90303748bdc5e2053f2722dac4907bf84364d2f9
 SHA512:
-  metadata.gz: 82a0a252fa7696b2590f8be43fba09e03c6b13371a58a678b31e088e01a244311e0ac9d5b077de5d7970c16bc9a2144504d01a0e037c5e0f0b06d06e8530c57a
-  data.tar.gz: d9fd4708ab8238a22a2e3187e880a898635739b00f0d2f4f224904325f3b88b28f3470cf37733d5875e97018a02a5bfe10bd7f041219fd842b596e9697bfdbb6
+  metadata.gz: fdd2d1209de7366f810cb1d7355700a54cd7d7749d94736213cf96c47b8e5cedad449ec0dc2ab09753c0ecc3d064498d18d1d001edc5d998c6c615c4cd05b571
+  data.tar.gz: 888016b33c67e7f2f77f320affcd1e945a7cc6e1c01c87d559d231cbed3309bbd4fff74833a5296f21680492955977d042594a39d807d4cb91eecd6adc4b4636

data/ext/cs__assess_array/cs__assess_array.c

@@ -22,7 +22,9 @@ static VALUE contrast_assess_array_join(const int argc, const VALUE *argv,
     }
     /* Finally, default to empty String. Implicit since nil.to_s is ''*/
 
+    /* call the Array.join but patched one */
     result = rb_funcall2(ary, rb_sym_assess_array_join, argc, argv);
+    /* call the Contrast::Extensions::Assess::ArrayPropagator#cs__track_join */
     result = rb_funcall(array_propagator, rb_sym_assess_track_array_join, 3,
                         ary, sep, result);
 
@@ -33,6 +35,11 @@ void Init_cs__assess_array(void) {
     array_propagator =
         rb_define_class_under(core_assess, "ArrayPropagator", rb_cObject);
     rb_sym_assess_track_array_join = rb_intern("cs__track_join");
+    /*
+     * Here we need to check before using the alias or prepend spec
+     * This patch is happening here, we register the cs__track_join
+     * method of the Array propagator, and call it here from Ruby.
+     */
     rb_sym_assess_array_join =
         contrast_register_patch("Array", "join", contrast_assess_array_join);
 }

data/ext/cs__assess_basic_object/cs__assess_basic_object.c

@@ -3,8 +3,20 @@
 
 #include "cs__assess_basic_object.h"
 #include "../cs__common/cs__common.h"
+#include "../cs__scope/cs__scope.h"
 #include <ruby.h>
 
+/*
+ * Source code of instance_eval:
+ *
+ *                static VALUE
+ *  rb_obj_instance_eval_internal(int argc, const VALUE *argv, VALUE self)
+ *  {
+ *      VALUE klass = singleton_class_for_eval(self);
+ *      return specific_eval(argc, argv, klass, self, RB_PASS_CALLED_KEYWORDS);
+ *  }
+ */
+
 void contrast_assess_instance_eval_trigger_check(VALUE self, VALUE source,
                                                  VALUE ret) {
     rb_funcall(basic_eval_trigger, instance_trigger_check_method, 3, self,
@@ -19,19 +31,21 @@ contrast_assess_basic_object_instance_eval(const int argc, const VALUE *argv,
         return rb_obj_instance_eval(argc, argv, self);
     }
 
-    int nested_scope =
-        RTEST(rb_funcall(contrast_patcher(), rb_sym_in_scope, 0));
+    VALUE nested_scope = inst_methods_in_cntr_scope(contrast_patcher(), 0);
 
-    rb_funcall(contrast_patcher(), rb_sym_enter_scope, 0);
+    /* Enter scope */
+    inst_methods_enter_cntr_scope(contrast_patcher(), 0);
 
+    /* Call the source: */
     VALUE ret = rb_obj_instance_eval(argc, argv, self);
 
-    if (!nested_scope && argc > 0) {
+    if (nested_scope == Qfalse && argc > 0) {
         VALUE data = argv[0];
         contrast_assess_instance_eval_trigger_check(self, data, ret);
     }
 
-    rb_funcall(contrast_patcher(), rb_sym_exit_scope, 0);
+    /* Exit scope */
+    inst_methods_exit_cntr_scope(contrast_patcher(), 0);
 
     return ret;
 }

data/ext/cs__assess_fiber_track/cs__assess_fiber_track.c

@@ -30,7 +30,7 @@ VALUE rb_fiber_new_hook(VALUE (*func)(ANYARGS), VALUE obj) {
             ID meth;
         };
 
-        /* underlying object is first entry in Enumerator struct def.
+        /*  underlying object is first entry in Enumerator struct def.
          *  that's all statically defined w/in enumerator.c, so we can't
          *  reference the data types and be safe about it.  (yippee.)
          *  we cut out the TypedData_Get_Struct middleman & just go for it.

data/ext/cs__assess_hash/cs__assess_hash.c

@@ -17,7 +17,6 @@ static VALUE contrast_assess_hash_bracket_constructor(const int argc,
                                                       const VALUE hash) {
     VALUE result;
 
-
     /* Array of Arrays: Hash[ [ [key, value], ... ] ]   -> new_hash */
     if (RB_TYPE_P(argv[0], T_ARRAY)) {
         int i;
@@ -34,13 +33,13 @@ static VALUE contrast_assess_hash_bracket_constructor(const int argc,
         }
     }
 
-    const VALUE * argv_final = argv;
+    const VALUE *argv_final = argv;
     /* unhandled case - shouldn't need it since issue is only unfrozen
      * String keys
      * # Hash[ object ]                  -> new_hash
      */
-    result =
-        rb_funcall2(hash, rb_sym_assess_hash_bracket_constructor, argc, argv_final);
+    result = rb_funcall2(hash, rb_sym_assess_hash_bracket_constructor, argc,
+                         argv_final);
 
     return result;
 }

data/ext/cs__assess_kernel/cs__assess_kernel.c

@@ -3,19 +3,21 @@
 
 #include "cs__assess_kernel.h"
 #include "../cs__common/cs__common.h"
+#include "../cs__scope/cs__scope.h"
 #include <ruby.h>
 
 VALUE
 contrast_patched_kernel_exec(const int argc, const VALUE *argv,
                              const VALUE self) {
-    int nested_scope =
-        RTEST(rb_funcall(contrast_patcher(), rb_sym_in_scope, 0));
+    VALUE nested_scope = inst_methods_in_cntr_scope(contrast_patcher(), 0);
 
-    if (!nested_scope && argc > 0) {
-        rb_funcall(contrast_patcher(), rb_sym_enter_scope, 0);
+    if (nested_scope == Qfalse && argc > 0) {
+        /* enter scope */
+        inst_methods_enter_cntr_scope(contrast_patcher(), 0);
         VALUE data = argv[0];
         rb_funcall(kernel_propagator, exec_apply_trigger, 1, data);
-        rb_funcall(contrast_patcher(), rb_sym_exit_scope, 0);
+        /* exit scope */
+        inst_methods_exit_cntr_scope(contrast_patcher(), 0);
     }
 
     /* maybe this should be rb_funcall2.  this works right now because *argv ==

data/ext/cs__assess_marshal_module/cs__assess_marshal_module.c

@@ -5,36 +5,50 @@
 #include "../cs__common/cs__common.h"
 #include <ruby.h>
 
-static VALUE contrast_marshal_module_load(const int argc,
-                                                 const VALUE *argv) {
+/*
+ * Marshal#load source:
+ * static VALUE
+ * marshal_load(int argc, VALUE *argv)
+ *  {
+ *     VALUE port, proc;
+ *
+ *     rb_check_arity(argc, 1, 2);
+ *     port = argv[0];
+ *     proc = argc > 1 ? argv[1] : Qnil;
+ *     return rb_marshal_load_with_proc(port, proc);
+ * }
+ */
+static VALUE contrast_marshal_module_load(const int argc, const VALUE *argv) {
     VALUE result;
     VALUE source_string;
 
-    // Our patches only need only apply in the case where there was valid input.
+    /* Our patches need to apply only in the case where there was valid input.
+     */
     if (argc >= 1) {
         source_string = argv[0];
     } else {
         source_string = Qnil;
     }
 
-    // Run our protect code ahead of the original method
+    /* Run our protect code ahead of the original method */
     if (source_string != Qnil) {
-        rb_funcall(marshal_propagator, rb_sym_protect_marshal_load, 1, source_string);
+        rb_funcall(marshal_propagator, rb_sym_protect_marshal_load, 1,
+                   source_string);
     }
 
-    // Invoke the original method
+    /* Invoke the original method */
     result = rb_call_super(argc, argv);
 
-    // Run our assess code after the original method
+    /* Run our assess code after the original method */
     if (source_string != Qnil) {
         VALUE tracked =
             rb_funcall(properties_hash, rb_sym_hash_tracked, 1, source_string);
 
-        // Assuming the source is tracked and needs assess checks
+        /* Assuming the source is tracked and needs assess checks */
         if (tracked == Qtrue) {
             VALUE skip =
                 rb_funcall(contrast_patcher(), rb_sym_skip_assess_analysis, 0);
-            // And Assess is enabled and applies to this request
+            /* And Assess is enabled and applies to this request */
             if (skip == Qfalse) {
                 rb_funcall(marshal_propagator, rb_sym_assess_marshal_load, 2,
                            source_string, result);
@@ -45,7 +59,7 @@ static VALUE contrast_marshal_module_load(const int argc,
 }
 
 void Init_cs__assess_marshal_module(void) {
-    // Contrast::Agent::Assess::Tracker::PROPERTIES_HASH
+    /* Contrast::Agent::Assess::Tracker::PROPERTIES_HASH */
     VALUE tracker = rb_define_class_under(assess, "Tracker", rb_cObject);
     properties_hash = rb_const_get(tracker, rb_intern("PROPERTIES_HASH"));
     marshal_propagator =
@@ -53,6 +67,6 @@ void Init_cs__assess_marshal_module(void) {
     rb_sym_assess_marshal_load = rb_intern("cs__load_assess");
     rb_sym_protect_marshal_load = rb_intern("cs__load_protect");
 
-    contrast_register_singleton_prepend_patch(
-        "Marshal", "load", &contrast_marshal_module_load);
+    contrast_register_singleton_prepend_patch("Marshal", "load",
+                                              &contrast_marshal_module_load);
 }

data/ext/cs__assess_module/cs__assess_module.c

@@ -3,6 +3,7 @@
 
 #include "cs__assess_module.h"
 #include "../cs__common/cs__common.h"
+#include "../cs__scope/cs__scope.h"
 #include <ruby.h>
 
 void contrast_assess_eval_trigger_check(VALUE module, VALUE source, VALUE ret) {
@@ -11,12 +12,11 @@ void contrast_assess_eval_trigger_check(VALUE module, VALUE source, VALUE ret) {
         return;
     }
 
-    int nested_scope =
-        RTEST(rb_funcall(contrast_patcher(), rb_sym_in_scope, 0));
+    int nested_scope = inst_methods_in_cntr_scope(contrast_patcher(), 0);
+    /* enter scope */
+    inst_methods_enter_cntr_scope(contrast_patcher(), 0);
 
-    rb_funcall(contrast_patcher(), rb_sym_enter_scope, 0);
-
-    if (!nested_scope) {
+    if (nested_scope == Qfalse) {
         VALUE method = rb_funcall(rb_mKernel, rb_sym_method, 0);
         /* If this method ever throws an exception, the scope-leave
          * needs to be moved within a rescue call.
@@ -24,8 +24,8 @@ void contrast_assess_eval_trigger_check(VALUE module, VALUE source, VALUE ret) {
         rb_funcall(module_eval_trigger, trigger_check_method, 4, module, source,
                    ret, method);
     }
-
-    rb_funcall(contrast_patcher(), rb_sym_exit_scope, 0);
+    /* exit scope */
+    inst_methods_exit_cntr_scope(contrast_patcher(), 0);
 }
 
 VALUE

data/ext/cs__assess_string/cs__assess_string.c

@@ -5,6 +5,18 @@
 #include "../cs__common/cs__common.h"
 #include <ruby.h>
 
+/*
+ * The -@ method source:
+ *
+ *                static VALUE
+ * str_uminus(VALUE str)
+ * {
+ *     if (!BARE_STRING_P(str) && !rb_obj_frozen_p(str)) {
+ *         str = rb_str_dup(str);
+ *     }
+ *     return rb_fstring(str);
+ * }
+ */
 static VALUE contrast_assess_string_freeze(const int argc, VALUE *argv,
                                            const VALUE obj) {
     if (!OBJ_FROZEN(obj)) {
@@ -39,7 +51,7 @@ void Init_cs__assess_string(void) {
     rb_sym_dup = rb_intern("dup");
     rb_sym_freeze = rb_intern("freeze");
     rb_sym_pre_freeze = rb_intern("pre_freeze");
-    // Contrast::Agent::Assess::Tracker::PROPERTIES_HASH
+    /* Contrast::Agent::Assess::Tracker::PROPERTIES_HASH */
     VALUE tracker = rb_define_class_under(assess, "Tracker", rb_cObject);
     properties_hash = rb_const_get(tracker, rb_intern("PROPERTIES_HASH"));
 

data/ext/cs__common/cs__common.c

@@ -10,6 +10,7 @@
 VALUE contrast, agent, patching, policy, assess;
 VALUE core_extensions, core_assess;
 VALUE assess_policy, assess_propagator;
+VALUE components;
 VALUE funchook_path;
 
 VALUE rb_sym_enter_scope;
@@ -59,8 +60,7 @@ VALUE contrast_patcher() {
 }
 
 VALUE contrast_register_patch(const char *module_name, const char *method_name,
-                              VALUE(c_fn)(const int, VALUE *,
-                                          const VALUE)) {
+                              VALUE(c_fn)(const int, VALUE *, const VALUE)) {
     return _contrast_register_patch(module_name, method_name, c_fn,
                                     IMPL_ALIAS_INSTANCE);
 }
@@ -74,17 +74,17 @@ VALUE contrast_register_singleton_patch(const char *module_name,
 }
 
 VALUE contrast_register_prepend_patch(const char *module_name,
-                              const char *method_name,
-                              VALUE(c_fn)(const int, VALUE *,
-                                          const VALUE)) {
+                                      const char *method_name,
+                                      VALUE(c_fn)(const int, VALUE *,
+                                                  const VALUE)) {
     return _contrast_register_patch(module_name, method_name, c_fn,
                                     IMPL_PREPEND_INSTANCE);
 }
 
 VALUE contrast_register_singleton_prepend_patch(const char *module_name,
-                              const char *method_name,
-                              VALUE(c_fn)(const int, VALUE *,
-                                          const VALUE)) {
+                                                const char *method_name,
+                                                VALUE(c_fn)(const int, VALUE *,
+                                                            const VALUE)) {
     return _contrast_register_patch(module_name, method_name, c_fn,
                                     IMPL_PREPEND_SINGLETON);
 }
@@ -134,7 +134,7 @@ _contrast_register_patch(const char *module_name, const char *method_name,
     case IMPL_PREPEND_INSTANCE:
         impl = ID2SYM(rb_sym_prepend_instance);
     case IMPL_PREPEND_SINGLETON:
-         impl = ID2SYM(rb_sym_prepend_singleton);
+        impl = ID2SYM(rb_sym_prepend_singleton);
         break;
     }
 
@@ -145,8 +145,10 @@ _contrast_register_patch(const char *module_name, const char *method_name,
 }
 
 int rb_ver_below_three() {
-  int ruby_version = FIX2INT(rb_funcall(rb_const_get(rb_cObject, rb_intern("RUBY_VERSION")), rb_intern("to_i"), 0));
-  return ruby_version < 3;
+    int ruby_version =
+        FIX2INT(rb_funcall(rb_const_get(rb_cObject, rb_intern("RUBY_VERSION")),
+                           rb_intern("to_i"), 0));
+    return ruby_version < 3;
 }
 
 void Init_cs__common(void) {
@@ -175,6 +177,9 @@ void Init_cs__common(void) {
     contrast = rb_define_module("Contrast");
     agent = rb_define_module_under(contrast, "Agent");
 
+    /* components => Contrast::Components */
+    components = rb_define_module_under(contrast, "Components");
+
     assess = rb_define_module_under(agent, "Assess");
 
     patching = rb_define_module_under(agent, "Patching");

data/ext/cs__common/cs__common.h

@@ -17,6 +17,7 @@ extern VALUE contrast, agent, patching, policy, assess;
 extern VALUE core_extensions, core_assess;
 extern VALUE assess_policy, assess_propagator;
 extern VALUE funchook_path;
+extern VALUE components;
 
 extern VALUE rb_sym_enter_scope;
 extern VALUE rb_sym_exit_scope;