delfos 0.0.1 → 0.0.2.pre.rc2

data/lib/delfos/patching/basic_object_remove.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-class BasicObject
-  def self.method_added(*_args); end
-
-  def self.singleton_method_added(*_args); end
-end

data/lib/delfos/patching/method_cache.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-require "Forwardable" unless defined? Forwardable
-
-module Delfos
-  module Patching
-    class MethodCache
-      class << self
-        extend Forwardable
-
-        def_delegators :instance,
-          :files_for,
-          :append,
-          :find
-
-        def reset!
-          @instance = nil
-        end
-
-        def instance
-          @instance ||= new
-        end
-
-        def each_method
-          instance.send(:added_methods).each do |klass, methods|
-            methods.each do |k, m|
-              class_method = !!(k[/^ClassMethod_/])
-              yield klass, m, class_method
-            end
-          end
-        end
-      end
-
-      def initialize
-        @added_methods = {}
-      end
-
-      def files_for(klass)
-        fetch(klass).
-          values.
-          map(&:source_location).
-          compact.
-          map(&:first).
-          compact.
-          uniq
-      end
-
-      def append(klass:, method:)
-        class_method = method.respond_to?(:receiver) && method.receiver.is_a?(Class)
-        key = key_for(class_method, method.name)
-        m = fetch(klass)[key]
-
-        fetch(klass)[key] = method if m.nil?
-      end
-
-      def find(klass:, method_name:, class_method:)
-        key = key_for(class_method, method_name)
-
-        fetch(klass)[key]
-      end
-
-      private
-
-      attr_reader :added_methods
-
-      def key_for(class_method, method_name)
-        class_method ? "ClassMethod_#{method_name}" : "InstanceMethod_#{method_name}"
-      end
-
-      def fetch(klass)
-        # Find method definitions defined in klass or its ancestors
-        super_klass = klass.ancestors.detect do |k|
-          (fetch_without_default(k) || {}).values.length.positive?
-        end
-
-        added_methods[(super_klass || klass).to_s] ||= {}
-      end
-
-      def fetch_without_default(klass)
-        added_methods[klass.to_s]
-      end
-    end
-  end
-end

data/lib/delfos/patching/method_override.rb

