contrast-agent 3.9.1 → 6.15.3

data/ext/cs__scope/cs__scope.c

@@ -0,0 +1,980 @@
+/* Copyright (c) 2023 Contrast Security, Inc.  See
+ * https://www.contrastsecurity.com/enduser-terms-0317a for more details. */
+
+#include "cs__scope.h"
+#include "../cs__common/cs__common.h"
+#include <ruby.h>
+#include <stdlib.h>
+
+/*-----------------------------------------
+ |  Calls to Contrast modules and classes
+ ------------------------------------------*/
+
+VALUE contrast, agent, components;
+VALUE scope_interface, scope_inst_methods;
+VALUE scope_mod, scope_klass;
+
+/*---------
+ |  Arrays
+ ----------*/
+static char truthy_arr[3][5] = {"true", "True", "TRUE"};
+
+/*----------
+ |  Helpers
+ -----------*/
+
+/**
+ * @brief get scope for ec or create new
+ *
+ * @note [Ruby definition] EXECUTION_CONTEXT[Fiber.current] ||=
+ * Contrast::Agent::Scope.new
+ *
+ * @return VALUE [Contrast::Agent::Scope]
+ */
+VALUE get_ec() {
+    VALUE ec, scope_inst, new_inst, keys, fiber;
+
+    ec = rb_const_get(scope_mod, rb_intern(rb_const_ec));
+    scope_inst = rb_hash_aref(ec, rb_fiber_current());
+    keys = rb_const_get(scope_mod, rb_intern(rb_const_ec_keys));
+    fiber = rb_fiber_current();
+
+    if (RB_TYPE_P(scope_inst, T_NIL)) {
+        new_inst = rb_new_c_scope();
+        rb_ary_push(keys, fiber);
+        rb_hash_aset(ec, fiber, new_inst);
+        return new_inst;
+    } else {
+        return scope_inst;
+    }
+}
+
+/**
+ * @brief  create new Scope class instance
+ *
+ * @return VALUE [Contrast::Agent::Scope]
+ */
+VALUE rb_new_c_scope() {
+    return rb_class_new_instance(0, 0, scope_klass);
+}
+
+/**
+ * @brief Increases scope value by 1.
+ *
+ * @param scope int
+ * @return int
+ */
+int scope_increase(int scope) {
+    int inc = scope;
+    inc = inc + 1;
+
+    return INT2FIX(inc);
+}
+
+/**
+ * @brief Decreases scope value by 1.
+ *
+ * @param scope int
+ * @return int
+ */
+int scope_decrease(int scope) {
+    int inc = scope;
+    inc = inc - 1;
+
+    return INT2FIX(inc);
+}
+
+/**
+ * @brief returns Qfalse or Qtrue if is in defined scope
+ *
+ * @param scope int
+ * @return VALUE
+ */
+VALUE is_in_scope(int scope) {
+    if (scope > 0) {
+        return Qtrue;
+    } else if (scope <= 0) {
+        return Qfalse;
+    }
+}
+
+/**
+ * @error: raise NoMethodError, "Scope '#{ name.inspect }' is not registered as
+ * a scope."
+ */
+void rb_raise_scope_no_method_err(const VALUE method_scope_sym) {
+    rb_raise(rb_eNoMethodError,
+             "Scope ':%" PRIsVALUE "' is not registered as a scope.",
+             rb_sym_to_s(method_scope_sym));
+}
+
+/*---------------------------------
+ |  @class Contrast::Agent::Scope
+ ----------------------------------*/
+
+/**
+ * @brief sets scope instance variables.
+ *
+ * @param self VALUE
+ * @param args VALUE
+ * @return VALUE self
+ *
+ * @note def initialize
+ *        @contrast_scope = 0
+ *        @deserialization_scope = 0
+ *        @split_scope = 0
+ *       end
+ */
+VALUE contrast_scope_klass_init(VALUE self, VALUE args) {
+    rb_iv_set(self, rb_iv_cntr_scope, contrast_scope_application_update());
+    rb_iv_set(self, rb_iv_dslr_scope, INT2FIX(0));
+    rb_iv_set(self, rb_iv_split_scope, INT2FIX(0));
+
+    return self;
+}
+
+/**
+ * @brief This function will determine if the Application Scope flag is set.
+ * If the value set is not valid the Contrast Scope with start with 0.
+ * If the value is validated, then the Contrast Scope will be set to 1.
+ * If the value is nil the Contrast Scope will be set as default => 0.
+ *
+ * To be valid app scope must be one of the truthy_arr: ["true", "True", "TRUE",
+ * "1"]
+ */
+VALUE contrast_scope_application_update() {
+    /**
+     * ENV variables are null-terminated strings.
+     *
+     * getenv() returns a pointer to a string within the environment list.
+     * The caller must take care not to modify this string,
+     * since that would change the environment of the process.
+     *
+     * [ Do not touch, do not free. We don't control it! ]
+     */
+    char *eVar = getenv(c_const_ctr_agent_app_scope);
+    VALUE app_scope = eVar;
+
+    /* check to see if the ENV variable is set */
+    if (RTEST(app_scope)) {
+        /* Application Scope is set*/
+        int i;
+        for (i = 0; i < sizeof(truthy_arr) / sizeof(truthy_arr[0]); i++) {
+            if (strcmp(eVar, truthy_arr[i]) == 0) {
+                return INT2FIX(1);
+            }
+        }
+        /* this covers all of the false values */
+        return INT2FIX(0);
+    } else {
+        /* Application Scope is not set ( NULL )*/
+        return INT2FIX(0);
+    }
+}
+
+/**
+ * @brief Check if we are in contrast scope.
+ * @note  @method in_contrast_scope?
+ * @param self VALUE
+ * @param args VALUE
+ * @return VALUE [Boolean] check if we are in contrast scope
+ *                    if the scope is above 0 return true.
+ *
+ * @note def in_contrast_scope?
+ *        @contrast_scope.positive?
+ *       end
+ */
+VALUE in_cntr_scope(VALUE self, VALUE args) {
+    return is_in_scope(FIX2INT(rb_iv_get(self, rb_iv_cntr_scope)));
+}
+
+/**
+ * @brief Enters contrast scope.
+ *
+ * @param self VALUE
+ * @param args VALUE
+ * @return VALUE [Integer] contrast scope increased.
+ *
+ * @note def enter_contrast_scope!
+ *        @contrast_scope += 1
+ *       end
+ */
+VALUE enter_cntr_scope(VALUE self, VALUE args) {
+    int scope = FIX2INT(rb_iv_get(self, rb_iv_cntr_scope));
+    rb_iv_set(self, rb_iv_cntr_scope, scope_increase(scope));
+
+    return rb_iv_get(self, rb_iv_cntr_scope);
+}
+
+/**
+ * @brief Exits contrast scope.
+ *
+ * @param self VALUE
+ * @param args VALUE
+ * @return VALUE [Integer] contrast scope decreased.
+ *
+ * @note def exit_contrast_scope!
+ *         @contrast_scope -= 1
+ *       end
+ */
+VALUE exit_cntr_scope(VALUE self, VALUE args) {
+    int scope = FIX2INT(rb_iv_get(self, rb_iv_cntr_scope));
+    rb_iv_set(self, rb_iv_cntr_scope, scope_decrease(scope));
+
+    return rb_iv_get(self, rb_iv_cntr_scope);
+}
+
+/**
+ * @brief Check if we are in deserialization scope.
+ *
+ * @param self VALUE
+ * @param args VALUE
+ * @return VALUE [Boolean] check if we are in deserialization scope
+ *                    if the scope is above 0 return true.
+ *
+ * @note  def in_deserialization_scope?
+ *         @deserialization_scope.positive?
+ *        end
+ */
+VALUE in_dslr_scope(VALUE self, VALUE args) {
+    return is_in_scope(FIX2INT(rb_iv_get(self, rb_iv_dslr_scope)));
+}
+
+/**
+ * @brief Enters deserialization scope.
+ *
+ * @param self VALUE
+ * @param args VALUE
+ * @return VALUE [Integer] deserialization scope increased.
+ *
+ * @note def enter_deserialization_scope!
+ *         @deserialization_scope += 1
+ *       end
+ */
+VALUE enter_dsrl_scope(VALUE self, VALUE args) {
+    int scope = FIX2INT(rb_iv_get(self, rb_iv_dslr_scope));
+    rb_iv_set(self, rb_iv_dslr_scope, scope_increase(scope));
+
+    return rb_iv_get(self, rb_iv_dslr_scope);
+}
+
+/**
+ * @brief Exits deserialization scope.
+ *
+ * @param self VALUE
+ * @param args VALUE
+ * @return VALUE [Integer] deserialization scope decreased.
+ *
+ * @note def enter_deserialization_scope!
+ *        @deserialization_scope += 1
+ *       end
+
+ */
+VALUE exit_dsrl_scope(VALUE self, VALUE args) {
+    int scope = FIX2INT(rb_iv_get(self, rb_iv_dslr_scope));
+    rb_iv_set(self, rb_iv_dslr_scope, scope_decrease(scope));
+
+    return rb_iv_get(self, rb_iv_dslr_scope);
+}
+
+/**
+ * @brief Check if we are in split scope.
+ *
+ * @param self VALUE
+ * @param args VALUE
+ * @return VALUE [Boolean] check if we are in split scope
+ *                    if the scope is above 0 return true.
+ *
+ * @note  def in_split_scope?
+ *          @split_scope.positive?
+ *        end
+ */
+VALUE in_split_scope(VALUE self, VALUE args) {
+    return is_in_scope(FIX2INT(rb_iv_get(self, rb_iv_split_scope)));
+}
+
+/**
+ * @brief Enters split scope.
+ *
+ * @param self VALUE
+ * @param args VALUE
+ * @return VALUE [Integer] split scope increased.
+ *
+ * @note def enter_split_scope!
+ *         @split_scope += 1
+ *       end
+ */
+VALUE enter_split_scope(VALUE self, VALUE args) {
+    int scope = FIX2INT(rb_iv_get(self, rb_iv_split_scope));
+    rb_iv_set(self, rb_iv_split_scope, scope_increase(scope));
+
+    return rb_iv_get(self, rb_iv_split_scope);
+}
+
+/**
+ * @brief Exits split scope.
+ *
+ * @param self VALUE
+ * @param args VALUE
+ * @return VALUE [Integer] split scope decreased.
+ *
+ * @note def enter_split_scope!
+ *         @split_scope -= 1
+ *       end
+ */
+VALUE exit_split_scope(VALUE self, VALUE args) {
+    int scope = FIX2INT(rb_iv_get(self, rb_iv_split_scope));
+    rb_iv_set(self, rb_iv_split_scope, scope_decrease(scope));
+
+    return rb_iv_get(self, rb_iv_split_scope);
+}
+
+/**
+ * @brief Returns split scope current depth.
+ *
+ * @param self VALUE
+ * @param args VALUE
+ * @return VALUE [Integer]
+ *
+ * @note def split_scope_depth
+ *        @split_scope
+ *       end
+ */
+VALUE split_scope_depth(VALUE self, VALUE args) {
+    return rb_iv_get(self, rb_iv_split_scope);
+}
+
+/**
+ * Static methods to be used, the cases are defined by the usage from the above
+ * methods if more methods are added - please extend the case statements as they
+ * are no longed dynamic.
+ */
+
+/**
+ * @brief Check if we are in specific scope.
+ *
+ * @param self VALUE
+ * @param method_scope_sym VALUE [Symbol] scope symbol representing scope to
+ * check.
+ * @return VALUE [Boolean] check if we are in passed scope.
+ * @error: NoMethodError
+ *
+ * @note def in_scope? name
+ *         case name
+ *         when :contrast
+ *           in_contrast_scope?
+ *         when :deserialization
+ *           in_deserialization_scope?
+ *         when :split
+ *           in_split_scope?
+ *         else
+ *           raise NoMethodError, "Scope '#{ name.inspect }' is not registered
+ * as a scope." end end
+ */
+VALUE scope_klass_in_scope(VALUE self, VALUE method_scope_sym) {
+    VALUE in_scope = Qnil;
+
+    if (method_scope_sym == rb_sym_contrast) {
+        /* in_contrast_scope? */
+        in_scope = in_cntr_scope(self, 0);
+    } else if (method_scope_sym == rb_sym_deserialization) {
+        /* in_deserialization_scope? */
+        in_scope = in_dslr_scope(self, 0);
+    } else if (method_scope_sym == rb_sym_split) {
+        /* in_split_scope? */
+        in_scope = in_split_scope(self, 0);
+    } else {
+        rb_raise_scope_no_method_err(method_scope_sym);
+    }
+
+    return in_scope;
+}
+
+/**
+ * @brief Enters specific scope.
+ *
+ * @param self VALUE
+ * @param method_scope_sym VALUE [Symbol] scope symbol representing scope to
+ * enter.
+ * @return VALUE [Boolean] entered scope value increased.
+ *
+ * @note def enter_scope! name
+ *         case name
+ *       when :contrast
+ *         enter_contrast_scope!
+ *       when :deserialization
+ *         enter_deserialization_scope!
+ *       when :split
+ *         enter_split_scope!
+ *       else
+ *         raise NoMethodError, "Scope '#{ name.inspect }' is not registered as
+ * a scope." end end
+ */
+VALUE scope_klass_enter_scope(VALUE self, VALUE method_scope_sym) {
+    VALUE enter_scope = Qnil;
+
+    if (method_scope_sym == rb_sym_contrast) {
+        enter_scope = enter_cntr_scope(self, 0);
+    } else if (method_scope_sym == rb_sym_deserialization) {
+        enter_scope = enter_dsrl_scope(self, 0);
+    } else if (method_scope_sym == rb_sym_split) {
+        enter_scope = enter_split_scope(self, 0);
+    } else {
+        rb_raise_scope_no_method_err(method_scope_sym);
+    }
+
+    return enter_scope;
+}
+
+/**
+ * @brief Exits specific scope.
+ *
+ * @param self VALUE
+ * @param method_scope_sym VALUE [Symbol] scope symbol representing scope to
+ * exit.
+ * @return VALUE [Boolean] entered scope value decreased.
+ *
+ * @note
+ * def exit_scope! name
+ *   case name
+ *    when :contrast
+ *      exit_contrast_scope!
+ *    when :deserialization
+ *      exit_deserialization_scope!
+ *    when :split
+ *      exit_split_scope!
+ *    else
+ *      raise NoMethodError, "Scope '#{ name.inspect }' is not registered as a
+ * scope." end end
+ */
+VALUE scope_klass_exit_scope(VALUE self, VALUE method_scope_sym) {
+    VALUE exit_scope = Qnil;
+
+    if (method_scope_sym == rb_sym_contrast) {
+        exit_scope = exit_cntr_scope(self, 0);
+    } else if (method_scope_sym == rb_sym_deserialization) {
+        exit_scope = exit_dsrl_scope(self, 0);
+    } else if (method_scope_sym == rb_sym_split) {
+        exit_scope = exit_split_scope(self, 0);
+    } else {
+        rb_raise_scope_no_method_err(method_scope_sym);
+    }
+
+    return exit_scope;
+}
+
+/*-----------------------------------------
+ |  @class Contrast::Components::Interface
+ ------------------------------------------*/
+
+/**
+ * @brief init set new scope for current fiber
+ *
+ * @param self VALUE
+ * @param args VALUE
+ * @return VALUE [Hash<Fiber => Scope>] ec
+ *
+ * @note EXECUTION_CONTEXT[Fiber.current] = Contrast::Agent::Scope.new
+ */
+VALUE contrast_scope_interface_init(VALUE self, VALUE args) {
+    VALUE ec = rb_const_get(scope_mod, rb_intern(rb_const_ec));
+    rb_hash_aset(ec, rb_fiber_current(), rb_new_c_scope());
+
+    return ec;
+}
+
+/**
+ * @brief This returns the scope governing the current execution context. Use
+ * this sparingly, preferring the instance & class methods to access and query
+ * scope, rather than interacting with the scope object directly.
+ *
+ * Alternative to Monitor => mutex.synchronize
+ * rb_mutex_new(void)
+ * rb_mutex_synchronize (VALUE mutex, VALUE(*func)(VALUE arg), VALUE arg)
+ * Mutex.synchronize do ... end goes here:
+ *
+ * @param self VALUE
+ * @param args VALUE
+ * @return VALUE
+ *
+ * @note def scope_for_current_ec
+ *         MONITOR.synchronize do
+ *           return EXECUTION_CONTEXT[Fiber.current] ||=
+ * Contrast::Agent::Scope.new end end
+ */
+VALUE contrast_scope_for_current_ec(VALUE self, VALUE args) {
+    /* synchronize */
+    VALUE mutex = rb_const_get(scope_mod, rb_intern(rb_const_mon));
+
+    return rb_mutex_synchronize(mutex, get_ec, 0);
+}
+
+/*--------------------------------------------------------
+ |  @module Contrast::Components::Scope::InstanceMethods
+ ---------------------------------------------------------*/
+
+/**
+ * @brief Iterates over the method policy's scopes and enters in each one.
+ *
+ * @param self VALUE
+ * @param scopes_to_enter VALUE [Array<Symbol>] Scopes form
+ * method_policy#scopes_to_enter for the scope current method policy
+ * @return VALUE [Array<Symbol>] scopes_to_enter
+ *
+ * @note def enter_method_scope! scopes_to_enter
+ *        scopes_to_enter.each do |scope|
+ *         enter_scope!(scope)
+ *       end
+ *      end
+ */
+VALUE inst_methods_enter_method_scope(VALUE self, VALUE scopes_to_enter) {
+    VALUE scopes_ary, scope;
+
+    scopes_ary = rb_ary_dup(scopes_to_enter);
+    scope = rb_ary_pop(scopes_ary);
+
+    while (!RB_TYPE_P(scope, T_NIL)) {
+        inst_methods_enter_scope(self, scope);
+        scope = rb_ary_pop(scopes_ary);
+    }
+
+    return scopes_to_enter;
+}
+
+/**
+ * @brief Iterates over the method policy's scopes and exits each one.
+ *
+ * @param self VALUE
+ * @param scopes_to_exit VALUE [Array<Symbol>] Scopes form
+ * method_policy#scopes_to_exit for the scope current method policy
+ * @return VALUE [Array<Symbol>] scopes_to_exit
+ *
+ * @note def enter_method_scope! scopes_to_exit
+ *         scopes_to_exit.each do |scope|
+ *          enter_scope!(scope)
+ *        end
+ *      end
+ */
+VALUE inst_methods_exit_method_scope(VALUE self, VALUE scopes_to_exit) {
+    VALUE scopes_ary, scope;
+
+    scopes_ary = rb_ary_dup(scopes_to_exit);
+    scope = rb_ary_pop(scopes_ary);
+
+    while (!RB_TYPE_P(scope, T_NIL)) {
+        inst_methods_exit_scope(self, scope);
+        scope = rb_ary_pop(scopes_ary);
+    }
+
+    return scopes_to_exit;
+}
+
+/**
+ * For the InstanceMethods we need to call all the scope methods from the
+ * current ec context All methods bellow are with same names as
+ * Contrast::Agent::Scope class with the difference that they act as forwarders:
+ *    def in_contrast_scope?
+ *      scope_for_current_ec.in_contrast_scope?
+ *    end
+ */
+
+/**
+ * @brief scope_for_current_ec.in_contrast_scope?
+ *
+ * @param self VALUE
+ * @param args VALUE
+ * @return VALUE
+ */
+VALUE inst_methods_in_cntr_scope(VALUE self, VALUE args) {
+    return is_in_scope(FIX2INT(
+        rb_iv_get(contrast_scope_for_current_ec(self, 0), rb_iv_cntr_scope)));
+}
+
+/**
+ * @brief scope_for_current_ec.enter_contrast_scope!
+ *
+ * @param self VALUE
+ * @param args VALUE
+ * @return VALUE
+ */
+VALUE inst_methods_enter_cntr_scope(VALUE self, VALUE args) {
+    int scope = FIX2INT(
+        rb_iv_get(contrast_scope_for_current_ec(self, 0), rb_iv_cntr_scope));
+    rb_iv_set(contrast_scope_for_current_ec(self, 0), rb_iv_cntr_scope,
+              scope_increase(scope));
+
+    return rb_iv_get(contrast_scope_for_current_ec(self, 0), rb_iv_cntr_scope);
+}
+
+/**
+ * @brief scope_for_current_ec.exit_contrast_scope!
+ *
+ * @param self VALUE
+ * @param args VALUE
+ * @return VALUE
+ */
+VALUE inst_methods_exit_cntr_scope(VALUE self, VALUE args) {
+    int scope = FIX2INT(
+        rb_iv_get(contrast_scope_for_current_ec(self, 0), rb_iv_cntr_scope));
+    rb_iv_set(contrast_scope_for_current_ec(self, 0), rb_iv_cntr_scope,
+              scope_decrease(scope));
+
+    return rb_iv_get(contrast_scope_for_current_ec(self, 0), rb_iv_cntr_scope);
+}
+
+/**
+ * @brief scope_for_current_ec.in_split_scope?
+ *
+ * @param self VALUE
+ * @param args VALUE
+ * @return VALUE
+ */
+VALUE inst_methods_in_split_scope(VALUE self, VALUE args) {
+    return is_in_scope(FIX2INT(
+        rb_iv_get(contrast_scope_for_current_ec(self, 0), rb_iv_split_scope)));
+}
+
+/**
+ * @brief scope_for_current_ec.enter_split_scope!
+ *
+ * @param self VALUE
+ * @param args VALUE
+ * @return VALUE
+ */
+VALUE inst_methods_enter_split_scope(VALUE self, VALUE args) {
+    int scope = FIX2INT(
+        rb_iv_get(contrast_scope_for_current_ec(self, 0), rb_iv_split_scope));
+
+    return rb_iv_set(contrast_scope_for_current_ec(self, 0), rb_iv_split_scope,
+                     scope_increase(scope));
+}
+
+/**
+ * @brief scope_for_current_ec.exit_split_scope!
+ *
+ * @param self VALUE
+ * @param args VALUE
+ * @return VALUE
+ */
+VALUE inst_methods_exit_split_scope(VALUE self, VALUE args) {
+    int scope = FIX2INT(
+        rb_iv_get(contrast_scope_for_current_ec(self, 0), rb_iv_split_scope));
+    rb_iv_set(contrast_scope_for_current_ec(self, 0), rb_iv_split_scope,
+              scope_decrease(scope));
+
+    return rb_iv_get(contrast_scope_for_current_ec(self, 0), rb_iv_split_scope);
+}
+
+/**
+ * @brief Get Deserialization scope iv.
+ *
+ * @param self
+ * @param args
+ * @return VALUE
+ */
+VALUE inst_methods_split_scope_depth(VALUE self, VALUE args) {
+    return rb_iv_get(contrast_scope_for_current_ec(self, 0), rb_iv_split_scope);
+}
+
+/**
+ * @brief scope_for_current_ec.in_deserialization_scope?
+ *
+ * @param self VALUE
+ * @param args VALUE
+ * @return VALUE
+ */
+VALUE inst_methods_in_dsrl_scope(VALUE self, VALUE args) {
+    return is_in_scope(FIX2INT(
+        rb_iv_get(contrast_scope_for_current_ec(self, 0), rb_iv_dslr_scope)));
+}
+
+/**
+ * @brief scope_for_current_ec.enter_deserialization_scope!
+ *
+ * @param self VALUE
+ * @param args VALUE
+ * @return VALUE
+ */
+VALUE inst_methods_enter_dsrl_scope(VALUE self, VALUE args) {
+    int scope = FIX2INT(
+        rb_iv_get(contrast_scope_for_current_ec(self, 0), rb_iv_dslr_scope));
+    rb_iv_set(contrast_scope_for_current_ec(self, 0), rb_iv_dslr_scope,
+              scope_increase(scope));
+
+    return rb_iv_get(contrast_scope_for_current_ec(self, 0), rb_iv_dslr_scope);
+}
+
+/**
+ * @brief scope_for_current_ec.exit_deserialization_scope!
+ *
+ * @param self VALUE
+ * @param args VALUE
+ * @return VALUE
+ */
+VALUE inst_methods_exit_dsrl_scope(VALUE self, VALUE args) {
+    int scope = FIX2INT(
+        rb_iv_get(contrast_scope_for_current_ec(self, 0), rb_iv_dslr_scope));
+    rb_iv_set(contrast_scope_for_current_ec(self, 0), rb_iv_dslr_scope,
+              scope_decrease(scope));
+
+    return rb_iv_get(contrast_scope_for_current_ec(self, 0), rb_iv_dslr_scope);
+}
+
+/**
+ * @brief Check to see if we are in scope by parameter symbol passed. Raises
+ * error if symbol is not valid.
+ *
+ * @param self VALUE
+ * @param method_scope_sym VALUE [Symbol]
+ * @error: rb_raise_scope_no_method_err [NoMethodError]
+ * @return VALUE
+ */
+VALUE inst_methods_in_scope(VALUE self, VALUE method_scope_sym) {
+    if (method_scope_sym == rb_sym_contrast) {
+        inst_methods_in_cntr_scope(self, 0);
+    } else if (method_scope_sym == rb_sym_deserialization) {
+        inst_methods_in_dsrl_scope(self, 0);
+    } else if (method_scope_sym == rb_sym_split) {
+        inst_methods_in_split_scope(self, 0);
+    } else {
+        rb_raise_scope_no_method_err(method_scope_sym);
+    }
+}
+
+/**
+ * @brief Enters scope by parameter symbol passed. Raises error if symbol is not
+ * valid.
+ *
+ * @param self VALUE
+ * @param method_scope_sym VALUE [Symbol]
+ * @error: rb_raise_scope_no_method_err [NoMethodError]
+ * @return VALUE
+ */
+VALUE inst_methods_enter_scope(VALUE self, VALUE method_scope_sym) {
+    if (method_scope_sym == rb_sym_contrast) {
+        inst_methods_enter_cntr_scope(self, 0);
+    } else if (method_scope_sym == rb_sym_deserialization) {
+        inst_methods_enter_dsrl_scope(self, 0);
+    } else if (method_scope_sym == rb_sym_split) {
+        inst_methods_enter_split_scope(self, 0);
+    } else {
+        rb_raise_scope_no_method_err(method_scope_sym);
+    }
+}
+
+/**
+ * @brief Exits scope by parameter symbol passed. Raises error if symbol is not
+ * valid.
+ *
+ * @param self VALUE
+ * @param method_scope_sym VALUE [Symbol]
+ * @error: rb_raise_scope_no_method_err [NoMethodError]
+ * @return VALUE
+ */
+VALUE inst_methods_exit_scope(VALUE self, VALUE method_scope_sym) {
+    if (method_scope_sym == rb_sym_contrast) {
+        inst_methods_exit_cntr_scope(self, 0);
+    } else if (method_scope_sym == rb_sym_deserialization) {
+        inst_methods_exit_dsrl_scope(self, 0);
+    } else if (method_scope_sym == rb_sym_split) {
+        inst_methods_exit_split_scope(self, 0);
+    } else {
+        rb_raise_scope_no_method_err(method_scope_sym);
+    }
+}
+
+/**
+ * @brief Sweeps and cleans any unused Execution Contexts.
+ * TODO: RUBY-534, #sweep_dead_ecs compensates for a lack of weak tables. when
+ * we can use WeakRef, we should investigate removing this call and instead use
+ * the WeakRef for the Execution Context's Keys or using our Finalizers Hash for
+ * Fibers
+ *
+ * @param self VALUE
+ * @param args VALUE
+ * @return VALUE
+ */
+VALUE scope_mod_sweep_dead_ecs(VALUE self, VALUE args) {
+    VALUE mutex, ec, ec_keys, key, test;
+
+    mutex = rb_const_get(scope_mod, rb_intern(rb_const_mon));
+    ec = rb_const_get(scope_mod, rb_intern(rb_const_ec));
+    ec_keys = rb_const_get(scope_mod, rb_intern(rb_const_ec_keys));
+
+    /* Check if the key is dead (terminated fiber) and delete if true. */
+    int i = 0;
+    int size = rb_hash_size(ec_keys);
+
+    for (i = 0; i < size; ++i) {
+        key = rb_ary_entry(ec_keys, i);
+        test = key;
+        if (!RB_TYPE_P(key, T_NIL)) {
+            if (!rb_fiber_alive_p(key)) {
+                rb_hash_delete(ec, key);
+            }
+        }
+    }
+
+    return ec;
+}
+
+void Init_cs__scope() {
+    /* ivs */
+    rb_iv_cntr_scope = "@contrast_scope";
+    rb_iv_dslr_scope = "@deserialization_scope";
+    rb_iv_split_scope = "@split_scope";
+
+    /* constants */
+    rb_const_mon = "MONITOR";
+    rb_const_ec = "EXECUTION_CONTEXT";
+    rb_const_ec_keys = "EC_KEYS";
+    c_const_ctr_agent_app_scope = "CONTRAST__AGENT__RUBY__APPLICATION_SCOPE";
+
+    /* Symbols */
+    rb_sym_scope_mod = rb_intern("Scope");
+    rb_sym_contrast = ID2SYM(rb_intern("contrast"));
+    rb_sym_deserialization = ID2SYM(rb_intern("deserialization"));
+    rb_sym_split = ID2SYM(rb_intern("split"));
+
+    /* method names */
+    rb_method_name_init = "initialize";
+    rb_method_name_in_scope = "in_scope?";
+    rb_method_name_enter_scope = "enter_scope!";
+    rb_method_name_exit_scope = "exit_scope!";
+    rb_method_name_scope_for_current_ec = "scope_for_current_ec";
+    rb_method_name_in_cntr_scope = "in_contrast_scope?";
+    rb_method_name_enter_cntr_scope = "enter_contrast_scope!";
+    rb_method_name_exit_cntr_scope = "exit_contrast_scope!";
+    rb_method_name_in_dslr_scope = "in_deserialization_scope?";
+    rb_method_name_enter_dslr_scope = "enter_deserialization_scope!";
+    rb_method_name_exit_dslr_scope = "exit_deserialization_scope!";
+    rb_method_name_in_split_scope = "in_split_scope?";
+    rb_method_name_enter_split_scope = "enter_split_scope!";
+    rb_method_name_exit_split_scope = "exit_split_scope!";
+    rb_method_name_split_scope_depth = "split_scope_depth";
+
+    /* Define the new scope modules and objects */
+    contrast = rb_define_module("Contrast");
+    /* contrast::Agent */
+    agent = rb_define_module_under(contrast, "Agent");
+    /* components => Contrast::Components */
+    components = rb_define_module_under(contrast, "Components");
+    /* scope_mod => Contrast::Components::Scope */
+    scope_mod = rb_define_module_under(components, "Scope");
+    /* scope_interface => Contrast::Components::Scope::Interface */
+    scope_interface = rb_define_class_under(scope_mod, "Interface", rb_cObject);
+    /* scope_inst_methods => Contrast::Components::Scope::InstanceMethods */
+    scope_inst_methods = rb_define_module_under(scope_mod, "InstanceMethods");
+    /* scope_klass => Contrast::Agent::Scope */
+    scope_klass = rb_define_class_under(agent, "Scope", rb_cObject);
+
+    /**
+     * @class Contrast::Agent::Scope
+     */
+
+    /* Instance methods: */
+    rb_define_method(scope_klass, rb_method_name_init,
+                     contrast_scope_klass_init, 0);
+    rb_define_method(scope_klass, rb_method_name_in_cntr_scope, in_cntr_scope,
+                     0);
+    rb_define_method(scope_klass, rb_method_name_enter_cntr_scope,
+                     enter_cntr_scope, 0);
+    rb_define_method(scope_klass, rb_method_name_exit_cntr_scope,
+                     exit_cntr_scope, 0);
+    rb_define_method(scope_klass, rb_method_name_in_dslr_scope, in_dslr_scope,
+                     0);
+    rb_define_method(scope_klass, rb_method_name_enter_dslr_scope,
+                     enter_dsrl_scope, 0);
+    rb_define_method(scope_klass, rb_method_name_exit_dslr_scope,
+                     exit_dsrl_scope, 0);
+    rb_define_method(scope_klass, rb_method_name_in_split_scope, in_split_scope,
+                     0);
+    rb_define_method(scope_klass, rb_method_name_enter_split_scope,
+                     enter_split_scope, 0);
+    rb_define_method(scope_klass, rb_method_name_exit_split_scope,
+                     exit_split_scope, 0);
+    rb_define_method(scope_klass, rb_method_name_split_scope_depth,
+                     split_scope_depth, 0);
+    rb_define_method(scope_klass, rb_method_name_in_scope, scope_klass_in_scope,
+                     1);
+    rb_define_method(scope_klass, rb_method_name_enter_scope,
+                     scope_klass_enter_scope, 1);
+    rb_define_method(scope_klass, rb_method_name_exit_scope,
+                     scope_klass_exit_scope, 1);
+
+    /**
+     * @class Contrast::Components::Interface
+     */
+
+    /* Interface#initialize */
+    rb_define_method(scope_interface, rb_method_name_init,
+                     contrast_scope_interface_init, 0);
+    /* Interface#scope_for_current_ec */
+    rb_define_method(scope_interface, rb_method_name_scope_for_current_ec,
+                     contrast_scope_for_current_ec, 0);
+
+    /**
+     * @module Contrast::Components::Scope
+     */
+
+    /* Constants */
+
+    /* Contrast::Components::Scope::EC_KEYS */
+    rb_const_set(scope_mod, rb_intern(rb_const_ec_keys), rb_ary_new());
+    /* Contrast::Components::Scope::EXECUTION_CONTEXT => {} */
+    rb_define_const(scope_mod, rb_const_ec, rb_hash_new());
+    /* Contrast::Components::Scope::MONITOR => Mutex.new.freeze */
+    rb_define_const(scope_mod, rb_const_mon, rb_mutex_new());
+
+    /**
+     * @module Contrast::Components::Scope::InstanceMethods
+     */
+
+    /* InstanceMethods#scope_for_current_ec */
+    rb_define_method(scope_inst_methods, rb_method_name_scope_for_current_ec,
+                     contrast_scope_for_current_ec, 0);
+    /* Forwarders */
+    rb_define_method(scope_inst_methods, rb_method_name_in_cntr_scope,
+                     inst_methods_in_cntr_scope, 0);
+    rb_define_method(scope_inst_methods, rb_method_name_enter_cntr_scope,
+                     inst_methods_enter_cntr_scope, 0);
+    rb_define_method(scope_inst_methods, rb_method_name_exit_cntr_scope,
+                     inst_methods_exit_cntr_scope, 0);
+    rb_define_method(scope_inst_methods, rb_method_name_in_dslr_scope,
+                     inst_methods_in_dsrl_scope, 0);
+    rb_define_method(scope_inst_methods, rb_method_name_enter_dslr_scope,
+                     inst_methods_enter_dsrl_scope, 0);
+    rb_define_method(scope_inst_methods, rb_method_name_exit_dslr_scope,
+                     inst_methods_exit_dsrl_scope, 0);
+    rb_define_method(scope_inst_methods, rb_method_name_in_split_scope,
+                     inst_methods_in_split_scope, 0);
+    rb_define_method(scope_inst_methods, rb_method_name_enter_split_scope,
+                     inst_methods_enter_split_scope, 0);
+    rb_define_method(scope_inst_methods, rb_method_name_exit_split_scope,
+                     inst_methods_exit_split_scope, 0);
+    rb_define_method(scope_inst_methods, rb_method_name_split_scope_depth,
+                     inst_methods_split_scope_depth, 0);
+    rb_define_method(scope_inst_methods, rb_method_name_in_scope,
+                     inst_methods_in_scope, 1);
+    rb_define_method(scope_inst_methods, rb_method_name_enter_scope,
+                     inst_methods_enter_scope, 1);
+    rb_define_method(scope_inst_methods, rb_method_name_exit_scope,
+                     inst_methods_exit_scope, 1);
+
+    /**
+     * @module Contrast::Components::Scope
+     */
+    rb_define_singleton_method(scope_mod, "sweep_dead_ecs",
+                               scope_mod_sweep_dead_ecs, 0);
+    /* Contrast::Components::Scope#cs__with_app_scope? */
+    rb_define_singleton_method(scope_mod, "cs__with_app_scope?",
+                               contrast_scope_application_update, 0);
+
+    /**
+     * @module Contrast::Components::Scope::InstanceMethods
+     */
+    rb_define_method(scope_inst_methods, "contrast_enter_method_scopes!",
+                     inst_methods_enter_method_scope, 1);
+    rb_define_method(scope_inst_methods, "contrast_exit_method_scopes!",
+                     inst_methods_exit_method_scope, 1);
+}