delfos 0.0.1.pre.rc1 → 0.0.1

data/lib/delfos/neo4j/{execution_persistence.rb → call_stack_query.rb}

@@ -1,29 +1,15 @@
 # frozen_string_literal: true
-require_relative "query_execution"
-
 module Delfos
   module Neo4j
-    class ExecutionPersistence
-      def self.save!(chain)
-        new(chain.call_sites, chain.execution_count).save!
-      end
-
-      def save!
-        Neo4j::QueryExecution.execute(query, params)
-      end
-
-      private
-
+    class CallStackQuery
       def initialize(call_sites, execution_count)
         @call_sites = call_sites
 
         @execution_count = execution_count
       end
 
-      attr_reader :call_sites, :execution_count
-
       def query
-        map_call_sites do |c,i|
+        map_call_sites do |c, i|
           call_site_query(c, i)
         end.join("\n")
       end
@@ -31,21 +17,25 @@ module Delfos
       def params
         params = {}
 
-        map_call_sites do |c,i|
+        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
+      def call_site_query(_cs, i)
+        <<-QUERY
           MERGE
 
           (
@@ -70,7 +60,7 @@ module Delfos
 
           (cs#{i}:CallSite {file: {file#{i}}, line_number: {line_number#{i}}})
 
-          MERGE (e#{i}:ExecutionChain{number: {execution_count#{i}}})
+          MERGE (e#{i}:CallStack{number: {execution_count#{i}}})
 
           MERGE (e#{i})
             -
@@ -82,7 +72,7 @@ module Delfos
 
       def call_site_params(cs, i)
         {
-          "klass#{i}"                  => cs.klass,
+          "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,
@@ -90,7 +80,7 @@ module Delfos
           "method_definition_line#{i}" => cs.method_definition_line,
           "file#{i}"                   => cs.file,
           "line_number#{i}"            => cs.line_number,
-          "step_number#{i}"            => i + 1
+          "step_number#{i}"            => i + 1,
         }
       end
     end

data/lib/delfos/neo4j/distance/call_site_fetcher.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+module Delfos
+  module Neo4j
+    module Distance
+      class CallSiteFetcher
+        def self.perform
+          Neo4j.execute_sync <<-QUERY
+            MATCH
+              (call_site:CallSite) - [:CALLS] -> (called:Method)
+
+            RETURN
+              call_site.file, id(call_site),
+              called.file,    id(called)
+          QUERY
+        end
+      end
+    end
+  end
+end

data/lib/delfos/neo4j/distance/update.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+require "delfos/file_system/distance_calculation"
+require_relative "call_site_fetcher"
+
+module Delfos
+  module Neo4j
+    module Distance
+      class Update
+        def perform
+          results = CallSiteFetcher.perform
+          return if results.length.negative?
+
+          results.each do |start_file, call_site_id, finish_file, called_id|
+            calc = FileSystem::DistanceCalculation.new(start_file, finish_file)
+
+            update(call_site_id, called_id, calc)
+          end
+
+          Neo4j.flush!
+        end
+
+        def update(call_site_id, called_id, calc)
+          Neo4j.execute(
+            query,
+            call_site_id:            call_site_id,
+            called_id:               called_id,
+            sum_traversals:          calc.sum_traversals,
+            sum_possible_traversals: calc.sum_possible_traversals
+          )
+        end
+
+        def query
+          <<-QUERY
+            START call_site = node({call_site_id}),
+                  called    = node({called_id})
+
+             MERGE (call_site)
+               -
+                 [:EFFERENT_COUPLING {
+                     distance:          {sum_traversals},
+                     possible_distance: {sum_possible_traversals}
+                   }
+                 ]
+               -> (called)
+          QUERY
+        end
+      end
+    end
+  end
+end

data/lib/delfos/neo4j/informer.rb

@@ -1,69 +1,101 @@
 # 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)
+      def save_call_stack(call_sites, execution_number)
+        q = Neo4j::CallStackQuery.new(call_sites, execution_number)
+        Neo4j.execute(q.query, q.params)
       end
 
-      def execute_query(*args)
-        query = query_for(*args)
-        params = {}
+      def log(args, call_site, called_code)
+        query = query_for(args, call_site, called_code)
+        params = params_for(args, call_site, called_code)
 
-        QueryExecution.execute(query, params)
+        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: #{klass.inspect}})"
+        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(call_site, "m1")}
+          MERGE (#{query_variable(call_site.klass)}) - [:OWNS] ->
+            #{method_node("m1")}
 
-          MERGE (m1) - [:CONTAINS] -> (cs:CallSite{file: "#{call_site.file}", line_number: #{call_site.line_number}})
+          MERGE (m1) - [:CONTAINS] ->
+            (cs:CallSite
+              {
+                file: {cs_file},
+                line_number: {cs_line_number}
+              }
+            )
 
-          MERGE (#{query_variable(called_code.klass)}) - [:OWNS] -> #{method_node(called_code, "m2")}
+          MERGE (#{query_variable(called_code.klass)}) - [:OWNS] ->
+            #{method_node("m2")}
 
-          MERGE (cs)  - [:CALLS]     ->  m2
+          MERGE (cs) - [:CALLS] -> (m2)
 
           #{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")
+        klasses = [call_site.klass, called_code.klass] + args.argument_classes
 
-        (args.args + args.keyword_args).uniq.each do |k|
+        klasses.uniq.each do |k|
           query_variables.assign(k, "k")
         end
       end
 
-      def method_node(code, id)
-        if code.method_definition_file.length.positive? && code.method_definition_line.positive?
-          <<-NODE
-            (#{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}:Method{type: "#{code.method_type}", name: "#{code.method_name}"})
-          NODE
-        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)
-        (args.args + args.keyword_args).map do |k|
+        query_text = args.argument_classes.map do |k|
           name = query_variable(k)
           "MERGE (cs) - [:ARG] -> (#{name})"
-        end.join("\n")
+        end
+
+        query_text.join("\n")
       end
 
       def query_variable(k)
@@ -74,10 +106,6 @@ module Delfos
         @query_variables ||= QueryVariables.new
       end
 
-      def code_execution_query
-        Delfos::Patching.execution_chain
-      end
-
       class QueryVariables < Hash
         def initialize(*args)
           super(*args)
@@ -85,7 +113,7 @@ module Delfos
         end
 
         def assign(klass, prefix)
-          klass = klass.to_s.tr(":", "_")
+          klass = klass.to_s
           val = self[klass]
           return val if val
 

data/lib/delfos/neo4j/query_execution/errors.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+module Delfos
+  module Neo4j
+    module QueryExecution
+      HTTP_ERRORS = [
+        EOFError,
+        Errno::ECONNRESET,
+        Errno::ECONNREFUSED,
+        Errno::EINVAL,
+        Net::HTTPBadResponse,
+        Net::HTTPHeaderSyntaxError,
+        Net::ProtocolError,
+        Timeout::Error,
+      ].freeze
+
+      class InvalidQuery < IOError
+        def initialize(errors, query, params)
+          message = errors.map do |e|
+            e.select { |k, _| %w(code message).include?(k) }.inspect
+          end.join("\n")
+
+          super [message, { query: query, params: params }.to_json].join("\n\n")
+        end
+      end
+
+      class ConnectionError < IOError
+      end
+    end
+  end
+end

data/lib/delfos/neo4j/query_execution/http.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+require "delfos"
+require "net/http"
+
+module Delfos
+  module Neo4j
+    module QueryExecution
+      class Http
+        attr_reader :uri
+
+        def initialize(uri)
+          @uri = uri
+        end
+
+        def post(body)
+          response(build_post(body))
+        end
+
+        def get
+          response(build_get)
+        end
+
+        private
+
+        def response(request)
+          http = Net::HTTP.new(uri.host, uri.port)
+
+          http.request(request)
+        rescue *HTTP_ERRORS => e
+          raise ConnectionError, e
+        end
+
+        def build_post(body)
+          build_request("Post") do |request|
+            add_headers(request)
+
+            request.body = body
+          end
+        end
+
+        def build_get
+          build_request("Get") do |request|
+            add_headers(request)
+          end
+        end
+
+        def build_request(type)
+          Net::HTTP.const_get(type).new(uri.request_uri).tap do |request|
+            yield request
+          end
+        end
+
+        def add_headers(request)
+          request.initialize_http_header("Accept" => "application/json; charset=UTF-8")
+          request.basic_auth(Delfos.neo4j.username, Delfos.neo4j.password)
+          request.content_type = "application/json"
+        end
+      end
+    end
+  end
+end

data/lib/delfos/neo4j/query_execution/http_query.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+module Delfos
+  module Neo4j
+    module QueryExecution
+      module HttpQuery
+        def self.included(base)
+          base.instance_eval do
+            attr_reader :query, :params
+          end
+        end
+
+        def initialize(query, params, uri = nil)
+          @query = query
+          @params = params
+          @uri = uri
+        end
+
+        private
+
+        def request_body
+          {
+            "statements": [{ "statement": strip_whitespace(query), "parameters": params }],
+          }.to_json
+        end
+
+        def strip_whitespace(s)
+          s.
+            gsub(/^\s+/, "").
+            gsub(/ +/, " ").
+            gsub("\n\n", "\n")
+        end
+
+        def json
+          JSON.parse response.body
+        end
+
+        def errors?
+          json["errors"].length.positive?
+        end
+
+        def response
+          @response ||= fetch
+        end
+
+        def fetch
+          log_query
+
+          Http.new(uri).post(request_body)
+        end
+
+        def log_query
+          statement = strip_whitespace(query)
+
+          if statement
+            begin
+            params.each { |k, v| statement = statement.gsub("{#{k}}", v.inspect) }
+            rescue
+            byebug
+            end
+            Delfos.logger.debug "sending query: "
+            Delfos.logger.debug statement.gsub(/^/, "    ")
+          end
+        end
+      end
+    end
+  end
+end