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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 504300a4ec558fbb0620996b4f1452dfd7f7424c
-  data.tar.gz: cf3adbd6030184d208a52d7586a816cc1d365668
+  metadata.gz: 942050257d2df0f604039c76a5503f892118ba8c
+  data.tar.gz: bbafde8bed085d9c67c75d6ff9d065f578b8d8b1
 SHA512:
-  metadata.gz: be9e77733e7d6af4ac90e62a5bbfac8ae056dbd2b6839e4a16e0c82960e64dd83d93ef8b72787b1b411f992687a67327790a3e9a9367c0dfeabe503c66d931a4
-  data.tar.gz: 6358c9cf62d2a2db3cf12b1fd025edc65e71c3982ad3d1d56a1d8adfb871777111da61f1dcb62ad17a213069666ce59594c24a4a75fc951991610998bf2d8b9b
+  metadata.gz: 26f22aa726e32d4aaaffc19aebcfad37d0a19150bb85cd4aa709d358d9733258954168837adcc31af470440cbd69d7ae8106ff6616f20277507c0d58ed3db6cf
+  data.tar.gz: 9aa2570f3afda8ec7aa4e9abd998385adc0d3dedd0acc32344b2758815d38ed2b2f326a880490310b0264c20caf00642679a665c45d7694a45ac092a195ab44f

data/lib/delfos.rb

@@ -1,17 +1,18 @@
 # frozen_string_literal: true
-require "delfos/version"
-require "delfos/method_logging"
-require "delfos/neo4j/query_execution"
 require "delfos/neo4j/informer"
 
 module Delfos
   class << self
+    attr_writer :application_directories
+
     def check_setup!
       raise "Delfos.setup! has not been called" unless neo4j_config && logger
     end
 
     def wipe_db!
-      Delfos.setup!(application_directories: [])
+      Delfos.setup_neo4j!
+
+      require "delfos/neo4j/query_execution"
       Delfos::Neo4j::QueryExecution.execute <<-QUERY
         MATCH (m)-[rel]->(n)
         DELETE m,rel,n
@@ -20,39 +21,80 @@ module Delfos
 
     def reset!
       @application_directories = []
-      @neo4j_config = nil
+      @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!
     end
 
-    def remove_patching!
-      load "delfos/remove_patching.rb"
-      begin
-        Delfos::Patching.instance_eval { @added_methods = nil }
-      rescue
-        nil
+    def unstub_all!
+      if defined? Delfos::Patching::MethodOverride
+
+        if Delfos::Patching::MethodOverride.respond_to?(:unstub_all!)
+          Delfos::Patching::MethodOverride.unstub_all!
+        end
       end
     end
 
-    def setup!(
-      connection_type: :server_db,
-      logger: Delfos::Neo4j::Informer.new,
-      host:"http://localhost:7474",
-      auth: { basic_auth: { username: "neo4j", password: "password" } },
-      application_directories: nil)
+    def remove_added_methods!
+      if defined? Delfos::MethodLogging::AddedMethods
+        Delfos::MethodLogging::AddedMethods.instance_eval { @instance = nil }
+      end
+    end
+
+    def remove_patching!
+      load "delfos/patching/basic_object_remove.rb"
+    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
 
-      @application_directories = application_directories.map{|f| Pathname.new(File.expand_path(f.to_s))}
       @logger = logger
 
-      @neo4j_config = [connection_type, host, auth]
+      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/perform_patching.rb"
+      load "delfos/patching/basic_object.rb"
+    end
+
+    attr_reader :neo4j
+
+    Neo4jOptions = Struct.new(:url, :username, :password) do
+      def to_s
+        "  url: #{url}\n  username: #{username}\n  password: #{password}"
+      end
     end
 
-    attr_reader :application_directories, :neo4j_config
+    attr_reader :application_directories, :neo4j_host, :neo4j_username, :neo4j_password
   end
 end

data/lib/delfos/common_path.rb

