delfos 0.0.1 → 0.0.2.pre.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 87475ed3a25d014e199e651988f4d3183561816a
-  data.tar.gz: 0c2441e45f0dfbe6b272e0904654907fba9f53d2
+  metadata.gz: d7fee8925fceb4563ffc7f5895a63c2d3e372c06
+  data.tar.gz: 444793d867d93a22502053420bec22c7c14cef79
 SHA512:
-  metadata.gz: 84f4de34ff44908ce8794643553ece54cd9914cc519502d3bfb3adfc3caa0e97effbefa65aba573f1ade386839798c496bd7adf10822ff9ff3c9734459ec1bcc
-  data.tar.gz: 9fd34ca930e93e73a5e16294a6fc4a94464accd3f8b91353a9a8c94d99a418ef7494855b79f064334ed102a70107a9049f3e1e554f37e4c88e5681392cd7d85d
+  metadata.gz: 9424c15ce219468cadb02be9e35ce932bbba9cb103416dbb0eda9115b61943955e2eae1c5464296a255aa83ad7a8de9b985240c298d4d953009829696ab577b4
+  data.tar.gz: ceb9b9bc4d27a011d46785b92a3d1c62294f0abce4f95e5d69fa1d8aadeee9178bf8abd971c3e8b71c0111005046f7758d92840d0dcae48db80481ea54eeae3f

data/lib/delfos.rb

@@ -1,22 +1,58 @@
 # frozen_string_literal: true
+
 require "delfos/setup"
 
 module Delfos
   class << self
-    attr_accessor :application_directories
-    attr_writer :logger, :neo4j
+    attr_accessor :application_directories,
+      :offline_query_saving,
+      :offline_query_filename
+
+    attr_writer :logger, :neo4j, :batch_size, :max_query_size
+
+    # rubocop:disable Metrics/ParameterLists
+    def setup!(
+      logger: nil,
+      call_site_logger: nil,
+      application_directories: nil,
+      batch_size: nil,
+      max_query_size: nil,
+      offline_query_saving: nil
+    )
+      # rubocop:enable Metrics/ParameterLists
+      self.logger         = logger
+      self.batch_size     = batch_size
+      self.max_query_size = max_query_size
 
-    def setup!(logger: nil, call_site_logger: nil, application_directories: nil)
-      self.logger = logger if logger
-      Delfos::Setup.perform!(call_site_logger: call_site_logger, application_directories: application_directories)
+      Setup.perform!(
+        call_site_logger: call_site_logger,
+        application_directories: application_directories,
+        offline_query_saving: offline_query_saving,
+      )
     end
 
-    def call_site_logger
-      Delfos::Setup.call_site_logger
+    def import_offline_queries(filename)
+      require "delfos/neo4j/offline/importer"
+      Neo4j::Offline::Importer.new(filename).perform
+    end
+
+    def batch_size
+      @batch_size ||= 100
     end
 
-    def call_site_logger=(call_site_logger)
-      Delfos::Setup.call_site_logger = call_site_logger
+    def max_query_size
+      @max_query_size ||= 10_000
+    end
+
+    def include_file?(file)
+      require "delfos/file_system"
+      FileSystem.include_file?(file)
+    end
+
+    attr_writer :call_site_logger
+
+    def call_site_logger
+      @call_site_logger ||= Delfos::Setup.default_call_site_logger
     end
 
     def logger
@@ -29,16 +65,39 @@ module Delfos
 
     def setup_neo4j!
       require "delfos/neo4j"
-      @neo4j ||= Delfos::Neo4j.config
+      @neo4j ||= Neo4j.config
+    end
+
+    def finish!
+      if offline_query_saving
+        Delfos.call_site_logger.finish!
+      else
+        flush!
+        update_distance!
+        disable!
+      end
+    end
+
+    def update_distance!
+      require "delfos/neo4j"
+      Neo4j.update_distance!
     end
 
-    def reset!
-      Delfos::Setup.reset!
+    def flush!
+      require "delfos/neo4j"
+      Neo4j.flush!
+    end
+
+    def disable!
+      Setup.disable!
     end
 
     def default_logger
       require "logger"
-      Logger.new(STDOUT)
+
+      Logger.new(STDOUT).tap do |l|
+        l.level = Logger::ERROR
+      end
     end
   end
 end