@@ -1,148 +0,0 @@
-# frozen_string_literal: true
-
-require "delfos/method_logging"
-require "delfos/call_stack"
-
-require_relative "module_defining_methods"
-require_relative "unstubber"
-
-module Delfos
-  module Patching
-    MUTEX = Mutex.new
-
-    class MethodOverride
-      include ModuleDefiningMethods
-
-      class << self
-        def setup(klass, name, private_methods, class_method:)
-          return if skip_meta_programming_defined_method?
-
-          MUTEX.synchronize do
-            return if Thread.current[:__delfos_disable_patching]
-          end
-
-          instance = new(klass, name, private_methods, class_method)
-
-          instance.ensure_method_recorded_once!
-        end
-
-        META_PROGRAMMING_REGEX = /`define_method'\z|`attr_accessor'\z|`attr_reader'\z|`attr_writer'\z/
-
-        def skip_meta_programming_defined_method?
-          stack = caller.dup
-
-          i = stack.index do |l|
-            l["delfos/patching/basic_object.rb"]
-          end
-
-          return unless i
-
-          result = stack[i + 1][META_PROGRAMMING_REGEX]
-
-          return unless result
-
-          Delfos.logger.debug "Skipping setting up delfos logging of method defined by #{result} #{stack[i+1]}"
-          true
-        end
-
-
-      end
-
-      attr_reader :klass, :name, :private_methods, :class_method
-
-      def initialize(klass, name, private_methods, class_method)
-        @klass           = klass
-        @name            = name
-        @private_methods = private_methods
-        @class_method    = class_method
-        original_method # ensure memoized method is the original not the overridden one
-      end
-
-      def ensure_method_recorded_once!
-        record_method! { setup }
-      end
-
-
-      # Redefine the method at runtime to enabling logging to Neo4j
-      def setup
-        cm = class_method
-        with_stack = method(:with_stack)
-        method_name = name
-        om = original_method
-
-        mod = module_definition(klass, name, class_method) do
-          define_method(method_name) do |*args, **kw_args, &block|
-            stack = caller.dup
-            caller_binding = binding.dup
-            parameters = Delfos::MethodLogging::MethodParameters.new(args, kw_args, block)
-
-            call_site = Delfos::MethodLogging::CodeLocation.from_call_site(stack, caller_binding)
-
-            if call_site
-              Delfos::MethodLogging.log(call_site, self, om, cm, parameters)
-            end
-
-            with_stack.call(call_site) do
-              if !kw_args.empty?
-                super(*args, **kw_args, &block)
-              else
-                super(*args, &block)
-              end
-            end
-          end
-        end
-        return unless mod
-
-        if class_method
-          klass.prepend mod
-        else
-          klass.instance_eval { prepend mod }
-        end
-      end
-
-      def with_stack(call_site)
-        return yield unless call_site
-
-        begin
-          CallStack.push(call_site)
-          yield
-        ensure
-          CallStack.pop
-        end
-      end
-
-      def original_method
-        @original_method ||= if class_method
-                               klass.method(name)
-                             else
-                               klass.instance_method(name)
-                             end
-      end
-
-      private
-
-      def record_method!
-        return true if bail?
-        MethodCache.append(klass: klass, method: original_method)
-
-        yield
-      end
-
-      def bail?
-        method_has_been_added? || private_method? || exclude?
-      end
-
-      def method_has_been_added?
-        MethodCache.find(klass: klass, class_method: class_method, method_name: name)
-      end
-
-      def private_method?
-        private_methods.include?(name.to_sym)
-      end
-
-      def exclude?
-        ::Delfos::MethodLogging.exclude?(original_method)
-      end
-    end
-  end
-end

data/lib/delfos/patching/module_defining_methods.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-module Delfos
-  module Patching
-    # containers for the individual modules created to log each method call
-    module ClassMethodLogging
-    end
-
-    module InstanceMethodLogging
-    end
-
-    module ModuleDefiningMethods
-      def module_definition(klass, method_name, class_method, &block)
-        definer = ModuleDefiner.new(klass, method_name, class_method)
-
-        if block_given?
-          definer.perform(&block) 
-        else
-          definer.perform
-        end
-      end
-    end
-
-    class ModuleDefiner
-      attr_reader :klass, :method_name, :class_method
-
-      def initialize(klass, method_name, class_method)
-        @klass, @method_name, @class_method = klass, method_name, class_method
-      end
-
-      def perform(&block)
-        safe_method_name = safe_method_name()
-        safe_class_name = safe_class_name()
-        module_type = class_method ? "ClassMethodLogging" : "InstanceMethodLogging"
-        find_or_create = method(:find_or_create)
-
-        m = nil
-        Patching.const_get(module_type).instance_eval do
-          namespace = find_or_create.call(self, safe_class_name)
-
-          m = find_or_create.call(namespace, safe_method_name)
-
-          m.class_eval(&block) if block_given?
-
-          m
-        end
-      end
-
-      private
-
-      def safe_class_name
-        module_safe_name(klass.name || klass.to_s)
-      end
-
-      def safe_method_name
-        module_safe_name(method_name.to_s)
-      end
-
-      def find_or_create(container, module_name)
-        module_name = module_name.tr(":", "_")
-
-        result = container.const_get(module_name)
-
-        # E.g. finding `::A' instead of Delfos::Patching::InstanceMethodLogging::A
-        if result == klass || result.name[module_name] == result.name
-          create(container, module_name)
-        else
-          result
-        end
-      rescue NameError => e
-        raise unless e.message[module_name]
-        create(container, module_name)
-      end
-
-      def create(container, module_name)
-        m = Module.new
-
-        container.const_set(module_name, m)
-        return m
-      rescue Exception => e
-        m
-      end
-
-      def module_safe_name(string, _uppercase_first_letter = true)
-        string = string.sub(/^[a-z\d]*/) { $&.capitalize }
-
-        string.
-          gsub(/(?:_|(\/))([a-z\d]*)/) { "#{Regexp.last_match(1)}#{Regexp.last_match(2).capitalize}" }.
-          gsub("/", "::").
-          gsub(/\=/, "Equals").
-          gsub(/\<\=\>/, "Spaceship").
-          gsub(/\<\=/, "LessThanOrEqualTo").
-          gsub(/\>\=/, "GreaterThanOrEqualTo").
-          gsub(/\#\<Class\:0x(.*)\>/) { "AnonymousClass_#{Regexp.last_match(1)}" }.
-          gsub(/\>/, "GreaterThan").
-          gsub(/\</, "LessThan").
-          gsub(/!\~/, "NotMatchOperator").
-          gsub(/\~/, "MatchOperator").
-          gsub(/\?/, "QuestionMark").
-          gsub(/\!$/, "Bang").
-          gsub(/\+/, "Plus").
-          gsub(/\[\]/, "SquareBrackets")
-      end
-    end
-  end
-end

data/lib/delfos/patching/unstubber.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-module Delfos
-  module Patching
-    class Unstubber
-      extend ModuleDefiningMethods
-
-      def self.unstub_all!
-        MUTEX.synchronize do
-          Thread.current[:__delfos_disable_patching] = true
-        end
-
-        MethodCache.each_method do |klass_name, method, class_method|
-          klass = eval(klass_name)
-
-          unstub!(klass, method.name, class_method)
-        end
-
-        MUTEX.synchronize do
-          Thread.current[:__delfos_disable_patching] = false
-        end
-      end
-
-      def self.unstub!(klass, method_name, class_method)
-        module_definition(klass, method_name, class_method) do |m|
-          begin
-            remove_method :"#{method_name}"
-          rescue NameError => e
-            raise unless e.message["method `#{method_name}' not defined in"]
-          end
-        end
-      end
-    end
-  end
-end