delfos 0.0.2.pre.rc2 → 0.0.2.pre.rc3

data/lib/delfos/file_system/app_files.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "file_cache"
+
+module Delfos
+  module FileSystem
+    class AppFiles
+      include FileCache
+
+      def initialize(included, excluded)
+        @included = included
+        @excluded = excluded
+      end
+
+      def include?(file)
+        !exclude?(file)
+      end
+
+      def exclude?(file)
+        return false if file.nil?
+        with_cache(file) { should_exclude?(file) }
+      end
+
+      private
+
+      def should_exclude?(file)
+        @excluded.include?(Pathname(file).expand_path)
+      end
+    end
+  end
+end

data/lib/delfos/file_system/file_cache.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Delfos
+  module FileSystem
+    module FileCache
+      def reset!
+        @cache = nil
+      end
+
+      private
+
+      def with_cache(key)
+        cache.include?(key) ? cache[key] : cache[key] = yield
+      end
+
+      def cache
+        @cache ||= {}
+      end
+    end
+  end
+end

data/lib/delfos/file_system/path_determination.rb

@@ -15,18 +15,21 @@ module Delfos
 
       def full_path
         return @file.realpath if Pathname.new(@file).exist?
-
-        Delfos.application_directories.map do |d|
-          path = try_path { d + @file }
-
-          path || try_path do
-            Pathname.new(d + @file.to_s.gsub(%r{[^/]*/}, ""))
-          end
+        Delfos.config.included_directories.map do |d|
+          determine_path(d)
         end.compact.first
       end
 
       private
 
+      def determine_path(d)
+        path = try_path { d + @file }
+
+        path || try_path do
+          Pathname.new(d + @file.to_s.gsub(%r{[^/]*/}, ""))
+        end
+      end
+
       def strip_block_message(f)
         f.to_s.split(" in block").first
       end

data/lib/delfos/method_trace.rb

@@ -6,7 +6,24 @@ require_relative "call_stack"
 module Delfos
   module MethodTrace
     class << self
-      def trace!
+      def enable!
+        method_trace.perform
+      end
+
+      def disable!
+        @method_trace&.disable!
+        @method_trace = nil
+      end
+
+      private
+
+      def method_trace
+        @method_trace ||= Setup.new
+      end
+    end
+
+    class Setup
+      def perform
         on_call.enable
         on_return.enable
         @last_returned = nil
@@ -14,12 +31,7 @@ module Delfos
 
       def disable!
         @on_call&.disable
-        @on_call = nil
-
         @on_return&.disable
-        @on_return = nil
-
-        @last_returned = nil
       end
 
       def on_call

data/lib/delfos/method_trace/call_handler.rb

@@ -2,14 +2,14 @@
 
 require "delfos/call_stack"
 require_relative "code_location"
-require_relative "code_location/filename_helpers"
+require_relative "code_location/eval_in_caller"
 
 module Delfos
   module MethodTrace
     CallHandler = Struct.new(:trace_point)
 
     class CallHandler
-      include CodeLocation::FilenameHelpers
+      include CodeLocation::EvalInCaller
 
       def perform
         return unless relevant?
@@ -17,8 +17,12 @@ module Delfos
         CallStack.push(call_site)
       end
 
+      STACK_OFFSET = 7
+
       def call_site
         @call_site ||= CodeLocation.callsite_from(
+          file:             eval_in_caller("__FILE__", STACK_OFFSET),
+          line_number:      eval_in_caller("__LINE__", STACK_OFFSET),
           container_method: container_method,
           called_method:    called_method,
         )

data/lib/delfos/method_trace/code_location.rb

@@ -3,27 +3,17 @@
 require_relative "code_location/method"
 require_relative "code_location/call_site"
 require_relative "code_location/container_method_factory"
-require_relative "code_location/eval_in_caller"
 
 module Delfos
   module MethodTrace
     module CodeLocation
       class << self
-        include EvalInCaller
-
         def method_from(attrs)
           Method.new(attrs)
         end
 