data/lib/delfos/call_stack.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
-require_relative "neo4j"
-require_relative "neo4j/call_stack_query"
+
 require_relative "call_stack/stack"
 
 module Delfos
@@ -16,24 +15,25 @@ module Delfos
 
     def stack
       CALL_STACK_MUTEX.synchronize do
-        Thread.current[:_delfos__call_stack] ||= Stack.new(on_empty: method(:save!))
+        Thread.current[:_delfos__call_stack] ||= Stack.new(on_empty: method(:reset!))
       end
     end
 
-    def push(method_object)
-      stack.push(method_object)
+    def push(call_site)
+      stack.push(call_site)
+      Delfos.call_site_logger.log(call_site, stack.uuid, stack.step_count)
     end
 
     def pop
       stack.pop
     end
 
-    def pop_until_top!
-      stack.pop_until_top!
+    def height
+      stack.height
     end
 
-    def save!(call_sites, execution_number)
-      Delfos::MethodLogging.save_call_stack(call_sites, execution_number)
+    def pop_until_top!
+      stack.pop_until_top!
     end
   end
 end

data/lib/delfos/call_stack/stack.rb

@@ -1,35 +1,41 @@
 # frozen_string_literal: true
+
+require "securerandom"
+
 module Delfos
   module CallStack
     class Stack
+      attr_reader :uuid
+
       def initialize(on_empty: nil)
         @on_empty = on_empty
+        @uuid = SecureRandom.uuid
       end
 
       def push(method_object)
         call_sites.push(method_object)
-        self.stack_depth += 1
+        self.height += 1
 
-        self.execution_count += self.stack_depth == 1 ? 1 : 0
+        self.execution_count += self.height == 1 ? 1 : 0
       end
 
       def pop
-        popping_empty_stack! if self.stack_depth.zero?
+        raise PoppingEmptyStackError if self.height.zero?
+
+        self.height -= 1
 
-        self.stack_depth -= 1
+        return unless height.zero? && call_sites.length.positive?
 
-        if stack_depth.zero? && call_sites.length.positive?
-          @on_empty&.call(call_sites, execution_count)
-          self.call_sites = []
-        end
+        @on_empty&.call
+        self.call_sites = []
       end
 
       def pop_until_top!
-        pop while self.stack_depth.positive?
+        pop while self.height.positive?
       end
 
-      def stack_depth
-        @stack_depth ||= 0
+      def height
+        @height ||= 0
       end
 
       def execution_count
@@ -44,13 +50,7 @@ module Delfos
         call_sites.length
       end
 
-      attr_writer :stack_depth, :step_count, :execution_count, :call_sites
-
-      private
-
-      def popping_empty_stack!
-        raise PoppingEmptyStackError
-      end
+      attr_writer :height, :step_count, :execution_count, :call_sites
     end
 
     class PoppingEmptyStackError < StandardError

data/lib/delfos/file_system.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "file_system/distance_calculation"
+require_relative "file_system/app_directories"
+
+module Delfos
+  module FileSystem
+    def self.distance_calculation(start_file, finish_file)
+      DistanceCalculation.new(start_file, finish_file)
+    end
+
+    def self.include_file?(file)
+      FileSystem::AppDirectories.include_file?(file)
+    end
+  end
+end

data/lib/delfos/file_system/app_directories.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "common_path"
+
+module Delfos
+  module FileSystem
+    module AppDirectories
+      extend self
+
+      def exclude_file?(file)
+        !include_file?(file)
+      end
+
+      def include_file?(file)
+        return false if file.nil?
+        with_cache(file) { should_include?(file) }
+      end
+
+      def reset!
+        @cache = nil
+      end
+
+      private
+
+      def should_include?(file)
+        CommonPath.included_in?(expand_path(file), Delfos.application_directories)
+      end
+
+      def expand_path(f)
+        Pathname.new(f).expand_path
+      end
+
+      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/common_path.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-require "pathname"
 
 module Delfos
   module FileSystem
@@ -8,6 +7,8 @@ module Delfos
         SEPARATOR = "/"
 
         def included_in?(p1, paths)
+          return false if paths.nil?
+
           paths.any? do |p2|
             common = common_parent(p1, p2)
             common.to_s.length >= p2.to_s.length
@@ -16,13 +17,12 @@ module Delfos
 
         def common_parent(path_a, path_b)
           dirs = [
-            File.expand_path(path_a.to_s),
-            File.expand_path(path_b.to_s),
+            Pathname.new(path_a.to_s).expand_path,
+            Pathname.new(path_b.to_s).expand_path,
           ]
 
