delfos 0.0.1 → 0.0.2.pre.rc2

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "json"
 require "uri"
 

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "json"
 require "uri"
 require "time"
@@ -12,10 +13,10 @@ module Delfos
       class Transactional
         include HttpQuery
 
-        def self.flush!(commit_url)
-          response = Http.new(commit_url).post({ statements: [] }.to_json)
+        def self.commit!(url)
+          response = Http.new(url).post({ statements: [] }.to_json)
 
-          check_for_error(commit_url, response)
+          check_for_error(url, response)
 
           response.code == "200"
         end
@@ -25,27 +26,37 @@ module Delfos
         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 ExpiredTransaction.new(uri, response) if response.code == "404"
 
           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"]
+          validate!
 
           [transaction_url, commit_url, expires]
         end
 
         private
 
+        def transaction_url
+          URI.parse(header("location")) if header("location")
+        end
+
+        def commit_url
+          URI.parse(json["commit"]) if json["commit"]
+        end
+
+        def expires
+          Time.parse json["transaction"]["expires"] if json["transaction"]
+        end
+
+        def validate!
+          self.class.check_for_error(uri, response)
+
+          raise InvalidQuery.new(json["errors"], query, params) if errors?
+        end
+
         def header(name)
           response.each_header.to_a.find { |n, _| n == name }&.last
         end

data/lib/delfos/neo4j/schema.rb

@@ -1,38 +1,28 @@
 # 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
+          log "Neo4j schema constraints not satisfied - adding", :warn
 
           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
@@ -56,14 +46,10 @@ module Delfos
       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
+        raise IOError.new uri, response unless response.code == "200"
 
-      private
+        JSON.parse response.body
+      end
 
       def constraints_uri
         Delfos.neo4j.uri_for("/db/data/schema/constraint")

data/lib/delfos/setup.rb

@@ -1,88 +1,120 @@
 # 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
+    def perform!(call_site_logger: nil,
+      application_directories: nil,
+      offline_query_saving: nil)
+      self.application_directories = application_directories if application_directories
+      self.call_site_logger = call_site_logger if call_site_logger
+
+      assign_offline_attributes(offline_query_saving)
 
-      perform_patching!
+      require "delfos/method_trace"
+      ::Delfos::MethodTrace.trace!
     end
 
     def application_directories=(dirs)
-      dirs ||= %w(app lib)
+      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
+      Delfos.application_directories = Array(dirs).map { |f| Pathname.new(f.to_s).expand_path }
     end
 
     def call_site_logger=(call_site_logger)
-      @call_site_logger = call_site_logger || default_call_site_logger
+      Delfos.call_site_logger = call_site_logger || default_call_site_logger
     end
 
     def default_call_site_logger
-      Delfos.setup_neo4j!
+      if Delfos.offline_query_saving
+        require "delfos/neo4j/offline/call_site_logger"
+        Delfos:: Neo4j::Offline::CallSiteLogger.new
+      else
+        Delfos.setup_neo4j!
+
+        require "delfos/neo4j/live/call_site_logger"
+        Delfos:: Neo4j::Live::CallSiteLogger.new
+      end
+    end
+
+    def disable!
+      disable_tracepoint!
+
+      reset_call_stack!
+      reset_batch!
+
+      reset_top_level_variables!
+      reset_app_directories!
+    end
 
-      require "delfos/neo4j/informer"
-      Delfos:: Neo4j::Informer.new
+    def disable_tracepoint!
+      require "delfos/method_trace"
+      ::Delfos::MethodTrace.disable!
     end
 
-    def reset!
-      if defined? Delfos::CallStack
-        Delfos::CallStack.pop_until_top!
-        Delfos::CallStack.reset!
+    def reset_call_stack!
+      ignoring_undefined("Delfos::CallStack") do |k|
+        k.pop_until_top!
+        k.reset!
       end
+    end
+
+    def reset_batch!
+      Delfos.batch_size = nil
 
-      if defined? Delfos::Neo4j::Batch::Execution
+      ignoring_undefined "Delfos::Neo4j::Batch::Retryable" do |b|
         begin
-          Delfos::Neo4j::Batch::Execution.flush!
-        rescue
-          Delfos::Neo4j::QueryExecution::ExpiredTransaction
+          with_rescue { b.flush! }
+        ensure
+          b.instance = nil
         end
-
-        Delfos::Neo4j::Batch::Execution.reset!
       end
+    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!)
+    def reset_app_directories!
+      ignoring_undefined("Delfos::FileSystem::AppDirectories", &:reset!)
+    end
 
+    def reset_top_level_variables!
+      Delfos.offline_query_saving    = nil
+      Delfos.offline_query_filename  = nil
       Delfos.neo4j                   = nil
       Delfos.logger                  = nil
       Delfos.application_directories = nil
       Delfos.call_site_logger        = nil
