delfos 0.0.1.pre.rc1 → 0.0.1

data/lib/delfos/neo4j/query_execution/sync.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+require "json"
+require "uri"
+
+require_relative "http_query"
+require_relative "errors"
+
+module Delfos
+  module Neo4j
+    module QueryExecution
+      class Sync
+        include HttpQuery
+
+        def perform
+          raise InvalidQuery.new(json["errors"], query, params) if errors?
+
+          strip_out_meta_data
+        end
+
+        private
+
+        def strip_out_meta_data
+          json["results"]
+          &.first
+          &.[]("data")
+          &.map { |r| r["row"] }
+        end
+
+        def uri
+          @uri ||= Delfos.neo4j.uri_for("/db/data/transaction/commit")
+        end
+      end
+    end
+  end
+end

data/lib/delfos/neo4j/query_execution/transactional.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+require "json"
+require "uri"
+require "time"
+
+require_relative "http"
+require_relative "http_query"
+
+module Delfos
+  module Neo4j
+    module QueryExecution
+      class Transactional
+        include HttpQuery
+
+        def self.flush!(commit_url)
+          response = Http.new(commit_url).post({ statements: [] }.to_json)
+
+          check_for_error(commit_url, response)
+
+          response.code == "200"
+        end
+
+        VALID_RESPONSE_MATCHER = /\A2\d\d\z/
+
+        def self.check_for_error(uri, response)
+          return if response.code[VALID_RESPONSE_MATCHER]
+
+          if response.code == "404"
+            raise ExpiredTransaction.new(uri, response)
+          end
+
+          raise InvalidCommit.new(uri, response)
+        end
+
+        def perform
+          self.class.check_for_error(uri, response)
+
+          raise InvalidQuery.new(json["errors"], query, params) if errors?
+
+          transaction_url = URI.parse  header("location") if header("location")
+          commit_url      = URI.parse  json["commit"]     if json["commit"]
+          expires         = Time.parse json["transaction"]["expires"] if json["transaction"]
+
+          [transaction_url, commit_url, expires]
+        end
+
+        private
+
+        def header(name)
+          response.each_header.to_a.find { |n, _| n == name }&.last
+        end
+
+        def uri
+          @uri ||= Delfos.neo4j.uri_for("/db/data/transaction")
+        end
+      end
+
+      class InvalidCommit < IOError
+        def initialize(commit_url, response)
+          super ["URL:", commit_url, "response:", response].join("\n  ")
+        end
+      end
+
+      class ExpiredTransaction < InvalidCommit
+      end
+    end
+  end
+end

