delfos 0.0.1.pre.rc1 → 0.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 942050257d2df0f604039c76a5503f892118ba8c
-  data.tar.gz: bbafde8bed085d9c67c75d6ff9d065f578b8d8b1
+  metadata.gz: 87475ed3a25d014e199e651988f4d3183561816a
+  data.tar.gz: 0c2441e45f0dfbe6b272e0904654907fba9f53d2
 SHA512:
-  metadata.gz: 26f22aa726e32d4aaaffc19aebcfad37d0a19150bb85cd4aa709d358d9733258954168837adcc31af470440cbd69d7ae8106ff6616f20277507c0d58ed3db6cf
-  data.tar.gz: 9aa2570f3afda8ec7aa4e9abd998385adc0d3dedd0acc32344b2758815d38ed2b2f326a880490310b0264c20caf00642679a665c45d7694a45ac092a195ab44f
+  metadata.gz: 84f4de34ff44908ce8794643553ece54cd9914cc519502d3bfb3adfc3caa0e97effbefa65aba573f1ade386839798c496bd7adf10822ff9ff3c9734459ec1bcc
+  data.tar.gz: 9fd34ca930e93e73a5e16294a6fc4a94464accd3f8b91353a9a8c94d99a418ef7494855b79f064334ed102a70107a9049f3e1e554f37e4c88e5681392cd7d85d

data/lib/delfos.rb

@@ -1,100 +1,44 @@
 # frozen_string_literal: true
-require "delfos/neo4j/informer"
+require "delfos/setup"
 
 module Delfos
   class << self
-    attr_writer :application_directories
+    attr_accessor :application_directories
+    attr_writer :logger, :neo4j
 
-    def check_setup!
-      raise "Delfos.setup! has not been called" unless neo4j_config && logger
+    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)
     end
 
-    def wipe_db!
-      Delfos.setup_neo4j!
-
-      require "delfos/neo4j/query_execution"
-      Delfos::Neo4j::QueryExecution.execute <<-QUERY
-        MATCH (m)-[rel]->(n)
-        DELETE m,rel,n
-      QUERY
+    def call_site_logger
+      Delfos::Setup.call_site_logger
     end
 
-    def reset!
-      @application_directories = []
-      @method_logging = nil
-      @neo4j = nil
-      @logger = nil
-
-      if defined? Delfos::ExecutionChain
-        Delfos::ExecutionChain.reset!
-      end
-
-      # unstubbing depends upon AddedMethods being still defined
-      # so this order is important
-      unstub_all!
-      remove_added_methods!
-
-      remove_patching!
+    def call_site_logger=(call_site_logger)
+      Delfos::Setup.call_site_logger = call_site_logger
     end
 
-    def unstub_all!
-      if defined? Delfos::Patching::MethodOverride
-
-        if Delfos::Patching::MethodOverride.respond_to?(:unstub_all!)
-          Delfos::Patching::MethodOverride.unstub_all!
-        end
-      end
+    def logger
+      @logger ||= default_logger
     end
 
-    def remove_added_methods!
-      if defined? Delfos::MethodLogging::AddedMethods
-        Delfos::MethodLogging::AddedMethods.instance_eval { @instance = nil }
-      end
+    def neo4j
+      setup_neo4j!
     end
 
-    def remove_patching!
-      load "delfos/patching/basic_object_remove.rb"
+    def setup_neo4j!
+      require "delfos/neo4j"
+      @neo4j ||= Delfos::Neo4j.config
     end
 
-    def setup!(logger: Delfos::Neo4j::Informer.new,
-               neo4j_url: nil,
-               neo4j_username: nil,
-               neo4j_password: nil,
-               application_directories: nil)
-      application_directories ||= %w(app lib)
-
-      @application_directories = if application_directories.is_a?(Proc)
-                                   application_directories
-                                 else
-                                   Array(application_directories).map { |f| Pathname.new(File.expand_path(f.to_s)) }
-                                 end
-
-      @logger = logger
-
-      setup_neo4j!(neo4j_url, neo4j_username, neo4j_password)
-
-      perform_patching!
-    end
-
-    def setup_neo4j!(url = nil, username = nil, password = nil)
-      url ||= ENV["NEO4J_URL"] || "http://localhost:7474"
-      username ||= ENV["NEO4J_USERNAME"] || "neo4j"
-      password ||= ENV["NEO4J_PASSWORD"] || "password"
-      @neo4j = Neo4jOptions.new(url, username, password)
-    end
-
-    def perform_patching!
-      load "delfos/patching/basic_object.rb"
+    def reset!
+      Delfos::Setup.reset!
     end
 