@@ -29,9 +29,7 @@ module Delfos
         common_path = common_path(dir1, dir2)
         common_path, path_a, path_b = append_trailing_slashes!(common_path, path_a, path_b)
 
-        if valid_length?(common_path, path_a, path_b)
-          Pathname.new(common_path)
-        end
+        Pathname.new(common_path) if valid_length?(common_path, path_a, path_b)
       end
 
       def valid_length?(common_path, path_a, path_b)

data/lib/delfos/execution_chain.rb

@@ -1,42 +1,43 @@
+# frozen_string_literal: true
 require_relative "neo4j/execution_persistence"
 
 module Delfos
   class ExecutionChain
-    METHOD_CHAIN_MUTEX = Mutex.new
+    EXECUTION_CHAIN_MUTEX = Mutex.new
 
     def self.reset!
-      METHOD_CHAIN_MUTEX.synchronize do
-        Thread.current[:_delfos__execution_chain__method_chain] = nil
+      EXECUTION_CHAIN_MUTEX.synchronize do
+        Thread.current[:_delfos__execution_chain] = nil
       end
     end
 
-    def self.method_chain
-      METHOD_CHAIN_MUTEX.synchronize do
-        Thread.current[:_delfos__execution_chain__method_chain] ||= new
+    def self.execution_chain
+      EXECUTION_CHAIN_MUTEX.synchronize do
+        Thread.current[:_delfos__execution_chain] ||= new
       end
     end
 
     def self.push(method_object)
-      method_chain.push(method_object)
+      execution_chain.push(method_object)
     end
 
     def self.pop
-      method_chain.pop
+      execution_chain.pop
     end
 
     def push(method_object)
-      self.call_sites.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 == 0
+      popping_empty_stack! if self.stack_depth.zero?
 
       self.stack_depth -= 1
 
-      save_and_reset!  if self.stack_depth == 0
+      save_and_reset!  if self.stack_depth.zero?
     end
 
     def stack_depth
@@ -55,6 +56,8 @@ module Delfos
       call_sites.length
     end
 
+    attr_writer :stack_depth, :step_count, :execution_count, :call_sites
+
     private
 
     class PoppingEmptyStackError < StandardError
@@ -65,10 +68,8 @@ module Delfos
     end
 
     def save_and_reset!
-      Neo4j::ExecutionPersistence.save!(self)  if call_sites.length > 0
+      Neo4j::ExecutionPersistence.save!(self) if call_sites.length.positive?
       self.call_sites = []
     end
-
-    attr_writer :stack_depth, :step_count, :execution_count, :call_sites
   end
 end

data/lib/delfos/method_logging.rb

@@ -1,9 +1,8 @@
 # frozen_string_literal: true
 require "pathname"
-require "forwardable"
+require "forwardable" unless defined? Forwardable
 require "binding_of_caller"
 require_relative "common_path"
-require_relative "method_logging/klass_determination"
 require_relative "method_logging/code_location"
 require_relative "method_logging/args"
 require_relative "execution_chain"
@@ -11,6 +10,11 @@ require_relative "execution_chain"
 module Delfos
   class << self
     attr_accessor :logger, :application_directories
+    attr_writer :method_logging
+
+    def method_logging
+      @method_logging ||= ::Delfos::MethodLogging
+    end
   end
 
   class ApplicationDirectoriesNotDefined < StandardError
@@ -25,32 +29,21 @@ module Delfos
         raise Delfos::ApplicationDirectoriesNotDefined unless Delfos.application_directories
       end
 
-      def log(called_object,
-        args, keyword_args, _block,
-        class_method,
-        stack, call_site_binding,
-        called_method)
+      def log(call_site, called_object, called_method, class_method, arguments)
         check_setup!
-
-        call_site = CodeLocation.from_call_site(stack, call_site_binding)
-        Delfos::ExecutionChain.push(call_site)
-
-        return unless call_site
-
-        args = Args.new(args.dup, keyword_args.dup)
-
+        arguments = Args.new(arguments)
         called_code = CodeLocation.from_called(called_object, called_method, class_method)
 
