delfos 0.0.1.pre.beta → 0.0.1.pre.rc1

data/lib/delfos/neo4j/distance_update.rb

@@ -7,24 +7,7 @@ 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)
+        update Delfos::Neo4j::QueryExecution.execute(query)
       end
 
       def determine_full_path(f)
@@ -39,8 +22,25 @@ module Delfos
 
       private
 
+      def query
+        <<-QUERY
+          MATCH
+            (klass:Class)        -  [:OWNS]     -> (method:Method),
+            (method)             -  [:CONTAINS] -> (call_site:CallSite),
+            (call_site)          -  [:CALLS]    -> (called:Method),
+            (called_klass:Class) -  [:OWNS]     -> (called:Method)
+
+          RETURN
+            head(labels(klass)),
+            call_site, id(call_site),
+            method,
+            called, id(called),
+            head(labels(called_klass))
+        QUERY
+      end
+
       def update(results)
-        results.map do |klass, call_site, call_site_id, meth, called, called_id, called_klass|
+        Array(results).compact.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"]
 
@@ -51,19 +51,19 @@ module Delfos
       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})
+        Delfos::Neo4j::QueryExecution.execute <<-QUERY, {call_site_id: call_site_id, called_id: called_id, sum_traversals: calc.sum_traversals, sum_possible_traversals: calc.sum_possible_traversals}
+          START call_site = node({call_site_id}),
+                called    = node({called_id})
 
-           MERGE (call_site) - #{rel_for(calc)} -> (called)
+           MERGE (call_site) - #{rel} -> (called)
         QUERY
       end
 
-      def rel_for(calc)
+      def rel
         <<-REL
            [:EFFERENT_COUPLING{
-             distance:          #{calc.sum_traversals},
-             possible_distance: #{calc.sum_possible_traversals}
+             distance:          {sum_traversals},
+             possible_distance: {sum_possible_traversals}
              }
            ]
         REL

data/lib/delfos/neo4j/execution_persistence.rb

@@ -1,14 +1,15 @@
+# frozen_string_literal: true
 require_relative "query_execution"
 
 module Delfos
   module Neo4j
     class ExecutionPersistence
-      def self.save!(other)
-        new(other.call_sites, other.execution_count).save!
+      def self.save!(chain)
+        new(chain.call_sites, chain.execution_count).save!
       end
 
       def save!
-        Neo4j::QueryExecution.execute query
+        Neo4j::QueryExecution.execute(query, params)
       end
 
       private
@@ -22,42 +23,76 @@ module Delfos
       attr_reader :call_sites, :execution_count
 
       def query
-        call_sites.compact.map.with_index do |c, i|
+        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
+
+      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
-        #{method_query(cs, i)}
+         <<-QUERY
+          MERGE
 