-    attr_reader :neo4j
-
-    Neo4jOptions = Struct.new(:url, :username, :password) do
-      def to_s
-        "  url: #{url}\n  username: #{username}\n  password: #{password}"
-      end
+    def default_logger
+      require "logger"
+      Logger.new(STDOUT)
     end
-
-    attr_reader :application_directories, :neo4j_host, :neo4j_username, :neo4j_password
   end
 end

data/lib/delfos/call_stack.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+require_relative "neo4j"
+require_relative "neo4j/call_stack_query"
+require_relative "call_stack/stack"
+
+module Delfos
+  module CallStack
+    CALL_STACK_MUTEX = Mutex.new
+    extend self
+
+    def reset!
+      CALL_STACK_MUTEX.synchronize do
+        Thread.current[:_delfos__call_stack] = nil
+      end
+    end
+
+    def stack
+      CALL_STACK_MUTEX.synchronize do
+        Thread.current[:_delfos__call_stack] ||= Stack.new(on_empty: method(:save!))
+      end
+    end
+
+    def push(method_object)
+      stack.push(method_object)
+    end
+
+    def pop
+      stack.pop
+    end
+
+    def pop_until_top!
+      stack.pop_until_top!
+    end
+
+    def save!(call_sites, execution_number)
+      Delfos::MethodLogging.save_call_stack(call_sites, execution_number)
+    end
+  end
+end

data/lib/delfos/call_stack/stack.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+module Delfos
+  module CallStack
+    class Stack
+      def initialize(on_empty: nil)
+        @on_empty = on_empty
+      end
+
+      def push(method_object)
+        call_sites.push(method_object)
+        self.stack_depth += 1
+
+        self.execution_count += self.stack_depth == 1 ? 1 : 0
+      end
+
+      def pop
+        popping_empty_stack! if self.stack_depth.zero?
+
+        self.stack_depth -= 1
+
+        if stack_depth.zero? && call_sites.length.positive?
+          @on_empty&.call(call_sites, execution_count)
+          self.call_sites = []
+        end
+      end
+
+      def pop_until_top!
+        pop while self.stack_depth.positive?
+      end
+
+      def stack_depth
+        @stack_depth ||= 0
+      end
+
+      def execution_count
+        @execution_count ||= 0
+      end
+
+      def call_sites
+        @call_sites ||= []
+      end
+
+      def step_count
+        call_sites.length
+      end
+
+      attr_writer :stack_depth, :step_count, :execution_count, :call_sites
+
+      private
+
+      def popping_empty_stack!
+        raise PoppingEmptyStackError
+      end
+    end
+
+    class PoppingEmptyStackError < StandardError
+    end
+  end
+end

data/lib/delfos/file_system/common_path.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+require "pathname"
+
+module Delfos
+  module FileSystem
+    module CommonPath
+      class << self
+        SEPARATOR = "/"
+
+        def included_in?(p1, paths)
+          paths.any? do |p2|
+            common = common_parent(p1, p2)
+            common.to_s.length >= p2.to_s.length
+          end
+        end
+
+        def common_parent(path_a, path_b)
+          dirs = [
+            File.expand_path(path_a.to_s),
+            File.expand_path(path_b.to_s),
+          ]
+
+          dir1, dir2 = dirs.minmax.map { |dir| dir.split(SEPARATOR) }
+
+          path_from(dir1, dir2, path_a, path_b)
+        end
+
+        private
+
+        def path_from(dir1, dir2, path_a, path_b)
+          common_path = common_path(dir1, dir2)
+          common_path, path_a, path_b = append_trailing_slashes!(common_path, path_a, path_b)
+
+          Pathname.new(common_path) if valid_length?(common_path, path_a, path_b)
+        end
+
+        def valid_length?(common_path, path_a, path_b)
+          l = common_path.to_s.length
+          (l <= path_a.to_s.length) || (l <= path_b.to_s.length)
+        end
+
+        def common_path(dir1, dir2)
+          dir1.
+            zip(dir2).
+            take_while { |dn1, dn2| dn1 == dn2 }.
+            map(&:first).
+            join(SEPARATOR)
+        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
+          end
+        end
+      end
+    end
+  end
+end

data/lib/delfos/{distance/calculation.rb → file_system/distance_calculation.rb}

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 require_relative "relation"
+require_relative "path_determination"
 
 module Delfos
-  module Distance
-    class Calculation
+  module FileSystem
+    class DistanceCalculation
       attr_reader :path_a, :path_b
 
       def initialize(path_a, path_b)
