delfos 0.0.1 → 0.0.2.pre.rc2

data/lib/delfos/method_logging/call_site_parsing.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-require "binding_of_caller"
-
-module Delfos
-  module MethodLogging
-    class CallSiteParsing
-      # This magic number is based on the implementation within this file.
-      # If the line with `call_site_binding.of_caller(stack_index + STACK_OFFSET).receiver`
-      # is moved up or down the call stack a test fails and we have to change `STACK_OFFSET`
-      STACK_OFFSET = 5
-
-      attr_reader :stack, :call_site_binding
-
-      def initialize(stack, call_site_binding, stack_offset: nil)
-        @stack             = stack
-        @call_site_binding = call_site_binding
-        @stack_offset      = stack_offset
-      end
-
-      def perform
-        file, line_number, method_name = method_details
-        return unless current && file && line_number && method_name
-
-        CodeLocation.new(object: object,
-                         method_name: method_name.to_s,
-                         class_method: class_method,
-                         file: file,
-                         line_number: line_number)
-      end
-
-      private
-
-      def class_method
-        object.is_a? Module
-      end
-
-      def current
-        stack.detect do |s|
-          file = s.split(":")[0]
-          Delfos::MethodLogging.include_file?(file)
-        end
-      end
-
-      def object
-        @object ||= call_site_binding.of_caller(stack_index + stack_offset).receiver
-      end
-
-      def stack_offset
-        @stack_offset ||= STACK_OFFSET
-      end
-
-      def stack_index
-        stack.index { |c| c == current }
-      end
-
-      METHOD_NAME_REGEX = /`(.*)'$/
-
-      def method_details
-        return unless current
-        file, line_number, rest, more = current.split(":")
-
-        rest = more.nil? ?  rest : "#{rest}:#{more}"
-        method_name = rest.match(METHOD_NAME_REGEX)&.[](1)
-
-        return unless method_name && file && line_number
-
-        method_name = method_name.delete("`")
-        method_name = method_name.delete("'")
-
-        [file, line_number.to_i, method_name]
-      end
-    end
-  end
-end

data/lib/delfos/method_logging/code_location.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-require_relative "call_site_parsing"
-
-module Delfos
-  module MethodLogging
-    class CodeLocation
-      class << self
-        def from_call_site(stack, call_site_binding)
-          CallSiteParsing.new(stack, call_site_binding).perform
-        end
-
-        def from_called(object, called_method, class_method)
-          file, line_number = called_method.source_location
-          return unless file && line_number
-
-          new(object: object, method_name: called_method.name.to_s,
-              class_method: class_method, file: file, line_number: line_number)
-        end
-
-      end
-
-      attr_reader :object, :method_name, :class_method, :line_number
-
-      def initialize(object:, method_name:, class_method:, file:, line_number:)
-        @object       = object
-        @method_name  = method_name
-        @class_method = class_method
-        @line_number  = line_number.to_i
-        @file         = file
-      end
-
-      def file
-        relative_filename @file
-      end
-
-      def klass
-        object.is_a?(Class) ? object : object.class
-      end
-
-      def method_definition_file
-        relative_filename(method_definition&.first || fallback_method_definition_file)
-      end
-
-      def method_definition_line
-        method_definition&.last&.to_i || fallback_method_definition_line_number
-      end
-
-      def method_type
-        class_method ? "ClassMethod" : "InstanceMethod"
-      end
-
-      private
-
-      def relative_filename(f)
-        return unless f
-        file = f.to_s
-
-        Delfos.application_directories.map do |d|
-          file = relative_path(file, d)
-        end
-
-        file
-      end
-
-      def relative_path(file, dir)
-        match = dir.to_s.split("/")[0..-2].join("/")
-
-        if file[match]
-          file = file.gsub(match, "").
-                 gsub(%r{^/}, "")
-        end
-
-        file
-      end
-
-      def fallback_method_definition_file
-        @file
-      end
-
-      def fallback_method_definition_line_number
-        0
-      end
-
-      def method_definition
-        @method_definition ||= Patching::MethodCache.find(klass: klass, method_name: method_name, class_method: class_method)&.source_location
-      end
-    end
-  end
-end