-        STACK_OFFSET = 8
-
-        def callsite_from(container_method:, called_method:, stack_offset: STACK_OFFSET)
-          CallSite.new(
-            container_method: container_method,
-            called_method:    called_method,
-            file:             eval_in_caller("__FILE__", stack_offset),
-            line_number:      eval_in_caller("__LINE__", stack_offset),
-          )
+        def callsite_from(attrs)
+          CallSite.new(attrs)
         end
 
         def create_container_method

data/lib/delfos/method_trace/code_location/container_method_factory.rb

@@ -9,7 +9,9 @@ module Delfos
       class ContainerMethodFactory
         include EvalInCaller
         include FilenameHelpers
+
         STACK_OFFSET = 12
+
         attr_reader :stack_offset
 
         def self.create(stack_offset: STACK_OFFSET)
@@ -21,49 +23,72 @@ module Delfos
         end
 
         def create
-          # ensure evaluated and memoised with correct stack offset
-          class_method
-
-          CodeLocation.method_from(
-            object:       object,
-            method_name:  meth,
-            file:         file,
-            line_number:  line,
-            class_method: class_method,
-          )
+          # ensure memoised with correct stack offset
+          method_object
+          source_location
+
+          CodeLocation.method_from(attrs)
         end
 
         private
 
-        def object
-          @object ||= eval_in_caller("self", stack_offset)
+        def attrs
+          {
+            object:        object,
+            method_name:   method_name,
+            file:          file,
+            line_number:   line,
+            class_method:  class_method,
+            method_object: method_object,
+            super_method:  super_method,
+          }
         end
 
         def class_method
           return @class_method if defined?(@class_method)
 
-          @class_method = eval_in_caller("is_a?(Module)", STACK_OFFSET)
+          @class_method = object.is_a?(Module)
         end
 
-        RUBY_IS_MAIN                = "self.class == Object && self&.to_s == 'main' && __method__.nil?"
-        RUBY_SOURCE_LOCATION        = "(__method__).source_location if __method__"
-        RUBY_CLASS_METHOD_SOURCE    = "method#{RUBY_SOURCE_LOCATION}"
-        RUBY_INSTANCE_METHOD_SOURCE = "self.class.instance_method#{RUBY_SOURCE_LOCATION}"
+        def file
+          return @file if defined? @file
 
-        def method_finder
-          @method_finder ||= class_method ? RUBY_CLASS_METHOD_SOURCE : RUBY_INSTANCE_METHOD_SOURCE
+          @file = source_location&.first
         end
 
-        def file
-          @file ||= eval_in_caller("(#{RUBY_IS_MAIN}) ? __FILE__ : ((#{method_finder})&.first)", stack_offset)
+        def line
+          return @line if defined? @line
+
+          @line = source_location&.last
         end
 
-        def line
-          @line ||= eval_in_caller("(#{RUBY_IS_MAIN}) ? __LINE__ : ((#{method_finder})&.last)", stack_offset)
+        def source_location
+          return @source_location if defined? @source_location
+
+          @source_location =
+            method_object&.source_location ||
+            eval_in_caller("[__FILE__, __LINE__]", stack_offset)
         end
 
-        def meth
-          @meth ||= eval_in_caller("__method__", stack_offset)
+        REPRESENTATION_OF_MAIN = Object.new
+
+        def object
+          @object ||= method_object&.receiver || REPRESENTATION_OF_MAIN
+        end
+
+        def method_name
+          @method_name ||= method_object&.name
+        end
+
+        def super_method
+          method_object&.super_method
+        end
+
+        RUBY_METHOD = "method(__method__) if __method__"
+
+        def method_object
+          return @method_object if defined? @method_object
+          @method_object = eval_in_caller(RUBY_METHOD, stack_offset)
         end
       end
     end

data/lib/delfos/method_trace/code_location/eval_in_caller.rb

@@ -6,10 +6,8 @@ module Delfos
   module MethodTrace
     module CodeLocation
       module EvalInCaller
-        def eval_in_caller(s, offset, &block)
-          other = binding.of_caller(offset)
-
-          other.eval(s)
+        def eval_in_caller(s, offset)
+          binding.of_caller(offset).eval(s)
         end
       end
     end