data/lib/delfos/neo4j/schema.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+module Delfos
+  module Neo4j
+    module Schema
+      extend self
+
+      def ensure_constraints!(required)
+        log "-" * 80
+        log "checking constraints"
+        log Time.now
+        log "-" * 80
+
+        if satisfies_constraints?(required)
+          log "Neo4j schema constraints satisfied"
+        else
+          error "-" * 80
+          error "Neo4j schema constraints not satisfied - adding"
+          error Time.now
+
+          required.each do |label, attribute|
+            create_constraint(label, attribute)
+          end
+
+          log "-" * 80
+          log "Constraints added"
+          log Time.now
+        end
+      end
+
+      private
+
+      def error(s)
+        log(s, :error)
+      end
+
+      def log(s, type = :debug)
+        Delfos.logger.send(type, s)
+      end
+
+      def create_constraint(label, attribute)
+        Neo4j.execute_sync <<-QUERY
+          CREATE CONSTRAINT ON (c:#{label}) ASSERT c.#{attribute} IS UNIQUE
+        QUERY
+      end
+
+      def satisfies_constraints?(required)
+        existing_constraints = fetch_existing_constraints
+
+        required.inject(true) do |_result, (label, attribute)|
+          constraint = existing_constraints.find { |c| c["label"] == label }
+
+          constraint && constraint["property_keys"].include?(attribute)
+        end
+      end
+
+      def fetch_existing_constraints
+        response = QueryExecution::Http.new(constraints_uri).get
+
+        if response.code == "200"
+          JSON.parse response.body
+        else
+          raise IOError.new uri, response
+        end
+      end
+
+      private
+
+      def constraints_uri
+        Delfos.neo4j.uri_for("/db/data/schema/constraint")
+      end
+    end
+  end
+end

data/lib/delfos/patching/basic_object.rb

@@ -3,15 +3,11 @@ require_relative "method_override"
 
 class BasicObject
   def self.method_added(name)
-    return if %i(to_s singleton_method_added method_added).include?(name)
-
     ::Delfos::Patching::MethodOverride.setup(self, name, private_instance_methods, class_method: false)
   end
 
   def self.singleton_method_added(name)
-    # can't currently support to_s and name as those are used inside the method logging code
-    return if %i(to_s name extended included inherited method_added singleton_method_added).include?(name)
-    return if ::Delfos::MethodLogging.exclude?(method(name))
+    return if %i(define_method extended included inherited method_added singleton_method_added).include?(name)
 
     ::Delfos::Patching::MethodOverride.setup(self, name, private_methods, class_method: true)
   end

data/lib/delfos/patching/method_cache.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+require "Forwardable" unless defined? Forwardable
+
+module Delfos
+  module Patching
+    class MethodCache
+      class << self
+        extend Forwardable
+
+        def_delegators :instance,
+          :files_for,
+          :append,
+          :find
+
+        def reset!
+          @instance = nil
+        end
+
+        def instance
+          @instance ||= new
+        end
+
+        def each_method
+          instance.send(:added_methods).each do |klass, methods|
+            methods.each do |k, m|
+              class_method = !!(k[/^ClassMethod_/])
+              yield klass, m, class_method
+            end
+          end
+        end
+      end
+
+      def initialize
+        @added_methods = {}
+      end
+
+      def files_for(klass)
+        fetch(klass).
+          values.
+          map(&:source_location).
+          compact.
+          map(&:first).
+          compact.
+          uniq
+      end
+
+      def append(klass:, method:)
+        class_method = method.respond_to?(:receiver) && method.receiver.is_a?(Class)
+        key = key_for(class_method, method.name)
+        m = fetch(klass)[key]
+
+        fetch(klass)[key] = method if m.nil?
+      end
+
+      def find(klass:, method_name:, class_method:)
+        key = key_for(class_method, method_name)
+
+        fetch(klass)[key]
+      end
+
+      private
+
+      attr_reader :added_methods
+
+      def key_for(class_method, method_name)
+        class_method ? "ClassMethod_#{method_name}" : "InstanceMethod_#{method_name}"
+      end
+
+      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/patching/method_override.rb

@@ -1,25 +1,60 @@
 # frozen_string_literal: true
 
-require_relative "../method_logging"
+require "delfos/method_logging"
+require "delfos/call_stack"
+
+require_relative "module_defining_methods"
+require_relative "unstubber"
 
 module Delfos
   module Patching
+    MUTEX = Mutex.new
+
     class MethodOverride
+      include ModuleDefiningMethods
+
       class << self
         def setup(klass, name, private_methods, class_method:)
+          return if skip_meta_programming_defined_method?
+
+          MUTEX.synchronize do
+            return if Thread.current[:__delfos_disable_patching]
+          end
+
           instance = new(klass, name, private_methods, class_method)
 
           instance.ensure_method_recorded_once!
         end
+
+        META_PROGRAMMING_REGEX = /`define_method'\z|`attr_accessor'\z|`attr_reader'\z|`attr_writer'\z/
+
+        def skip_meta_programming_defined_method?
+          stack = caller.dup
+
+          i = stack.index do |l|
+            l["delfos/patching/basic_object.rb"]
+          end
+
+          return unless i
+
+          result = stack[i + 1][META_PROGRAMMING_REGEX]
+
+          return unless result
+
+          Delfos.logger.debug "Skipping setting up delfos logging of method defined by #{result} #{stack[i+1]}"
+          true
+        end
+
+
       end
 
       attr_reader :klass, :name, :private_methods, :class_method
 
       def initialize(klass, name, private_methods, class_method)
-        @klass = klass
-        @name = name
+        @klass           = klass
+        @name            = name
         @private_methods = private_methods
-        @class_method = class_method
+        @class_method    = class_method
         original_method # ensure memoized method is the original not the overridden one
       end
 
@@ -27,59 +62,55 @@ module Delfos
         record_method! { setup }
       end
 
-      # Redefine the method (only once) at runtime to enabling logging to Neo4j
+
+      # Redefine the method at runtime to enabling logging to Neo4j
       def setup
-        processor = method(:process)
         cm = class_method
-
-        method_defining_method.call(name) do |*args, **kw_args, &block|
-          arguments = MethodArguments.new(args, kw_args, block, cm)
-
-          processor.call(self, caller.dup, binding.dup, arguments)
-        end
-      end
-
-      def process(instance, stack, caller_binding, arguments)
-        method_to_call = method_selector(instance)
-
-        call_site = Delfos::MethodLogging::CodeLocation.from_call_site(stack, caller_binding)
-
-        with_logging(call_site, instance, method_to_call, class_method, arguments) do
-          arguments.apply_to(method_to_call)
+        with_stack = method(:with_stack)
+        method_name = name
+        om = original_method
+
+        mod = module_definition(klass, name, class_method) do
+          define_method(method_name) do |*args, **kw_args, &block|
+            stack = caller.dup
+            caller_binding = binding.dup
+            parameters = Delfos::MethodLogging::MethodParameters.new(args, kw_args, block)
+
+            call_site = Delfos::MethodLogging::CodeLocation.from_call_site(stack, caller_binding)
+
+            if call_site
+              Delfos::MethodLogging.log(call_site, self, om, cm, parameters)
+            end
+
+            with_stack.call(call_site) do
+              if !kw_args.empty?
+                super(*args, **kw_args, &block)
+              else
+                super(*args, &block)
+              end
+            end
+          end
         end
-      end
+        return unless mod
 
-      def with_logging(call_site, instance, method_to_call, class_method, arguments)
-        Delfos.method_logging.log(call_site, instance, method_to_call, class_method, arguments) if call_site
-
-        with_stack(call_site) do
-          yield
+        if class_method
+          klass.prepend mod
+        else
+          klass.instance_eval { prepend mod }
         end
       end
 
-
       def with_stack(call_site)
         return yield unless call_site
 
         begin
-          ExecutionChain.push(call_site)
+          CallStack.push(call_site)
           yield
         ensure
-          ExecutionChain.pop
+          CallStack.pop
         end
       end
 
-      MethodArguments = Struct.new(:args, :keyword_args, :block, :class_method) do
-        def apply_to(method)
-          if keyword_args.empty?
-            method.call(*args, &block)
-          else
-            method.call(*args, **keyword_args, &block)
-          end
-        end
-      end
-
-
       def original_method
         @original_method ||= if class_method
                                klass.method(name)
@@ -92,22 +123,9 @@ module Delfos
 
       def record_method!
         return true if bail?
-        yield
+        MethodCache.append(klass: klass, method: original_method)
 
-        Delfos::MethodLogging::AddedMethods.append(klass, key, original_method)
-      end
-
-      def method_selector(instance)
-        if class_method
-          m = Delfos::MethodLogging::AddedMethods.find(instance, "ClassMethod_#{name}")
-          m.receiver == instance ? m : m.unbind.bind(instance)
-        else
-          original_method.bind(instance)
-        end
-      end
-
-      def method_defining_method
-        class_method ? klass.method(:define_singleton_method) : klass.method(:define_method)
+        yield
       end
 
       def bail?
@@ -115,7 +133,7 @@ module Delfos
       end
 
       def method_has_been_added?
-        Delfos::MethodLogging::AddedMethods.find(klass, key)
+        MethodCache.find(klass: klass, class_method: class_method, method_name: name)
       end
 
       def private_method?
@@ -123,15 +141,7 @@ module Delfos
       end
 
       def exclude?
-        ::Delfos.method_logging.exclude?(original_method)
-      end
-
-      def key
-        "#{type}_#{name}"
-      end
-
-      def type
-        class_method ? "ClassMethod" : "InstanceMethod"
+        ::Delfos::MethodLogging.exclude?(original_method)
       end
     end
   end