-        @path_a = path_a
-        @path_b = path_b
+        @path_a, @path_b = PathDetermination.for(path_a, path_b)
       end
 
       attr_reader :traversal_a, :traversal_b
@@ -42,17 +42,6 @@ module Delfos
         siblings(path).select { |f| File.directory?(f) }
       end
 
-      def in_start_directory?(path)
-        return false if path.directory?
-        path_a.dirname == path
-      end
-
-      def in_finish_directory?(path)
-        return false if path.directory?
-
-        path_b.dirname == path
-      end
-
       def traversal_path
         TraversalPathCalculator.new(path_a, path_b).path
       end

data/lib/delfos/file_system/path_determination.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+module Delfos
+  module FileSystem
+    class PathDetermination
+      def self.for(*files)
+        files.map { |f| new(f).full_path }
+      end
+
+      def initialize(file)
+        @file = Pathname.new(strip_block_message(file))
+      end
+
+      def full_path
+        return @file.realpath if File.exist?(@file)
+
+        Delfos.application_directories.map do |d|
+          path = try_path { d + @file }
+
+          path || try_path do
+            Pathname.new(d + @file.to_s.gsub(%r{[^/]*/}, ""))
+          end
+        end.compact.first
+      end
+
+      private
+
+      def strip_block_message(f)
+        f.to_s.split(" in block").first
+      end
+
+      def try_path
+        path = yield
+        path if path.exist?
+      end
+    end
+  end
+end

data/lib/delfos/{distance → file_system}/relation.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 module Delfos
-  module Distance
+  module FileSystem
     class Relation
       attr_reader :start_path, :finish_path
 

data/lib/delfos/method_logging.rb

@@ -1,69 +1,52 @@
 # frozen_string_literal: true
-require "pathname"
-require "forwardable" unless defined? Forwardable
-require "binding_of_caller"
-require_relative "common_path"
+require "delfos/file_system/common_path"
+
 require_relative "method_logging/code_location"
-require_relative "method_logging/args"
-require_relative "execution_chain"
+require_relative "method_logging/method_parameters"
 
 module Delfos
-  class << self
-    attr_accessor :logger, :application_directories
-    attr_writer :method_logging
+  module MethodLogging
+    extend self
 
-    def method_logging
-      @method_logging ||= ::Delfos::MethodLogging
+    def save_call_stack(call_sites, execution_number)
+      Delfos.call_site_logger.save_call_stack(call_sites, execution_number)
     end
-  end
 
-  class ApplicationDirectoriesNotDefined < StandardError
-    def initialize(*_args)
-      super "Please set Delfos.application_directories"
+    def log(call_site, called_object, called_method, class_method, parameters)
+      called_code = CodeLocation.from_called(called_object, called_method, class_method)
+
+      Delfos.call_site_logger.log(parameters, call_site, called_code)
     end
-  end
 
-  module MethodLogging
-    class << self
-      def check_setup!
-        raise Delfos::ApplicationDirectoriesNotDefined unless Delfos.application_directories
-      end
+    def exclude?(method)
+      file, = method.source_location
+      return true unless file
 
-      def log(call_site, called_object, called_method, class_method, arguments)
-        check_setup!
-        arguments = Args.new(arguments)
-        called_code = CodeLocation.from_called(called_object, called_method, class_method)
+      exclude_file?(File.expand_path(file))
+    end
 
-        Delfos.logger.debug(arguments, call_site, called_code)
-      end
+    def include_file?(file)
+      !exclude_file?(file)
+    end
 
-      def include_any_path_in_logging?(paths)
-        Array(paths).inject(false) do |result, path|
-          result || include_file_in_logging?(path)
-        end
+    def exclude_file?(file)
+      with_cache(file) do
+        !FileSystem::CommonPath.included_in?(File.expand_path(file), Delfos.application_directories)
       end
+    end
 
-      def exclude?(method)
-        file, _line_number = method.source_location
-        return true unless file
-
-        exclude_file_from_logging?(File.expand_path(file))
-      end
+    def reset!
+      @cache = nil
+    end
 
-      def include_file_in_logging?(file)
-        !exclude_file_from_logging?(file)
-      end
+    private
 
-      def exclude_file_from_logging?(file)
-        check_setup!
-        path = Pathname.new(File.expand_path(file))
+    def with_cache(key)
+      cache.include?(key) ? cache[key] : cache[key] = yield
+    end
 
-        if Delfos.application_directories.is_a? Proc
-          Delfos.application_directories.call(path)
-        else
-          !CommonPath.included_in?(path, Delfos.application_directories)
-        end
-      end
+    def cache
+      @cache ||= {}
     end
   end
 end