delfos 0.0.1.pre.beta

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 504300a4ec558fbb0620996b4f1452dfd7f7424c
+  data.tar.gz: cf3adbd6030184d208a52d7586a816cc1d365668
+SHA512:
+  metadata.gz: be9e77733e7d6af4ac90e62a5bbfac8ae056dbd2b6839e4a16e0c82960e64dd83d93ef8b72787b1b411f992687a67327790a3e9a9367c0dfeabe503c66d931a4
+  data.tar.gz: 6358c9cf62d2a2db3cf12b1fd025edc65e71c3982ad3d1d56a1d8adfb871777111da61f1dcb62ad17a213069666ce59594c24a4a75fc951991610998bf2d8b9b

data/lib/delfos.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+require "delfos/version"
+require "delfos/method_logging"
+require "delfos/neo4j/query_execution"
+require "delfos/neo4j/informer"
+
+module Delfos
+  class << self
+    def check_setup!
+      raise "Delfos.setup! has not been called" unless neo4j_config && logger
+    end
+
+    def wipe_db!
+      Delfos.setup!(application_directories: [])
+      Delfos::Neo4j::QueryExecution.execute <<-QUERY
+        MATCH (m)-[rel]->(n)
+        DELETE m,rel,n
+      QUERY
+    end
+
+    def reset!
+      @application_directories = []
+      @neo4j_config = nil
+      @logger = nil
+      remove_patching!
+    end
+
+    def remove_patching!
+      load "delfos/remove_patching.rb"
+      begin
+        Delfos::Patching.instance_eval { @added_methods = nil }
+      rescue
+        nil
+      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)
+
+      @application_directories = application_directories.map{|f| Pathname.new(File.expand_path(f.to_s))}
+      @logger = logger
+
+      @neo4j_config = [connection_type, host, auth]
+
+      perform_patching!
+    end
+
+    def perform_patching!
+      load "delfos/perform_patching.rb"
+    end
+
+    attr_reader :application_directories, :neo4j_config
+  end
+end

data/lib/delfos/common_path.rb

@@ -0,0 +1,60 @@
+# 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)
+
+        if valid_length?(common_path, path_a, path_b)
+          Pathname.new(common_path)
+        end
+      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/distance/calculation.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+require_relative "relation"
+
+module Delfos
+  module Distance
+    class Calculation
+      attr_reader :path_a, :path_b
+
+      def initialize(path_a, path_b)
+        @path_a = path_a
+        @path_b = path_b
+      end
+
+      attr_reader :traversal_a, :traversal_b
+
+      def traversals
+        result = []
+        path = traversal_path
+
+        path.each_cons(2) do |start, finish|
+          klass = klass_for(start, finish)
+          result.push(klass.new(start, finish))
+        end
+
+        result
+      end
+
+      def klass_for(a, b)
+        return ChildFile if b + ".." == a
+        Relation
+      end
+
+      def sum_traversals
+        traversals.inject(0) { |a, e| a + e.distance }
+      end
+
+      def sum_possible_traversals
+        traversals.inject(0) { |a, e| a + e.possible_length }
+      end
+
+      def sibling_directories(path)
+        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
+
+      class TraversalPathCalculator
+        attr_reader :path_a, :path_b
+
+        def initialize(path_a, path_b)
+          @path_a = path_a
+          @path_b = path_b
+        end
+
+        def path
+          return [path_a, path_b] if same_directory?
+
+          current_path = path_a
+
+          traversal.descend do |p|
+            current_path = full(path_a, p)
+            result.process(current_path)
+          end
+
+          result
+        end
+
+        def same_directory?
+          path_a.dirname == path_b.dirname
+        end
+
+        def result
+          @result ||= Result.new([path_a])
+        end
+
+        def traversal
+          path_b.relative_path_from(path_a)
+        end
+
+        def full(start, traversal)
+          start.realpath + Pathname.new(traversal)
+        end
+
+        class Result < Array
+          def initialize(*args)
+            super
+            @in_parent = false
+          end
+
+          def process(i)
+            if @in_parent
+              @in_parent = false
+              remove_parent(i)
+            else
+              add_item(i)
+            end
+          end
+
+          private
+
+          def add_item(i)
+            @in_parent = ((last && last + "..") == i)
+            push i
+          end
+
+          def remove_parent(i)
+            return unless same_dir?(i)
+
+            pop
+            push(i)
+          end
+
+          def same_dir?(i)
+            self[-2] && self[-2].dirname == i.dirname
+          end
+        end
+      end
+    end
+  end
+end