data/lib/delfos/method_logging/method_parameters.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-require "delfos/patching/method_cache"
-
-module Delfos
-  module MethodLogging
-    class MethodParameters
-      attr_reader :block
-
-      def initialize(args=[], keyword_args=nil, block=nil)
-        @raw_args         = args
-        @raw_keyword_args = keyword_args
-        @block            = block
-      end
-
-      def args
-        @args ||= calculate_args(@raw_args)
-      end
-
-      def argument_classes
-        (args + keyword_args).uniq
-      end
-
-      def keyword_args
-        @keyword_args ||= calculate_args(@raw_keyword_args.values)
-      end
-
-      def as_json(*params)
-        {arguments: args, keyword_arguments: keyword_args}
-      end
-
-      private
-
-      def calculate_args(arguments)
-        arguments.
-          map { |o| o.is_a?(Class) ? o : o.class }.
-          select { |k| keep?(k) }
-      end
-
-      def keep?(klass)
-        files_for(klass).
-          any? { |f| record?(f) }
-      end
-
-      def files_for(klass)
-        Patching::MethodCache.files_for(klass)
-      end
-
-      def record?(f)
-        Delfos::MethodLogging.include_file?(f)
-      end
-    end
-  end
-end

data/lib/delfos/neo4j/call_stack_query.rb

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-module Delfos
-  module Neo4j
-    class CallStackQuery
-      def initialize(call_sites, execution_count)
-        @call_sites = call_sites
-
-        @execution_count = execution_count
-      end
-
-      def query
-        map_call_sites do |c, i|
-          call_site_query(c, i)
-        end.join("\n")
-      end
-
-      def params
-        params = {}
-
-        map_call_sites do |c, i|
-          params.merge!(call_site_params(c, i))
-        end
-
-        params
-      end
-
-      private
-
-      attr_reader :call_sites, :execution_count
-
-      def map_call_sites
-        call_sites.compact.map.with_index do |c, i|
-          yield c, i
-        end
-      end
-
-      def call_site_query(_cs, i)
-        <<-QUERY
-          MERGE
-
-          (
-            k#{i}:Class { name: {klass#{i}} }
-          )
-
-          - [:OWNS] ->
-
-          (
-            m#{i} :Method {
-              type: {method_type#{i}},
-              name: {method_name#{i}},
-              file: {method_definition_file#{i}},
-              line_number: {method_definition_line#{i}}}
-          )
-
-          MERGE
-
-          (m#{i})
-
-          -[:CONTAINS]->
-
-          (cs#{i}:CallSite {file: {file#{i}}, line_number: {line_number#{i}}})
-
-          MERGE (e#{i}:CallStack{number: {execution_count#{i}}})
-
-          MERGE (e#{i})
-            -
-            [:STEP {number: {step_number#{i}}}]
-            ->
-          (cs#{i})
-        QUERY
-      end
-
-      def call_site_params(cs, i)
-        {
-          "klass#{i}"                  => cs.klass.to_s,
-          "method_name#{i}"            => cs.method_name,
-          "method_type#{i}"            => cs.method_type,
-          "method_definition_file#{i}" => cs.method_definition_file,
-          "execution_count#{i}"        => execution_count,
-          "method_definition_line#{i}" => cs.method_definition_line,
-          "file#{i}"                   => cs.file,
-          "line_number#{i}"            => cs.line_number,
-          "step_number#{i}"            => i + 1,
-        }
-      end
-    end
-  end
-end

data/lib/delfos/neo4j/informer.rb

@@ -1,128 +0,0 @@
-# frozen_string_literal: true
-
-module Delfos
-  module Neo4j
-    class Informer
-      def save_call_stack(call_sites, execution_number)
-        q = Neo4j::CallStackQuery.new(call_sites, execution_number)
-        Neo4j.execute(q.query, q.params)
-      end
-
-      def log(args, call_site, called_code)
-        query = query_for(args, call_site, called_code)
-        params = params_for(args, call_site, called_code)
-
-        Neo4j.execute(query, params)
-      end
-
-      def params_for(args, call_site, called_code)
-        assign_query_variables(args, call_site, called_code)
-
-        params = query_variables.each_with_object({}) do |(klass, name), object|
-          object[name] = klass.to_s
-        end
-
-        params["m1_type"]        = call_site.method_type
-        params["m1_name"]        = call_site.method_name
-        params["m1_file"]        = call_site.method_definition_file
-        params["m1_line_number"] = call_site.method_definition_line
-
-        params["cs_file"]        = call_site.file
-        params["cs_line_number"] = call_site.line_number
-
-        params["m2_type"]        = called_code.method_type
-        params["m2_name"]        = called_code.method_name
-        params["m2_file"]        = called_code.method_definition_file
-        params["m2_line_number"] = called_code.method_definition_line
-
-        params
-      end
-
-      def query_for(args, call_site, called_code)
-        assign_query_variables(args, call_site, called_code)
-
-        klasses_query = query_variables.map do |_klass, name|
-          "MERGE (#{name}:Class {name: {#{name}}})"
-        end.join("\n")
-
-        <<-QUERY
-          #{klasses_query}
-
-          MERGE (#{query_variable(call_site.klass)}) - [:OWNS] ->
-            #{method_node("m1")}
-
-          MERGE (m1) - [:CONTAINS] ->
-            (cs:CallSite
-              {
-                file: {cs_file},
-                line_number: {cs_line_number}
-              }
-            )
-
-          MERGE (#{query_variable(called_code.klass)}) - [:OWNS] ->
-            #{method_node("m2")}
-
-          MERGE (cs) - [:CALLS] -> (m2)
-
-          #{args_query args}
-        QUERY
-      end
-
-      def assign_query_variables(args, call_site, called_code)
-        klasses = [call_site.klass, called_code.klass] + args.argument_classes
-
-        klasses.uniq.each do |k|
-          query_variables.assign(k, "k")
-        end
-      end
-
-      def method_node(id)
-        <<-NODE
-          (#{id}:Method
-            {
-              type: {#{id}_type},
-              name: {#{id}_name},
-              file: {#{id}_file},
-              line_number: {#{id}_line_number}
-            }
-          )
-        NODE
-      end
-
-      def args_query(args)
-        query_text = args.argument_classes.map do |k|
-          name = query_variable(k)
-          "MERGE (cs) - [:ARG] -> (#{name})"
-        end
-
-        query_text.join("\n")
-      end
-
-      def query_variable(k)
-        query_variables[k.to_s]
-      end
-
-      def query_variables
-        @query_variables ||= QueryVariables.new
-      end
-
-      class QueryVariables < Hash
-        def initialize(*args)
-          super(*args)
-          @counters = Hash.new(1)
-        end
-
-        def assign(klass, prefix)
-          klass = klass.to_s
-          val = self[klass]
-          return val if val
-
-          "#{prefix}#{@counters[prefix]}".tap do |v|
-            self[klass] = v
-            @counters[prefix] += 1
-          end
-        end
-      end
-    end
-  end
-end

data/lib/delfos/patching/basic_object.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-require_relative "method_override"
-
-class BasicObject
-  def self.method_added(name)
-    ::Delfos::Patching::MethodOverride.setup(self, name, private_instance_methods, class_method: false)
-  end
-
-  def self.singleton_method_added(name)
-    return if %i(define_method extended included inherited method_added singleton_method_added).include?(name)
-
-    ::Delfos::Patching::MethodOverride.setup(self, name, private_methods, class_method: true)
-  end
-end