data/lib/delfos/method_trace/code_location/filename_helpers.rb

@@ -22,7 +22,7 @@ module Delfos
           return unless f
           file = f.to_s
 
-          Delfos.application_directories.map do |d|
+          Delfos.config.included_directories.map do |d|
             file = relative_path(file, d)
           end
 

data/lib/delfos/method_trace/code_location/method.rb

@@ -7,15 +7,19 @@ module Delfos
     module CodeLocation
       class Method
         include FilenameHelpers
-        attr_reader :object, :line_number, :class_method
-
-        def initialize(object:, method_name:, file:, line_number:, class_method:)
-          @object       = object
-          @method_name  = method_name
-          @file         = file
-          @line_number  = line_number
-          @class_method = class_method
-        end
+        attr_reader :object, :line_number, :class_method, :method_object, :super_method
+
+        # rubocop:disable Metrics/ParameterLists
+        def initialize(object:, method_name:, file:, line_number:, class_method:, method_object: nil, super_method: nil)
+          @object        = object
+          @method_name   = method_name
+          @file          = file
+          @line_number   = line_number
+          @class_method  = class_method
+          @method_object = method_object
+          @super_method  = super_method
+        end
+        # rubocop:enable Metrics/ParameterLists
 
         def klass_name
           klass.name

data/lib/delfos/neo4j.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
 require_relative "neo4j/query_execution/sync"
-require_relative "neo4j/batch/retryable"
+require_relative "neo4j/query_execution/batch/retryable"
 require_relative "neo4j/schema"
 require_relative "neo4j/distance/update"
+require_relative "neo4j/offline"
 
 module Delfos
   module Neo4j
@@ -14,11 +15,15 @@ module Delfos
     end
 
     def execute(query, params = {})
-      Batch::Retryable.execute!(query, params: params, size: Delfos.batch_size)
+      QueryExecution::Batch::Retryable.execute!(query, params: params, size: Delfos.batch_size)
     end
 
     def flush!
-      Batch::Retryable.flush!
+      QueryExecution::Batch::Retryable.flush!
+    end
+
+    def reset!
+      Delfos::Neo4j::QueryExecution::Batch::Retryable.reset!
     end
 
     def ensure_schema!
@@ -28,6 +33,10 @@ module Delfos
       )
     end
 
+    def import_offline_queries(filename)
+      Offline.import_queries(filename)
+    end
+
     def update_distance!
       Distance::Update.new.perform
     end

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

@@ -9,7 +9,7 @@ module Delfos
       class Update
         def perform
           results = CallSiteFetcher.perform
-          return if results.length.negative?
+          return unless results.length.positive?
 
           results.each do |start_file, call_site_id, finish_file, called_id|
             handle(start_file, call_site_id, finish_file, called_id)

data/lib/delfos/neo4j/live/call_site_logger.rb

@@ -11,6 +11,33 @@ module Delfos
 
           Neo4j.execute(q.query, q.params)
         end
+
+        def finish!
+          reset_call_stack!
+          update_distance!
+        end
+
+        def reset!
+          reset_call_stack!
+          Neo4j.reset!
+        end
+
+        private
+
+        def flush!
+          Neo4j.flush!
+        end
+
+        def update_distance!
+          Neo4j.update_distance!
+          flush!
+        end
+
+        def reset_call_stack!
+          Delfos::CallStack.pop_until_top!
+          Delfos::CallStack.reset!
+          flush!
+        end
       end
     end
   end

data/lib/delfos/neo4j/offline.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "offline/importer"
+
+module Delfos
+  module Neo4j
+    module Offline
+      def self.import_queries(filename)
+        Importer.new(filename).perform
+      end
+    end
+  end
+end

data/lib/delfos/neo4j/offline/call_site_logger.rb

@@ -17,11 +17,16 @@ module Delfos
           file.flush if (count % 100).zero?
         end
 
+        def reset!
+          finish!
+        end
+
         def finish!
-          return if file.closed?
+          return if Delfos.offline_query_filename.nil? || file.closed?
 
           file.flush
           file.close
+          @file = nil
         end
 
         def count