delfos 0.0.1.pre.rc1 → 0.0.1

data/lib/delfos/method_logging/added_methods.rb

@@ -1,67 +0,0 @@
-# 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/neo4j/distance_update.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-require_relative "../distance/calculation"
-require_relative "query_execution"
-require "json"
-
-module Delfos
-  module Neo4j
-    class DistanceUpdate
-      def perform
-        update Delfos::Neo4j::QueryExecution.execute(query)
-      end
-
-      def determine_full_path(f)
-        f = Pathname.new f
-        return f.realpath if File.exist?(f)
-
-        Delfos.application_directories.map do |d|
-          path = Pathname.new(d + f.to_s.gsub(%r{[^/]*/}, ""))
-          path if path.exist?
-        end.compact.first
-      end
-
-      private
-
-      def query
-        <<-QUERY
-          MATCH
-            (klass:Class)        -  [:OWNS]     -> (method:Method),
-            (method)             -  [:CONTAINS] -> (call_site:CallSite),
-            (call_site)          -  [:CALLS]    -> (called:Method),
-            (called_klass:Class) -  [:OWNS]     -> (called:Method)
-
-          RETURN
-            head(labels(klass)),
-            call_site, id(call_site),
-            method,
-            called, id(called),
-            head(labels(called_klass))
-        QUERY
-      end
-
-      def update(results)
-        Array(results).compact.map do |_klass, call_site, call_site_id, _meth, called, called_id, _called_klass|
-          start  = determine_full_path call_site["file"]
-          finish = determine_full_path called["file"]
-
-          calc = Delfos::Distance::Calculation.new(start, finish)
-
-          perform_query(calc, call_site_id, called_id)
-        end
-      end
-
-      def perform_query(calc, call_site_id, called_id)
-        Delfos::Neo4j::QueryExecution.execute <<-QUERY, {call_site_id: call_site_id, called_id: called_id, sum_traversals: calc.sum_traversals, sum_possible_traversals: calc.sum_possible_traversals}
-          START call_site = node({call_site_id}),
-                called    = node({called_id})
-
-           MERGE (call_site) - #{rel} -> (called)
-        QUERY
-      end
-
-      def rel
-        <<-REL
-           [:EFFERENT_COUPLING{
-             distance:          {sum_traversals},
-             possible_distance: {sum_possible_traversals}
-             }
-           ]
-        REL
-      end
-    end
-  end
-end

data/lib/delfos/neo4j/query_execution.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-require "delfos"
-require "json"
-require "net/http"
-require "uri"
-
-module Delfos
-  module Neo4j
-    module QueryExecution
-      class ExecutionError  < IOError
-        def initialize(response, query, params)
-          message = response.inspect
-
-          super [message, query, params.to_json].join("\n\n    ")
-        end
-      end
-
-      class << self
-        def execute(query, params={})
-          return unless query.length.positive?
-
-          parse_response(*response_for(query, params))
-        end
-
-        private
-
-
-        def parse_response(result, query, params)
-          result = JSON.parse result.body
-
-          if result["errors"].length.positive?
-            raise ExecutionError.new(result["errors"], query, params)
-          end
-
-          strip_out_meta_data(result)
-        end
-
-        def strip_out_meta_data(result)
-          results = result["results"]
-
-          if results
-            result = results.first
-            if result
-              data = result["data"]
-              data &.map { |r| r["row"] }
-            end
-          end
-        end
-
-        def response_for(query, params)
-          request = request_for(query, params)
-          http = Net::HTTP.new(uri.host, uri.port)
-
-          response = http.request(request)
-          [response, query, params]
-        end
-
-        def request_for(query, params)
-          build_request do
-            "{\"statements\": [{\"statement\": #{query.inspect} , \"parameters\": #{params.to_json}}]}"
-          end
-        end
-
-        def build_request
-          Net::HTTP::Post.new(uri.request_uri).tap do |request|
-            request.basic_auth(Delfos.neo4j.username, Delfos.neo4j.password)
-            request.content_type = "application/json"
-
-            request.body = yield
-          end
-        end
-
-        def uri
-          @uri ||= URI.parse "#{Delfos.neo4j.url}/db/data/transaction/commit"
-        end
-      end
-    end
-  end
-end

data/lib/delfos/patching/unstubbing_spec_helper.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-
-# These `Unstubbing` modules because we are testing something that redefines
-# methods.
-
-# We don't want to call the logging defined in
-# `Delfos::Patching::MethodOverride#setup` multiple times. So we replace with
-# the original definition, or to as close as possible.
-
-# If there is a better way to do this please suggest
-
-module Delfos
-  module Patching
-    module Unstubbing
-      module ClassMethods
-        def add_instance_to_unstub!(object)
-          instances_to_unstub.push(object)
-        end
-
-        def unstub_all!
-          instances_to_unstub.each(&:unstub!)
-          @instances_to_unstub = []
-        end
-
-        private
-
-        def instances_to_unstub
-          @instances_to_unstub ||= []
-        end
-      end
-
-      module InstanceMethods
-        def initialize(*args)
-          super(*args)
-          self.class.add_instance_to_unstub!(self) unless bail?
-        end
-
-        # This method is the inverse of `Delfos::Patching::MethodOverride#setup`
-        def unstub!
-          method = Delfos::MethodLogging::AddedMethods.find(klass, key)
-          return unless method
-          file = File.expand_path(__FILE__)
-
-          cm = class_method
-          if cm
-            method.unbind.bind(klass)
-          else
-            klass.send(:define_method, name) do |*args, **kw_args, &block|
-              arguments = Delfos::Patching::MethodOverride::MethodArguments.new(args, kw_args, block, cm)
-              arguments.apply_to(method.bind(self))
-            end
-          end
-        end
-      end
-    end
-  end
-end