delfos 0.0.1.pre.beta

data/lib/delfos/method_logging.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+require "pathname"
+require "forwardable"
+require "binding_of_caller"
+require_relative "common_path"
+require_relative "method_logging/klass_determination"
+require_relative "method_logging/code_location"
+require_relative "method_logging/args"
+require_relative "execution_chain"
+
+module Delfos
+  class << self
+    attr_accessor :logger, :application_directories
+  end
+
+  class ApplicationDirectoriesNotDefined < StandardError
+    def initialize(*_args)
+      super "Please set Delfos.application_directories"
+    end
+  end
+
+  module MethodLogging
+    class << self
+      def check_setup!
+        raise Delfos::ApplicationDirectoriesNotDefined unless Delfos.application_directories
+      end
+
+      def log(called_object,
+        args, keyword_args, _block,
+        class_method,
+        stack, call_site_binding,
+        called_method)
+        check_setup!
+
+        call_site = CodeLocation.from_call_site(stack, call_site_binding)
+        Delfos::ExecutionChain.push(call_site)
+
+        return unless call_site
+
+        args = Args.new(args.dup, keyword_args.dup)
+
+        called_code = CodeLocation.from_called(called_object, called_method, class_method)
+
+        Delfos.logger.debug(args, call_site, called_code)
+      end
+
+      def include_any_path_in_logging?(paths)
+        paths.inject(false) do |result, path|
+          result || include_file_in_logging?(path)
+        end
+      end
+
+      def exclude_from_logging?(method)
+        file, _line_number = method.source_location
+        return true unless file
+
+        exclude_file_from_logging?(File.expand_path(file))
+      end
+
+      def include_file_in_logging?(file)
+        !exclude_file_from_logging?(file)
+      end
+
+      def exclude_file_from_logging?(file)
+        check_setup!
+        path = Pathname.new(File.expand_path file)
+        !CommonPath.included_in?(path, Delfos.application_directories)
+      end
+    end
+  end
+end

data/lib/delfos/method_logging/args.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+require_relative "../../delfos"
+require_relative "../common_path"
+require_relative "klass_determination"
+
+module Delfos
+  module MethodLogging
+    class Args
+      include KlassDetermination
+
+      def initialize(args, keyword_args)
+        @raw_args = args
+        @raw_keyword_args = keyword_args
+      end
+
+      def args
+        @args ||= calculate_args(@raw_args)
+      end
+
+      def calculate_args(args)
+        klass_file_locations(args).select do |_klass, locations|
+          Delfos::MethodLogging.include_any_path_in_logging?(locations)
+        end.map(&:first)
+      end
+
+      def keyword_args
+        @keyword_args ||= calculate_args(@raw_keyword_args.values)
+      end
+
+      def klass_locations(klass)
+        files = method_sources(klass)
+
+        files.flatten.compact.uniq
+      end
+
+      private
+
+      def klass_file_locations(args)
+        klasses(args).each_with_object({}) { |k, result| result[k] = klass_locations(k) }
+      end
+
+      def klasses(args)
+        args.map do |k|
+          klass_for(k)
+        end
+      end
+
+      def method_sources(klass)
+        (Delfos::Patching.added_methods[klass.to_s] || {}).values.map(&:first)
+      end
+    end
+  end
+end

