delfos 0.0.2.pre.rc2 → 0.0.2.pre.rc3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d7fee8925fceb4563ffc7f5895a63c2d3e372c06
-  data.tar.gz: 444793d867d93a22502053420bec22c7c14cef79
+  metadata.gz: 2abc41e61012e7262afb07416943d0eac71811f3
+  data.tar.gz: 9015780c3ed0a18153c3eceb083914ac2bf23ee5
 SHA512:
-  metadata.gz: 9424c15ce219468cadb02be9e35ce932bbba9cb103416dbb0eda9115b61943955e2eae1c5464296a255aa83ad7a8de9b985240c298d4d953009829696ab577b4
-  data.tar.gz: ceb9b9bc4d27a011d46785b92a3d1c62294f0abce4f95e5d69fa1d8aadeee9178bf8abd971c3e8b71c0111005046f7758d92840d0dcae48db80481ea54eeae3f
+  metadata.gz: 521ee2c4de9433e74a6989caf6991c76fb0dc238b842a5444fe0dcca1a049c98d96670c755f63ed4bf71e1359c3a69257f0aac18106aad47cd8a46f4e7143204
+  data.tar.gz: d5b09f2278d2312707d11743a8156cb1de88fb44fcb76f6599a226e84f09b5c1d764d862e52af19b26ea9295aaacdf423ac713c269caca3b01670b64b6c3137d

data/exe/delfos_import

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "fileutils"
+
+# Credit to http://ruby-journal.com/how-to-import-millions-records-via-activerecord-within-minutes-not-hours/
+# for the basis for this script
+
+NUMBER_OF_SPLIT_LINES = 10_000
+SPLIT_FILE_PREFIX     = "delfos_queries_"
+TEMP_DIRECTORY        = "./tmp/delfos"
+BIG_FILE_PATH         = ARGV[0] || "./tmp/delfos/query_parameters.json"
+
+BIG_FILENAME = File.basename BIG_FILE_PATH
+FileUtils.rm_rf TEMP_DIRECTORY
+FileUtils.mkdir_p TEMP_DIRECTORY
+FileUtils.cp BIG_FILE_PATH, "#{TEMP_DIRECTORY}/#{BIG_FILENAME}"
+
+FileUtils.cd TEMP_DIRECTORY
+
+def split_file
+  puts "Split '#{BIG_FILENAME}' file into small chunks with size #{NUMBER_OF_SPLIT_LINES} lines"
+  system "split -l #{NUMBER_OF_SPLIT_LINES} #{BIG_FILENAME} #{SPLIT_FILE_PREFIX}"
+end
+
+def process_split_files
+  split_files = Dir.glob("#{SPLIT_FILE_PREFIX}*")
+
+  split_files.each do |f|
+    command = "FILE=#{f} delfos_import_offline_queries"
+    system command
+  end
+end
+
+split_file
+process_split_files
+
+system "delfos_update_distance"

data/exe/delfos_import_offline_queries

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+
+require "delfos"
+
+Delfos.configure
+Delfos.import_offline_queries(ENV["FILE"])

data/exe/delfos_update_distance

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+
+require "delfos"
+
+Delfos.configure { |c| c.include = "." }
+Delfos.start!
+Delfos.update_distance!
+Delfos.finish!

data/lib/delfos.rb

@@ -1,103 +1,59 @@
 # frozen_string_literal: true
 
-require "delfos/setup"
+require "forwardable"
+
+require "delfos/config"
+require "delfos/method_trace"
+require "delfos/neo4j"
 
 module Delfos
   class << self
-    attr_accessor :application_directories,
+    extend Forwardable
+
+    def_delegators :config,
+      :batch_size,
+      :call_site_logger,
+      :logger,
+      :max_query_size,
       :offline_query_saving,
       :offline_query_filename
 
-    attr_writer :logger, :neo4j, :batch_size, :max_query_size
-
-    # rubocop:disable Metrics/ParameterLists
-    def setup!(
-      logger: nil,
-      call_site_logger: nil,
-      application_directories: nil,
-      batch_size: nil,
-      max_query_size: nil,
-      offline_query_saving: nil
-    )
-      # rubocop:enable Metrics/ParameterLists
-      self.logger         = logger
-      self.batch_size     = batch_size
-      self.max_query_size = max_query_size
+    attr_reader :config
 