data/lib/delfos/distance/relation.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+module Delfos
+  module Distance
+    class Relation
+      attr_reader :start_path, :finish_path
+
+      def initialize(start_path, finish_path)
+        @start_path = start_path
+        @finish_path = finish_path
+      end
+
+      def other_files
+        RelatedPaths.new(start_path).files
+      end
+
+      def other_directories
+        RelatedPaths.new(start_path).directories
+      end
+
+      def distance
+        return traversed_files.length       if both_files?
+        return traversed_directories.length if both_directories?
+
+        traversed_files.length + traversed_directories.length
+      end
+
+      def possible_length
+        other_files.length + other_directories.length
+      end
+
+      def traversed_files
+        start_at_end = (start_path.file? && finish_path.directory?)
+
+        subset_to_traverse(collection: other_files,
+                           start: start_path,
+                           finish: finish_path,
+                           start_at_end: start_at_end)
+      end
+
+      def traversed_directories
+        start_at_end = (start_path.file? && finish_path.directory?) || (start_path.directory? && finish_path.file?)
+
+        subset_to_traverse(collection: other_directories,
+                           start: start_path,
+                           finish: finish_path,
+                           start_at_end: start_at_end)
+      end
+
+      def subset_to_traverse(collection:, start:, finish:, start_at_end: true)
+        start_index, finish_index = indexes_from(collection, start, finish, start_at_end)
+
+        Array collection[start_index..finish_index]
+      end
+
+      private
+
+      def both_files?
+        start_path.file? && finish_path.file?
+      end
+
+      def both_directories?
+        start_path.directory? && finish_path.directory?
+      end
+
+      def indexes_from(collection, start, finish, start_at_end)
+        start_index  = index_from(collection, start,  start_at_end: start_at_end)
+        finish_index = index_from(collection, finish, start_at_end: start_at_end, reverse: true)
+
+        if start_index.zero? && finish_index.zero?
+          finish_index = collection.length - 1
+        end
+
+        [start_index, finish_index].sort
+      end
+
+      def index_from(collection, value, reverse: false, start_at_end: false)
+        index = collection.index value
+
+        if index.nil?
+          index = start_at_end && !reverse ? collection.length - 1 : 0
+        end
+
+        index
+      end
+
+      class RelatedPaths
+        attr_reader :path
+
+        def initialize(path)
+          @path = path
+        end
+
+        def files
+          all.select(&:file?)
+        end
+
+        def directories
+          all.select(&:directory?)
+        end
+
+        private
+
+        def all
+          Dir.glob(path.dirname + "*").map { |f| Pathname.new(f) }
+        end
+      end
+    end
+
+    class ChildFile < Relation
+      def other_files
+        RelatedPaths.new(start_path + "*").files
+      end
+
+      def other_directories
+        RelatedPaths.new(start_path + "*").directories
+      end
+    end
+  end
+end

data/lib/delfos/execution_chain.rb

@@ -0,0 +1,74 @@
+require_relative "neo4j/execution_persistence"
+
+module Delfos
+  class ExecutionChain
+    METHOD_CHAIN_MUTEX = Mutex.new
+
+    def self.reset!
+      METHOD_CHAIN_MUTEX.synchronize do
+        Thread.current[:_delfos__execution_chain__method_chain] = nil
+      end
+    end
+
+    def self.method_chain
+      METHOD_CHAIN_MUTEX.synchronize do
+        Thread.current[:_delfos__execution_chain__method_chain] ||= new
+      end
+    end
+
+    def self.push(method_object)
+      method_chain.push(method_object)
+    end
+
+    def self.pop
+      method_chain.pop
+    end
+
+    def push(method_object)
+      self.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
+
+      self.stack_depth -= 1
+
+      save_and_reset!  if self.stack_depth == 0
+    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
+
+    private
+
+    class PoppingEmptyStackError < StandardError
+    end
+
+    def popping_empty_stack!
+      raise PoppingEmptyStackError
+    end
+
+    def save_and_reset!
+      Neo4j::ExecutionPersistence.save!(self)  if call_sites.length > 0
+      self.call_sites = []
+    end
+
+    attr_writer :stack_depth, :step_count, :execution_count, :call_sites
+  end
+end