-          dir1, dir2 = dirs.minmax.map { |dir| dir.split(SEPARATOR) }
-
-          path_from(dir1, dir2, path_a, path_b)
+          dir1, dir2 = dirs.sort.map { |dir| dir.to_s.split(SEPARATOR) }
+          append_trailing_slash!(path_from(dir1, dir2, path_a, path_b).to_s)
         end
 
         private
@@ -47,13 +47,19 @@ module Delfos
             join(SEPARATOR)
         end
 
+        def append_trailing_slash!(path)
+          path = path.to_s
+
+          if Pathname.new(path).directory?
+            path += SEPARATOR if path && path.to_s[-1] != SEPARATOR
+          end
+
+          path
+        end
+
         def append_trailing_slashes!(*paths)
           paths.map do |path|
-            if Pathname.new(path).directory?
-              path += SEPARATOR if path && path.to_s[-1] != SEPARATOR
-            end
-
-            path
+            append_trailing_slash!(path)
           end
         end
       end

data/lib/delfos/file_system/distance_calculation.rb

@@ -1,14 +1,23 @@
 # frozen_string_literal: true
+
 require_relative "relation"
 require_relative "path_determination"
 
 module Delfos
   module FileSystem
+    Error = Class.new(::StandardError)
+
     class DistanceCalculation
       attr_reader :path_a, :path_b
 
+      PathNotFound = Class.new(Error)
+
       def initialize(path_a, path_b)
         @path_a, @path_b = PathDetermination.for(path_a, path_b)
+
+        return if @path_a && @path_b
+
+        raise PathNotFound, "path_a: #{path_a} -> #{@path_a.inspect}, path_b: #{path_b} -> #{@path_b.inspect}"
       end
 
       attr_reader :traversal_a, :traversal_b
@@ -31,15 +40,15 @@ module Delfos
       end
 
       def sum_traversals
-        traversals.inject(0) { |a, e| a + e.distance }
+        traversals.sum(&:distance)
       end
 
       def sum_possible_traversals
-        traversals.inject(0) { |a, e| a + e.possible_length }
+        traversals.sum(&:possible_length)
       end
 
       def sibling_directories(path)
-        siblings(path).select { |f| File.directory?(f) }
+        siblings(path).select { |f| Pathname.new(f).directory?(f) }
       end
 
       def traversal_path

data/lib/delfos/file_system/path_determination.rb

@@ -1,4 +1,7 @@
 # frozen_string_literal: true
+
+require "pathname"
+
 module Delfos
   module FileSystem
     class PathDetermination
@@ -11,7 +14,7 @@ module Delfos
       end
 
       def full_path
-        return @file.realpath if File.exist?(@file)
+        return @file.realpath if Pathname.new(@file).exist?
 
         Delfos.application_directories.map do |d|
           path = try_path { d + @file }

data/lib/delfos/file_system/relation.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Delfos
   module FileSystem
     class Relation

data/lib/delfos/method_trace.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative "method_trace/call_handler"
+require_relative "call_stack"
+
+module Delfos
+  module MethodTrace
+    class << self
+      def trace!
+        on_call.enable
+        on_return.enable
+        @last_returned = nil
+      end
+
+      def disable!
+        @on_call&.disable
+        @on_call = nil
+
+        @on_return&.disable
+        @on_return = nil
+
+        @last_returned = nil
+      end
+
+      def on_call
+        @on_call ||= setup_trace_point(:call) do |tp|
+          CallHandler.new(tp).perform
+        end
+      end
+
+      def on_return
+        @on_return ||= setup_trace_point(:return) do |tp|
+          next if check_for_bug!(tp)
+
+          CallStack.pop
+
+          @last_returned = tp
+        end
+      end
+
+      private
+
+      # FIXME: There seems to be a bug where the last TracePoint in a chain
+      # when returning to (main) is duplicated. Can't get to the source of
+      # this.  But the only effect seems to be popping the stacking beyond the
+      # end so this is a workaround
+      def check_for_bug!(tp)
+        (@last_returned == tp) && CallStack.height.zero?
+      end
+
+      def setup_trace_point(type)
+        TracePoint.new(type) do |tp|
+          next unless Delfos.include_file?(tp.path)
+          yield tp
+        end
+      end
+    end
+  end
+end