-      Setup.perform!(
-        call_site_logger: call_site_logger,
-        application_directories: application_directories,
-        offline_query_saving: offline_query_saving,
-      )
-    end
-
-    def import_offline_queries(filename)
-      require "delfos/neo4j/offline/importer"
-      Neo4j::Offline::Importer.new(filename).perform
+    def start!
+      ::Delfos::MethodTrace.enable!
     end
 
-    def batch_size
-      @batch_size ||= 100
-    end
+    def finish!
+      ::Delfos::MethodTrace.disable!
 
-    def max_query_size
-      @max_query_size ||= 10_000
+      config.call_site_logger.finish!
     end
 
-    def include_file?(file)
-      require "delfos/file_system"
-      FileSystem.include_file?(file)
+    def reset!
+      Delfos.config&.call_site_logger&.reset!
     end
 
-    attr_writer :call_site_logger
-
-    def call_site_logger
-      @call_site_logger ||= Delfos::Setup.default_call_site_logger
-    end
+    def configure
+      new_config
 
-    def logger
-      @logger ||= default_logger
+      yield config if block_given?
     end
 
-    def neo4j
-      setup_neo4j!
-    end
-
-    def setup_neo4j!
-      require "delfos/neo4j"
-      @neo4j ||= Neo4j.config
+    def import_offline_queries(filename)
+      Neo4j.import_offline_queries(filename)
     end
 
-    def finish!
-      if offline_query_saving
-        Delfos.call_site_logger.finish!
-      else
-        flush!
-        update_distance!
-        disable!
-      end
+    def include_file?(file)
+      config&.include?(file)
     end
 
     def update_distance!
-      require "delfos/neo4j"
       Neo4j.update_distance!
     end
 
-    def flush!
-      require "delfos/neo4j"
-      Neo4j.flush!
-    end
-
-    def disable!
-      Setup.disable!
-    end
-
-    def default_logger
-      require "logger"
-
-      Logger.new(STDOUT).tap do |l|
-        l.level = Logger::ERROR
-      end
+    def new_config
+      @config ||= Delfos::Config.new
     end
   end
 end

data/lib/delfos/config.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "forwardable"
+require_relative "config/inclusion"
+
+module Delfos
+  class Config
+    attr_reader :offline_query_saving, :offline_query_filename
+
+    attr_accessor :batch_size,
+      :call_site_logger,
+      :logger,
+      :max_query_size
+
+    extend Forwardable
+
+    def_delegators :inclusion,
+      :included_directories, :included_files, :include=, :include, :include?,
+      :excluded_directories, :excluded_files, :exclude=, :exclude, :exclude?
+
+    def initialize
+      @batch_size              = default_batch_size
+      @logger                  = default_logger
+      @max_query_size          = default_max_query_size
+      @offline_query_saving    = default_offline_query_saving
+      @offline_query_filename  = nil
+      @call_site_logger        = default_call_site_logger
+    end
+
+    def offline_query_saving=(bool)
+      @offline_query_saving = bool
+      @call_site_logger = default_call_site_logger
+    end
+
+    def offline_query_filename=(path)
+      @offline_query_filename = path || default_offline_query_filename
+    end
+
+    def neo4j
+      setup_neo4j!
+    end
+
+    private
+
+    def inclusion
+      @inclusion ||= Inclusion.new
+    end
+
+    def default_batch_size
+      100
+    end
+
+    def default_call_site_logger
+      if @offline_query_saving
+        require "delfos/neo4j/offline/call_site_logger"
+        Delfos:: Neo4j::Offline::CallSiteLogger.new
+      else
+        setup_neo4j!
+        require "delfos/neo4j/live/call_site_logger"
+        Delfos:: Neo4j::Live::CallSiteLogger.new
+      end
+    end
+
+    def setup_neo4j!
+      require "delfos/neo4j"
+      @neo4j ||= Neo4j.config
+    end
+
+    def default_logger
+      require "logger"
+      Logger.new(STDOUT).tap do |l|
+        l.level = Logger::ERROR
+      end
+    end
+
+    def default_max_query_size
+      10_000
+    end
+
+    def default_offline_query_saving
+      false
+    end
+
+    def default_offline_query_filename
+      FileUtils.mkdir_p "./tmp/delfos" if @offline_query_saving
+
+      "./tmp/delfos/query_parameters.json"
+    end
+  end
+end