data/lib/delfos/method_logging/code_location.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+require_relative "klass_determination"
+
+module Delfos
+  module MethodLogging
+    class CodeLocation
+      include KlassDetermination
+
+      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, called_method.name.to_s, class_method, file, line_number)
+        end
+
+        def method_type_from(class_method)
+          class_method ? "ClassMethod" : "InstanceMethod"
+        end
+
+        def method_definition_for(klass, class_method, method_name)
+          key = key_from(class_method, method_name)
+
+          Delfos::Patching.method_definition_for(klass, key)
+        end
+
+        private
+
+        def key_from(class_method, name)
+          "#{method_type_from(class_method)}_#{name}"
+        end
+      end
+
+      attr_reader :object, :method_name, :class_method, :method_type, :file, :line_number
+
+      def initialize(object, method_name, class_method, file, line_number)
+        @object = object
+        @method_name = method_name
+        @class_method = class_method
+        @method_type = self.class.method_type_from class_method
+        @line_number = line_number.to_i
+        @file = file
+
+      end
+
+      def file
+        file = @file.to_s
+
+        if file
+          Delfos.application_directories.map do |d|
+            file = relative_path(file, d)
+          end
+        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 klass
+        klass_for(object)
+      end
+
+      def klass_name
+        name = klass.name || "__AnonymousClass"
+        name.tr ":", "_"
+      end
+
+      def method_definition_file
+        method_definition[0].to_s
+      end
+
+      def method_definition_line
+        method_definition[1].to_i
+      end
+
+      private
+
+      def method_key
+        "#{method_type}_#{method_name}"
+      end
+
+      def method_definition
+        (@method_definition ||= self.class.method_definition_for(klass, class_method, method_name)) || {}
+      end
+    end
+
+    class CallSiteParsing
+      # This magic number is determined based on the specific implementation now
+      # E.g. if the line
+      # where we call this `call_site_binding.of_caller(stack_index + STACK_OFFSET).eval('self')`
+      # is to be extracted into another method we will get a failing test and have to increment
+      # the value
+      STACK_OFFSET = 5
+
+      attr_reader :stack, :call_site_binding
+
+      def initialize(stack, call_site_binding)
+        @stack = stack
+        @call_site_binding = call_site_binding
+      end
+
+      def perform
+        file, line_number, method_name = method_details
+        return unless current && file && line_number && method_name
+
+        CodeLocation.new(object, method_name.to_s, class_method, file, 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_in_logging?(file)
+        end
+      end
+
+      def object
+        @object ||= call_site_binding.of_caller(stack_index + STACK_OFFSET).receiver
+      end
+
+      def stack_index
+        stack.index { |c| c == current }
+      end
+
+      def method_details
+        return unless current
+        file, line_number, rest = current.split(":")
+        method_name = rest[/`.*'$/]
+        return unless method_name && file && line_number
+
+        method_name.delete!("`").delete!("'")
+
+        [file, line_number.to_i, method_name]
+      end
+    end
+  end
+end

data/lib/delfos/method_logging/klass_determination.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+module Delfos
+  module MethodLogging
+    module KlassDetermination
+      private
+
+      def klass_for(object)
+        if object.is_a?(Class)
+          object
+        else
+          object.class
+        end
+      end
+    end
+  end
+end

data/lib/delfos/neo4j/distance_update.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+require_relative "../distance/calculation"
+require_relative "query_execution"
+require "json"
+
+module Delfos
+  module Neo4j
+    class DistanceUpdate
+      def perform
+        query = <<-QUERY
+          MATCH
+            (klass)        -  [:OWNS]     -> (method),
+            (method)       -  [:CONTAINS] -> (call_site),
+            (call_site)    -  [:CALLS]    -> (called),
+            (called_klass) -  [:OWNS]     -> (called)
+
+          RETURN
+            head(labels(klass)),
+            call_site, id(call_site),
+            method,
+            called, id(called),
+            head(labels(called_klass))
+        QUERY
+
+        results = Delfos::Neo4j::QueryExecution.execute(query)
+
+        update(results)
+      end
+
+      def determine_full_path(f)
+        f = Pathname.new f
+        return f.realpath if File.exist?(f)
+
+        Delfos.application_directories.map do |d|
+          path = Pathname.new(d + f.to_s.gsub(%r{[^/]*/}, ""))
+          path if path.exist?
+        end.compact.first
+      end
+
+      private
+
+      def update(results)
+        results.map do |klass, call_site, call_site_id, meth, called, called_id, called_klass|
+          start  = determine_full_path call_site["file"]
+          finish = determine_full_path called["file"]
+
+          calc = Delfos::Distance::Calculation.new(start, finish)
+
+          perform_query(calc, call_site_id, called_id)
+        end
+      end
+
+      def perform_query(calc, call_site_id, called_id)
+        Delfos::Neo4j::QueryExecution.execute <<-QUERY
+          START call_site = node(#{call_site_id}),
+                called    = node(#{called_id})
+
+           MERGE (call_site) - #{rel_for(calc)} -> (called)
+        QUERY
+      end
+
+      def rel_for(calc)
+        <<-REL
+           [:EFFERENT_COUPLING{
+             distance:          #{calc.sum_traversals},
+             possible_distance: #{calc.sum_possible_traversals}
+             }
+           ]
+        REL
+      end
+    end
+  end
+end

data/lib/delfos/neo4j/execution_persistence.rb

@@ -0,0 +1,63 @@
+require_relative "query_execution"
+
+module Delfos
+  module Neo4j
+    class ExecutionPersistence
+      def self.save!(other)
+        new(other.call_sites, other.execution_count).save!
+      end
+
+      def save!
+        Neo4j::QueryExecution.execute query
+      end
+
+      private
+
+      def initialize(call_sites, execution_count)
+        @call_sites = call_sites
+
+        @execution_count = execution_count
+      end
+
+      attr_reader :call_sites, :execution_count
+
+      def query
+        call_sites.compact.map.with_index do |c, i|
+          call_site_query(c, i)
+        end.join("\n")
+      end
+
+      def call_site_query(cs, i)
+        <<-QUERY
+        #{method_query(cs, i)}
+
+      MERGE
+        (m#{i})
+
+        -[:CONTAINS]->
+
+        (cs#{i}:CallSite {file: "#{cs.file}", line_number: #{cs.line_number}})
+
+        #{execution_chain_query(cs, i)}
+        QUERY
+      end
+
+      def execution_chain_query(cs, i)
+        <<-QUERY
+        MERGE (e#{i}:ExecutionChain{number: #{execution_count}})
+
+        MERGE e#{i}-[:STEP{number: #{i + 1}}]-> (cs#{i})
+        QUERY
+      end
+
+      def method_query(cs, i)
+        <<-QUERY
+        MERGE (k#{i}:#{cs.klass})
+        - [:OWNS] ->
+
+        (m#{i} :#{cs.method_type} {name: "#{cs.method_name}", file: "#{cs.method_definition_file}", line_number: #{cs.method_definition_line}})
+        QUERY
+      end
+    end
+  end
+end

data/lib/delfos/neo4j/informer.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+require "delfos"
+require_relative "query_execution"
+
+module Delfos
+  module Neo4j
+    class Informer
+      def debug(args, call_site, called_code)
+        execute_query(args, call_site, called_code)
+      end
+
+      def execute_query(*args)
+        query = query_for(*args)
+
+        QueryExecution.execute(query)
+      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}:#{klass})"
+        end.join("\n")
+
+        <<-QUERY
+          #{klasses_query}
+
+          #{merge_query(call_site, called_code)}
+          #{args_query args}
+        QUERY
+      end
+
+      def assign_query_variables(args, call_site, called_code)
+        query_variables.assign(call_site.klass, "k")
+        query_variables.assign(called_code.klass, "k")
+
+        (args.args + args.keyword_args).uniq.each do |k|
+          query_variables.assign(k, "k")
+        end
+      end
+
+      def merge_query(call_site, called_code)
+        <<-MERGE_QUERY
+          #{method_definition call_site, "m1"}
+
+          MERGE (m1) - [:CONTAINS] -> (cs:CallSite{file: "#{call_site.file}", line_number: #{call_site.line_number}})
+
+          #{method_definition called_code, "m2"}
+
+          MERGE (cs)  - [:CALLS]     ->  m2
+        MERGE_QUERY
+      end
+
+      def method_definition(code, id)
+        <<-METHOD
+          MERGE (#{query_variable(code.klass)}) - [:OWNS] -> #{method_node(code, id)}
+        METHOD
+      end
+
+      def method_node(code, id)
+        if code.method_definition_file.length > 0 && code.method_definition_line > 0
+          <<-NODE
+            (#{id}:#{code.method_type}{name: "#{code.method_name}", file: #{code.method_definition_file.inspect}, line_number: #{code.method_definition_line}})
+          NODE
+        else
+          <<-NODE
+            (#{id}:#{code.method_type}{name: "#{code.method_name}"})
+          NODE
+        end
+      end
+
+      def args_query(args)
+        (args.args + args.keyword_args).map do |k|
+          name = query_variable(k)
+          "MERGE (cs) - [:ARG] -> (#{name})"
+        end.join("\n")
+      end
+
+      def query_variable(k)
+        query_variables[k.to_s]
+      end
+
+      def query_variables
+        @query_variables ||= QueryVariables.new
+      end
+
+      def code_execution_query
+        Delfos::Patching.method_chain
+      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