-      @call_site_logger              = nil
+      Delfos.max_query_size          = nil
       Delfos.neo4j                   = nil
     end
 
-    def unstub_all!
-      return unless defined? Delfos::Patching::Unstubber
+    # This method allows resetting in between every spec.  So we avoid load
+    # order issues in cases where we have not run particular specs that require
+    # and define these constants
+    def ignoring_undefined(k)
+      o = Object.const_get(k)
+      yield(o)
+    rescue NameError => e
+      raise unless e.message[k]
+    end
 
-      Delfos::Patching::Unstubber.unstub_all!
+    def with_rescue
+      yield
+    rescue Delfos::Neo4j::QueryExecution::ExpiredTransaction
+      puts # no-op
     end
 
-    def remove_cached_methods!
-      return unless defined? Delfos::Patching::MethodCache
+    def assign_offline_attributes(offline_query_saving)
+      return unless offline_query_saving
+      Delfos.offline_query_saving = offline_query_saving
 
-      Delfos::Patching::MethodCache.reset!
+      Delfos.offline_query_filename = filename_from(offline_query_saving)
     end
 
-    def remove_patching!
-      load "delfos/patching/basic_object_remove.rb"
-    end
+    def filename_from(offline_query_saving)
+      return offline_query_saving if offline_query_saving.is_a?(String)
 
-    def perform_patching!
-      load "delfos/patching/basic_object.rb"
+      "delfos_query_parameters.json"
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: delfos
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2.pre.rc2
 platform: ruby
 authors:
 - Mark Burns
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-12-29 00:00:00.000000000 Z
+date: 2017-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: binding_of_caller
@@ -30,8 +30,64 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.7.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  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: rspec_junit_formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.3
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  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: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.3.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.3.2
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -115,32 +171,35 @@ files:
 - lib/delfos.rb
 - lib/delfos/call_stack.rb
 - lib/delfos/call_stack/stack.rb
+- lib/delfos/file_system.rb
+- lib/delfos/file_system/app_directories.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/call_site_parsing.rb
-- lib/delfos/method_logging/code_location.rb
-- lib/delfos/method_logging/method_parameters.rb
+- lib/delfos/method_trace.rb
+- lib/delfos/method_trace/call_handler.rb
+- lib/delfos/method_trace/code_location.rb
+- lib/delfos/method_trace/code_location/call_site.rb
+- lib/delfos/method_trace/code_location/container_method_factory.rb
+- lib/delfos/method_trace/code_location/eval_in_caller.rb
+- lib/delfos/method_trace/code_location/filename_helpers.rb
+- lib/delfos/method_trace/code_location/method.rb
 - lib/delfos/neo4j.rb
 - lib/delfos/neo4j/batch/execution.rb
-- lib/delfos/neo4j/call_stack_query.rb
+- lib/delfos/neo4j/batch/retryable.rb
+- lib/delfos/neo4j/call_site_query.rb
 - lib/delfos/neo4j/distance/call_site_fetcher.rb
 - lib/delfos/neo4j/distance/update.rb
-- lib/delfos/neo4j/informer.rb
+- lib/delfos/neo4j/live/call_site_logger.rb
+- lib/delfos/neo4j/offline/call_site_logger.rb
+- lib/delfos/neo4j/offline/importer.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/module_defining_methods.rb
-- lib/delfos/patching/unstubber.rb
 - lib/delfos/setup.rb
 homepage: https://github.com/markburns/delfos
 licenses:
@@ -155,15 +214,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Runtime type analysis

data/lib/delfos/method_logging.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-require "delfos/file_system/common_path"
-
-require_relative "method_logging/code_location"
-require_relative "method_logging/method_parameters"
-
-module Delfos
-  module MethodLogging
-    extend self
-
-    def save_call_stack(call_sites, execution_number)
-      Delfos.call_site_logger.save_call_stack(call_sites, execution_number)
-    end
-
-    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
-
-    def exclude?(method)
-      file, = method.source_location
-      return true unless file
-
-      exclude_file?(File.expand_path(file))
-    end
-
-    def include_file?(file)
-      !exclude_file?(file)
-    end
-
-    def exclude_file?(file)
-      with_cache(file) do
-        !FileSystem::CommonPath.included_in?(File.expand_path(file), Delfos.application_directories)
-      end
-    end
-
-    def reset!
-      @cache = nil
-    end
-
-    private
-
-    def with_cache(key)
-      cache.include?(key) ? cache[key] : cache[key] = yield
-    end
-
-    def cache
-      @cache ||= {}
-    end
-  end
-end