data/lib/delfos/config/inclusion.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "delfos/file_system/app_directories"
+require "delfos/file_system/app_files"
+
+module Delfos
+  class Config
+    class Inclusion
+      attr_reader :included_directories, :included_files,
+        :excluded_directories, :excluded_files
+
+      def initialize
+        require "pathname"
+        @included_directories = default_included_directories
+        @included_files = []
+
+        @excluded_directories = []
+        @excluded_files = []
+      end
+
+      def exclude(paths)
+        append_all_to(paths, "excluded")
+      end
+
+      def include(paths)
+        append_all_to(paths, "included")
+      end
+
+      def include=(paths)
+        replace_all_with(paths, "included")
+      end
+
+      def exclude=(paths)
+        replace_all_with(paths, "excluded")
+      end
+
+      def include?(file)
+        app_directories.include?(file) && app_files.include?(file)
+      end
+
+      private
+
+      def append_all_to(paths, type)
+        files, directories = files_and_directories_from(paths)
+
+        append_to(files, "@#{type}_files")
+        append_to(directories, "@#{type}_directories")
+      end
+
+      def append_to(paths, ivar_name)
+        ivar = instance_variable_get(ivar_name)
+        ivar += paths
+        ivar.uniq!
+        instance_variable_set(ivar_name, ivar)
+      end
+
+      def replace_all_with(paths, type)
+        files, directories = files_and_directories_from(paths)
+
+        replace_with(files, "@#{type}_files")
+        replace_with(directories, "@#{type}_directories")
+      end
+
+      def replace_with(paths, ivar_name)
+        instance_variable_set(ivar_name, paths)
+        instance_variable_get(ivar_name).uniq!
+      end
+
+      def files_and_directories_from(paths)
+        expand_paths(paths).partition(&:file?)
+      end
+
+      def app_directories
+        @app_directories ||= FileSystem.app_directories(@included_directories, @excluded_directories)
+      end
+
+      def app_files
+        @app_files ||= FileSystem.app_files(@included_files, @excluded_files)
+      end
+
+      def default_included_directories
+        %w[app lib].map { |f| Pathname.new(f.to_s).expand_path }
+      end
+
+      def expand_paths(files)
+        Array(files).compact.map { |f| Pathname.new(f.to_s).expand_path }
+      end
+    end
+  end
+end

data/lib/delfos/file_system.rb

@@ -2,6 +2,7 @@
 
 require_relative "file_system/distance_calculation"
 require_relative "file_system/app_directories"
+require_relative "file_system/app_files"
 
 module Delfos
   module FileSystem
@@ -9,8 +10,12 @@ module Delfos
       DistanceCalculation.new(start_file, finish_file)
     end
 
-    def self.include_file?(file)
-      FileSystem::AppDirectories.include_file?(file)
+    def self.app_directories(included, excluded)
+      AppDirectories.new(included, excluded)
+    end
+
+    def self.app_files(included, excluded)
+      AppFiles.new(included, excluded)
     end
   end
 end

data/lib/delfos/file_system/app_directories.rb

@@ -1,41 +1,39 @@
 # frozen_string_literal: true
 
 require_relative "common_path"
+require_relative "file_cache"
 
 module Delfos
   module FileSystem
-    module AppDirectories
-      extend self
+    class AppDirectories
+      include FileCache
 
-      def exclude_file?(file)
-        !include_file?(file)
+      def initialize(included, excluded)
+        @included = included
+        @excluded = excluded
       end
 
-      def include_file?(file)
-        return false if file.nil?
-        with_cache(file) { should_include?(file) }
+      def exclude?(file)
+        !include?(file)
       end
 
-      def reset!
-        @cache = nil
+      def include?(file)
+        return false if file.nil?
+        with_cache(file) { should_include?(file) }
       end
 
       private
 
       def should_include?(file)
-        CommonPath.included_in?(expand_path(file), Delfos.application_directories)
-      end
-
-      def expand_path(f)
-        Pathname.new(f).expand_path
+        !matches(file, @excluded) && matches(file, @included)
       end
 
-      def with_cache(key)
-        cache.include?(key) ? cache[key] : cache[key] = yield
+      def matches(f, directories)
+        CommonPath.included_in?(expand_path(f), directories)
       end
 
-      def cache
-        @cache ||= {}
+      def expand_path(f)
+        Pathname.new(f).expand_path
       end
     end
   end