-      MERGE
-        (m#{i})
+          (
+            k#{i}:Class { name: {klass#{i}} }
+          )
 
-        -[:CONTAINS]->
+          - [:OWNS] ->
 
-        (cs#{i}:CallSite {file: "#{cs.file}", line_number: #{cs.line_number}})
+          (
+            m#{i} :Method {
+              type: {method_type#{i}},
+              name: {method_name#{i}},
+              file: {method_definition_file#{i}},
+              line_number: {method_definition_line#{i}}}
+          )
 
-        #{execution_chain_query(cs, i)}
-        QUERY
-      end
+          MERGE
 
-      def execution_chain_query(cs, i)
-        <<-QUERY
-        MERGE (e#{i}:ExecutionChain{number: #{execution_count}})
+          (m#{i})
 
-        MERGE e#{i}-[:STEP{number: #{i + 1}}]-> (cs#{i})
-        QUERY
-      end
+          -[:CONTAINS]->
 
-      def method_query(cs, i)
-        <<-QUERY
-        MERGE (k#{i}:#{cs.klass})
-        - [:OWNS] ->
+          (cs#{i}:CallSite {file: {file#{i}}, line_number: {line_number#{i}}})
 
-        (m#{i} :#{cs.method_type} {name: "#{cs.method_name}", file: "#{cs.method_definition_file}", line_number: #{cs.method_definition_line}})
+          MERGE (e#{i}:ExecutionChain{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,
+          "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

@@ -11,21 +11,29 @@ module Delfos
 
       def execute_query(*args)
         query = query_for(*args)
+        params = {}
 
-        QueryExecution.execute(query)
+        QueryExecution.execute(query, 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}:#{klass})"
+          "MERGE (#{name}:Class {name: #{klass.inspect}})"
         end.join("\n")
 
         <<-QUERY
           #{klasses_query}
 
-          #{merge_query(call_site, called_code)}
+          MERGE (#{query_variable(call_site.klass)}) - [:OWNS] -> #{method_node(call_site, "m1")}
+
+          MERGE (m1) - [:CONTAINS] -> (cs:CallSite{file: "#{call_site.file}", line_number: #{call_site.line_number}})
+
+          MERGE (#{query_variable(called_code.klass)}) - [:OWNS] -> #{method_node(called_code, "m2")}
+
+          MERGE (cs)  - [:CALLS]     ->  m2
+
           #{args_query args}
         QUERY
       end
@@ -39,32 +47,14 @@ module Delfos
         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
+        if code.method_definition_file.length.positive? && code.method_definition_line.positive?
           <<-NODE
-            (#{id}:#{code.method_type}{name: "#{code.method_name}", file: #{code.method_definition_file.inspect}, line_number: #{code.method_definition_line}})
+            (#{id}:Method{type: "#{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}"})
+            (#{id}:Method{type: "#{code.method_type}", name: "#{code.method_name}"})
           NODE
         end
       end
@@ -85,7 +75,7 @@ module Delfos
       end
 
       def code_execution_query
-        Delfos::Patching.method_chain
+        Delfos::Patching.execution_chain
       end
 
       class QueryVariables < Hash
@@ -95,7 +85,7 @@ module Delfos
         end
 
         def assign(klass, prefix)
-          klass = klass.to_s
+          klass = klass.to_s.tr(":", "_")
           val = self[klass]
           return val if val
 

data/lib/delfos/neo4j/query_execution.rb

@@ -1,38 +1,79 @@
 # frozen_string_literal: true
 require "delfos"
 require "json"
+require "net/http"
+require "uri"
 
 module Delfos
   module Neo4j
     module QueryExecution
+      class ExecutionError  < IOError
+        def initialize(response, query, params)
+          message = response.inspect
+
+          super [message, query, params.to_json].join("\n\n    ")
+        end
+      end
+
       class << self
-        def execute(query, url=nil)
-          result = JSON.parse response_for(query)
-          result["results"].first["data"].map{|r| r["row"]}
+        def execute(query, params={})
+          return unless query.length.positive?
+
+          parse_response(*response_for(query, params))
         end
 
         private
 
-        def response_for(query)
-          body = <<-BODY.gsub(/^\s+/, "").chomp
-            {"statements": [ { "statement": #{query.inspect} }]}
-          BODY
-          url = "http://neo4j:password@localhost:7474/db/data/transaction/commit"
 
-          command = "curl  #{headers} --data-ascii '#{body}' #{url} 2> /dev/null"
+        def parse_response(result, query, params)
+          result = JSON.parse result.body
+
+          if result["errors"].length.positive?
+            raise ExecutionError.new(result["errors"], query, params)
+          end
+
+          strip_out_meta_data(result)
+        end
+
+        def strip_out_meta_data(result)
+          results = result["results"]
+
+          if results
+            result = results.first
+            if result
+              data = result["data"]
+              data &.map { |r| r["row"] }
+            end
+          end
+        end
+
+        def response_for(query, params)
+          request = request_for(query, params)
+          http = Net::HTTP.new(uri.host, uri.port)
+
+          response = http.request(request)
+          [response, query, params]
+        end
+
+        def request_for(query, params)
+          build_request do
+            "{\"statements\": [{\"statement\": #{query.inspect} , \"parameters\": #{params.to_json}}]}"
+          end
+        end
+
+        def build_request
+          Net::HTTP::Post.new(uri.request_uri).tap do |request|
+            request.basic_auth(Delfos.neo4j.username, Delfos.neo4j.password)
+            request.content_type = "application/json"
 
-          `#{command}`
+            request.body = yield
+          end
         end
 
-        def headers
-          <<-HEADERS.chomp
-            -H "User-Agent: delfos" -H "Accept: application/json; charset=UTF-8" -H "Content-Type: application/json" 
-          HEADERS
+        def uri
+          @uri ||= URI.parse "#{Delfos.neo4j.url}/db/data/transaction/commit"
         end
       end
     end
   end
 end
-
-
-

data/lib/delfos/patching/basic_object.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+require_relative "method_override"
+
+class BasicObject
+  def self.method_added(name)
+    return if %i(to_s singleton_method_added method_added).include?(name)
+
+    ::Delfos::Patching::MethodOverride.setup(self, name, private_instance_methods, class_method: false)
+  end
+
+  def self.singleton_method_added(name)
+    # can't currently support to_s and name as those are used inside the method logging code
+    return if %i(to_s name extended included inherited method_added singleton_method_added).include?(name)
+    return if ::Delfos::MethodLogging.exclude?(method(name))
+
+    ::Delfos::Patching::MethodOverride.setup(self, name, private_methods, class_method: true)
+  end
+end

data/lib/delfos/patching/basic_object_remove.rb

@@ -0,0 +1,7 @@
+# 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_override.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require_relative "../method_logging"
+
+module Delfos
+  module Patching
+    class MethodOverride
+      class << self
+        def setup(klass, name, private_methods, class_method:)
+          instance = new(klass, name, private_methods, class_method)
+
+          instance.ensure_method_recorded_once!
+        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 (only once) at runtime to enabling logging to Neo4j
+      def setup
+        processor = method(:process)
+        cm = class_method
+
+        method_defining_method.call(name) do |*args, **kw_args, &block|
+          arguments = MethodArguments.new(args, kw_args, block, cm)
+
+          processor.call(self, caller.dup, binding.dup, arguments)
+        end
+      end
+
+      def process(instance, stack, caller_binding, arguments)
+        method_to_call = method_selector(instance)
+
+        call_site = Delfos::MethodLogging::CodeLocation.from_call_site(stack, caller_binding)
+
+        with_logging(call_site, instance, method_to_call, class_method, arguments) do
+          arguments.apply_to(method_to_call)
+        end
+      end
+
+      def with_logging(call_site, instance, method_to_call, class_method, arguments)
+        Delfos.method_logging.log(call_site, instance, method_to_call, class_method, arguments) if call_site
+
+        with_stack(call_site) do
+          yield
+        end
+      end
+
+
+      def with_stack(call_site)
+        return yield unless call_site
+
+        begin
+          ExecutionChain.push(call_site)
+          yield
+        ensure
+          ExecutionChain.pop
+        end
+      end
+
+      MethodArguments = Struct.new(:args, :keyword_args, :block, :class_method) do
+        def apply_to(method)
+          if keyword_args.empty?
+            method.call(*args, &block)
+          else
+            method.call(*args, **keyword_args, &block)
+          end
+        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?
+        yield
+
+        Delfos::MethodLogging::AddedMethods.append(klass, key, original_method)
+      end
+
+      def method_selector(instance)
+        if class_method
+          m = Delfos::MethodLogging::AddedMethods.find(instance, "ClassMethod_#{name}")
+          m.receiver == instance ? m : m.unbind.bind(instance)
+        else
+          original_method.bind(instance)
+        end
+      end
+
+      def method_defining_method
+        class_method ? klass.method(:define_singleton_method) : klass.method(:define_method)
+      end
+
+      def bail?
+        method_has_been_added? || private_method? || exclude?
+      end
+
+      def method_has_been_added?
+        Delfos::MethodLogging::AddedMethods.find(klass, key)
+      end
+
+      def private_method?
+        private_methods.include?(name.to_sym)
+      end
+
+      def exclude?
+        ::Delfos.method_logging.exclude?(original_method)
+      end
+
+      def key
+        "#{type}_#{name}"
+      end
+
+      def type
+        class_method ? "ClassMethod" : "InstanceMethod"
+      end
+    end
+  end
+end