-        Delfos.logger.debug(args, call_site, called_code)
+        Delfos.logger.debug(arguments, call_site, called_code)
       end
 
       def include_any_path_in_logging?(paths)
-        paths.inject(false) do |result, path|
+        Array(paths).inject(false) do |result, path|
           result || include_file_in_logging?(path)
         end
       end
 
-      def exclude_from_logging?(method)
+      def exclude?(method)
         file, _line_number = method.source_location
         return true unless file
 
@@ -63,8 +56,13 @@ module Delfos
 
       def exclude_file_from_logging?(file)
         check_setup!
-        path = Pathname.new(File.expand_path file)
-        !CommonPath.included_in?(path, Delfos.application_directories)
+        path = Pathname.new(File.expand_path(file))
+
+        if Delfos.application_directories.is_a? Proc
+          Delfos.application_directories.call(path)
+        else
+          !CommonPath.included_in?(path, Delfos.application_directories)
+        end
       end
     end
   end

data/lib/delfos/method_logging/added_methods.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+require "Forwardable" unless defined? Forwardable
+
+module Delfos
+  module MethodLogging
+    class AddedMethods
+      class << self
+        extend Forwardable
+
+        def_delegators :instance,
+          :all_method_sources_for,
+          :method_source_for,
+          :append,
+          :find
+
+        def instance
+          @instance ||= new
+        end
+      end
+
+      def initialize
+        @added_methods = {}
+      end
+
+      attr_reader :added_methods
+
+      def all_method_sources_for(klass)
+        fetch(klass).values.map(&:source_location)
+      end
+
+      def method_source_for(klass, key)
+        meth = find(klass, key)
+
+        if meth
+          meth.source_location
+        end
+      end
+
+      def append(klass, key, original_method)
+        m = fetch(klass)[key] 
+
+        if m.nil?
+          fetch(klass)[key]  = original_method
+        end
+      end
+
+      def find(klass, key)
+        fetch(klass)[key]
+      end
+
+      private
+
+      def fetch(klass)
+        # Find method definitions defined in klass or its ancestors
+        super_klass = klass.ancestors.detect do |k|
+          (fetch_without_default(k) || {}).values.length.positive?
+        end
+
+        added_methods[(super_klass || klass).to_s] ||= {}
+      end
+
+      def fetch_without_default(klass)
+        added_methods[klass.to_s]
+      end
+    end
+  end
+end

data/lib/delfos/method_logging/args.rb

@@ -1,52 +1,53 @@
 # frozen_string_literal: true
 require_relative "../../delfos"
 require_relative "../common_path"
-require_relative "klass_determination"
+require_relative "./added_methods"
 
 module Delfos
   module MethodLogging
     class Args
-      include KlassDetermination
+      attr_reader :block
 
-      def initialize(args, keyword_args)
-        @raw_args = args
-        @raw_keyword_args = keyword_args
+      def initialize(arguments)
+        @raw_args = arguments.args
+        @raw_keyword_args = arguments.keyword_args
+        @block = arguments.block
       end
 
       def args
         @args ||= calculate_args(@raw_args)
       end
 
-      def calculate_args(args)
-        klass_file_locations(args).select do |_klass, locations|
-          Delfos::MethodLogging.include_any_path_in_logging?(locations)
-        end.map(&:first)
-      end
-
       def keyword_args
         @keyword_args ||= calculate_args(@raw_keyword_args.values)
       end
 
-      def klass_locations(klass)
-        files = method_sources(klass)
+      private
 
-        files.flatten.compact.uniq
+      def calculate_args(arguments)
+        arguments.
+          map { |o| o.is_a?(Class) ? o : o.class }.
+          select { |k| keep?(k) }
       end
 
-      private
+      def keep?(klass)
+        files_for(klass).
+          select { |f| record?(f) }.length.positive?
+      end
 
-      def klass_file_locations(args)
-        klasses(args).each_with_object({}) { |k, result| result[k] = klass_locations(k) }
+      def files_for(klass)
+        source_files(klass).
+          flatten.
+          compact.
+          uniq
       end
 
