delfos 0.0.1.pre.rc1 → 0.0.1

data/lib/delfos/patching/module_defining_methods.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+module Delfos
+  module Patching
+    # containers for the individual modules created to log each method call
+    module ClassMethodLogging
+    end
+
+    module InstanceMethodLogging
+    end
+
+    module ModuleDefiningMethods
+      def module_definition(klass, method_name, class_method, &block)
+        definer = ModuleDefiner.new(klass, method_name, class_method)
+
+        if block_given?
+          definer.perform(&block) 
+        else
+          definer.perform
+        end
+      end
+    end
+
+    class ModuleDefiner
+      attr_reader :klass, :method_name, :class_method
+
+      def initialize(klass, method_name, class_method)
+        @klass, @method_name, @class_method = klass, method_name, class_method
+      end
+
+      def perform(&block)
+        safe_method_name = safe_method_name()
+        safe_class_name = safe_class_name()
+        module_type = class_method ? "ClassMethodLogging" : "InstanceMethodLogging"
+        find_or_create = method(:find_or_create)
+
+        m = nil
+        Patching.const_get(module_type).instance_eval do
+          namespace = find_or_create.call(self, safe_class_name)
+
+          m = find_or_create.call(namespace, safe_method_name)
+
+          m.class_eval(&block) if block_given?
+
+          m
+        end
+      end
+
+      private
+
+      def safe_class_name
+        module_safe_name(klass.name || klass.to_s)
+      end
+
+      def safe_method_name
+        module_safe_name(method_name.to_s)
+      end
+
+      def find_or_create(container, module_name)
+        module_name = module_name.tr(":", "_")
+
+        result = container.const_get(module_name)
+
+        # E.g. finding `::A' instead of Delfos::Patching::InstanceMethodLogging::A
+        if result == klass || result.name[module_name] == result.name
+          create(container, module_name)
+        else
+          result
+        end
+      rescue NameError => e
+        raise unless e.message[module_name]
+        create(container, module_name)
+      end
+
+      def create(container, module_name)
+        m = Module.new
+
+        container.const_set(module_name, m)
+        return m
+      rescue Exception => e
+        m
+      end
+
+      def module_safe_name(string, _uppercase_first_letter = true)
+        string = string.sub(/^[a-z\d]*/) { $&.capitalize }
+
+        string.
+          gsub(/(?:_|(\/))([a-z\d]*)/) { "#{Regexp.last_match(1)}#{Regexp.last_match(2).capitalize}" }.
+          gsub("/", "::").
+          gsub(/\=/, "Equals").
+          gsub(/\<\=\>/, "Spaceship").
+          gsub(/\<\=/, "LessThanOrEqualTo").
+          gsub(/\>\=/, "GreaterThanOrEqualTo").
+          gsub(/\#\<Class\:0x(.*)\>/) { "AnonymousClass_#{Regexp.last_match(1)}" }.
+          gsub(/\>/, "GreaterThan").
+          gsub(/\</, "LessThan").
+          gsub(/!\~/, "NotMatchOperator").
+          gsub(/\~/, "MatchOperator").
+          gsub(/\?/, "QuestionMark").
+          gsub(/\!$/, "Bang").
+          gsub(/\+/, "Plus").
+          gsub(/\[\]/, "SquareBrackets")
+      end
+    end
+  end
+end

data/lib/delfos/patching/unstubber.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+module Delfos
+  module Patching
+    class Unstubber
+      extend ModuleDefiningMethods
+
+      def self.unstub_all!
+        MUTEX.synchronize do
+          Thread.current[:__delfos_disable_patching] = true
+        end
+
+        MethodCache.each_method do |klass_name, method, class_method|
+          klass = eval(klass_name)
+
+          unstub!(klass, method.name, class_method)
+        end
+
+        MUTEX.synchronize do
+          Thread.current[:__delfos_disable_patching] = false
+        end
+      end
+
+      def self.unstub!(klass, method_name, class_method)
+        module_definition(klass, method_name, class_method) do |m|
+          begin
+            remove_method :"#{method_name}"
+          rescue NameError => e
+            raise unless e.message["method `#{method_name}' not defined in"]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/delfos/setup.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+module Delfos
+  module Setup
+    extend self
+    attr_accessor :neo4j
+
+    def perform!(call_site_logger: nil, application_directories: nil)
+      self.application_directories = application_directories
+      self.call_site_logger = call_site_logger
+
+      perform_patching!
+    end
+
+    def application_directories=(dirs)
+      dirs ||= %w(app lib)
+      require "pathname"
+      Delfos.application_directories = Array(dirs).map { |f| Pathname.new(File.expand_path(f.to_s)) }
+    end
+
+    def call_site_logger
+      @call_site_logger ||= default_call_site_logger
+    end
+
+    def call_site_logger=(call_site_logger)
+      @call_site_logger = call_site_logger || default_call_site_logger
+    end
+
+    def default_call_site_logger
+      Delfos.setup_neo4j!
+
+      require "delfos/neo4j/informer"
+      Delfos:: Neo4j::Informer.new
+    end
+
+    def reset!
+      if defined? Delfos::CallStack
+        Delfos::CallStack.pop_until_top!
+        Delfos::CallStack.reset!
+      end
+
+      if defined? Delfos::Neo4j::Batch::Execution
+        begin
+          Delfos::Neo4j::Batch::Execution.flush!
+        rescue
+          Delfos::Neo4j::QueryExecution::ExpiredTransaction
+        end
+
+        Delfos::Neo4j::Batch::Execution.reset!
+      end
+
+      # unstubbing depends upon MethodCache being still defined
+      # so this order is important
+      unstub_all!
+      remove_cached_methods!
+
+      remove_patching!
+
+      Delfos::MethodLogging.reset! if defined?(Delfos::MethodLogging) && Delfos::MethodLogging.respond_to?(:reset!)
+
+      Delfos.neo4j                   = nil
+      Delfos.logger                  = nil
+      Delfos.application_directories = nil
+      Delfos.call_site_logger        = nil
+      @call_site_logger              = nil
+      Delfos.neo4j                   = nil
+    end
+
+    def unstub_all!
+      return unless defined? Delfos::Patching::Unstubber
+
+      Delfos::Patching::Unstubber.unstub_all!
+    end
+
+    def remove_cached_methods!
+      return unless defined? Delfos::Patching::MethodCache
+
+      Delfos::Patching::MethodCache.reset!
+    end
+
+    def remove_patching!
+      load "delfos/patching/basic_object_remove.rb"
+    end
+
+    def perform_patching!
+      load "delfos/patching/basic_object.rb"
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: delfos
 version: !ruby/object:Gem::Version
-  version: 0.0.1.pre.rc1
+  version: 0.0.1
 platform: ruby
 authors:
 - Mark Burns
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-12-08 00:00:00.000000000 Z
+date: 2016-12-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: binding_of_caller
@@ -30,6 +30,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.7.0
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: pry-byebug
   requirement: !ruby/object:Gem::Requirement
@@ -99,22 +113,35 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/delfos.rb
-- lib/delfos/common_path.rb
-- lib/delfos/distance/calculation.rb
-- lib/delfos/distance/relation.rb
-- lib/delfos/execution_chain.rb
+- lib/delfos/call_stack.rb
+- lib/delfos/call_stack/stack.rb
+- lib/delfos/file_system/common_path.rb
+- lib/delfos/file_system/distance_calculation.rb
+- lib/delfos/file_system/path_determination.rb
+- lib/delfos/file_system/relation.rb
 - lib/delfos/method_logging.rb
-- lib/delfos/method_logging/added_methods.rb
-- lib/delfos/method_logging/args.rb
+- lib/delfos/method_logging/call_site_parsing.rb
 - lib/delfos/method_logging/code_location.rb
-- lib/delfos/neo4j/distance_update.rb
-- lib/delfos/neo4j/execution_persistence.rb
+- lib/delfos/method_logging/method_parameters.rb
+- lib/delfos/neo4j.rb
+- lib/delfos/neo4j/batch/execution.rb
+- lib/delfos/neo4j/call_stack_query.rb
+- lib/delfos/neo4j/distance/call_site_fetcher.rb
+- lib/delfos/neo4j/distance/update.rb
 - lib/delfos/neo4j/informer.rb
-- lib/delfos/neo4j/query_execution.rb
+- lib/delfos/neo4j/query_execution/errors.rb
+- lib/delfos/neo4j/query_execution/http.rb
+- lib/delfos/neo4j/query_execution/http_query.rb
+- lib/delfos/neo4j/query_execution/sync.rb
+- lib/delfos/neo4j/query_execution/transactional.rb
+- lib/delfos/neo4j/schema.rb
 - lib/delfos/patching/basic_object.rb
 - lib/delfos/patching/basic_object_remove.rb
+- lib/delfos/patching/method_cache.rb
 - lib/delfos/patching/method_override.rb
-- lib/delfos/patching/unstubbing_spec_helper.rb
+- lib/delfos/patching/module_defining_methods.rb
+- lib/delfos/patching/unstubber.rb
+- lib/delfos/setup.rb
 homepage: https://github.com/markburns/delfos
 licenses:
 - MIT
@@ -131,12 +158,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: Runtime type analysis

data/lib/delfos/common_path.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-require "pathname"
-
-module Delfos
-  module CommonPath
-    class << self
-      SEPARATOR = "/"
-
-      def included_in?(p1, paths)
-        paths = paths.map do |p2|
-          common = common_parent_directory_path(p1, p2)
-          common.to_s.length >= p2.to_s.length
-        end
-
-        paths.compact.detect { |v| v }
-      end
-
-      def common_parent_directory_path(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)
-        (common_path.to_s.length <= path_a.to_s.length) || (common_path.to_s.length <= 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

data/lib/delfos/execution_chain.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-require_relative "neo4j/execution_persistence"
-
-module Delfos
-  class ExecutionChain
-    EXECUTION_CHAIN_MUTEX = Mutex.new
-
-    def self.reset!
-      EXECUTION_CHAIN_MUTEX.synchronize do
-        Thread.current[:_delfos__execution_chain] = nil
-      end
-    end
-
-    def self.execution_chain
-      EXECUTION_CHAIN_MUTEX.synchronize do
-        Thread.current[:_delfos__execution_chain] ||= new
-      end
-    end
-
-    def self.push(method_object)
-      execution_chain.push(method_object)
-    end
-
-    def self.pop
-      execution_chain.pop
-    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
-
-      save_and_reset!  if self.stack_depth.zero?
-    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
-
-    class PoppingEmptyStackError < StandardError
-    end
-
-    def popping_empty_stack!
-      raise PoppingEmptyStackError
-    end
-
-    def save_and_reset!
-      Neo4j::ExecutionPersistence.save!(self) if call_sites.length.positive?
-      self.call_sites = []
-    end
-  end
-end