-      def klasses(args)
-        args.map do |k|
-          klass_for(k)
-        end
+      def source_files(klass)
+        AddedMethods.all_method_sources_for(klass).map(&:first)
       end
 
-      def method_sources(klass)
-        (Delfos::Patching.added_methods[klass.to_s] || {}).values.map(&:first)
+      def record?(f)
+        Delfos.method_logging.include_any_path_in_logging?(f)
       end
     end
   end

data/lib/delfos/method_logging/code_location.rb

@@ -1,11 +1,8 @@
 # frozen_string_literal: true
-require_relative "klass_determination"
 
 module Delfos
   module MethodLogging
     class CodeLocation
-      include KlassDetermination
-
       class << self
         def from_call_site(stack, call_site_binding)
           CallSiteParsing.new(stack, call_site_binding).perform
@@ -21,18 +18,6 @@ module Delfos
         def method_type_from(class_method)
           class_method ? "ClassMethod" : "InstanceMethod"
         end
-
-        def method_definition_for(klass, class_method, method_name)
-          key = key_from(class_method, method_name)
-
-          Delfos::Patching.method_definition_for(klass, key)
-        end
-
-        private
-
-        def key_from(class_method, name)
-          "#{method_type_from(class_method)}_#{name}"
-        end
       end
 
       attr_reader :object, :method_name, :class_method, :method_type, :file, :line_number
@@ -44,7 +29,6 @@ module Delfos
         @method_type = self.class.method_type_from class_method
         @line_number = line_number.to_i
         @file = file
-
       end
 
       def file
@@ -71,7 +55,7 @@ module Delfos
       end
 
       def klass
-        klass_for(object)
+        object.is_a?(Class) ? object : object.class
       end
 
       def klass_name
@@ -80,11 +64,21 @@ module Delfos
       end
 
       def method_definition_file
-        method_definition[0].to_s
+        if method_definition
+          method_definition[0].to_s
+        else
+          #TODO fix edge case when block
+          "#{@file} in block"
+        end
       end
 
       def method_definition_line
-        method_definition[1].to_i
+        if method_definition
+          method_definition[1].to_i
+        else
+          #TODO fix edge case when block
+          0
+        end
       end
 
       private
@@ -94,23 +88,22 @@ module Delfos
       end
 
       def method_definition
-        (@method_definition ||= self.class.method_definition_for(klass, class_method, method_name)) || {}
+        @method_definition ||= ::Delfos::MethodLogging::AddedMethods.method_source_for(klass, method_key)
       end
     end
 
     class CallSiteParsing
-      # This magic number is determined based on the specific implementation now
-      # E.g. if the line
-      # where we call this `call_site_binding.of_caller(stack_index + STACK_OFFSET).eval('self')`
-      # is to be extracted into another method we will get a failing test and have to increment
-      # the value
+      # This magic number is based on the implementation within this file.
+      # If the line with `call_site_binding.of_caller(stack_index + STACK_OFFSET).receiver`
+      # is moved up or down the call stack a test fails and we have to change `STACK_OFFSET`
       STACK_OFFSET = 5
 
       attr_reader :stack, :call_site_binding
 
-      def initialize(stack, call_site_binding)
+      def initialize(stack, call_site_binding, stack_offset: nil)
         @stack = stack
         @call_site_binding = call_site_binding
+        @stack_offset = stack_offset
       end
 
       def perform
@@ -129,12 +122,16 @@ module Delfos
       def current
         stack.detect do |s|
           file = s.split(":")[0]
-          Delfos::MethodLogging.include_file_in_logging?(file)
+          Delfos.method_logging.include_file_in_logging?(file)
         end
       end
 
       def object
-        @object ||= call_site_binding.of_caller(stack_index + STACK_OFFSET).receiver
+        @object ||= call_site_binding.of_caller(stack_index + stack_offset).receiver
+      end
+
+      def stack_offset
+        @stack_offset ||= STACK_OFFSET
       end
 
       def stack_index