rails-dev-boost 0.1.1 → 0.2.0

data/lib/rails_development_boost/dependencies_patch/instrumentation_patch.rb

@@ -0,0 +1,171 @@
+module RailsDevelopmentBoost
+  module DependenciesPatch
+    module InstrumentationPatch
+      module Instrumenter
+        delegate :boost_log, :to => 'ActiveSupport::Dependencies'
+        
+        def self.included(mod)
+          mod.extend(ClassMethods)
+        end
+        
+        module ClassMethods
+          def included(klass)
+            (public_instance_methods(false) + private_instance_methods(false) + protected_instance_methods(false)).each do |method|
+              if m = method.to_s.match(/\A(.+)_with_(.+)\Z/)
+                meth_name, extension = m[1], m[2]
+                extension.sub!(/[?!=]\Z/) do |modifier|
+                  meth_name << modifier
+                  ''
+                end
+                klass.alias_method_chain meth_name, extension
+              end
+            end
+
+            super
+          end
+        end
+      end
+      
+      module LoadedFile
+        include Instrumenter
+        
+        def boost_inspect
+          "\#<LoadedFile #{relative_path} #{inspect_constants(@constants)}>"
+        end
+        
+        def add_constants_with_instrumentation(new_constants)
+          boost_log('ADD_CONSTANTS', "#{boost_inspect} <- #{inspect_constants(new_constants)}")
+          add_constants_without_instrumentation(new_constants)
+        end
+        
+        def unload_dependent_file_with_instrumentation(dependent_file)
+          boost_log('UNLOAD_DEPENDENT', "#{boost_inspect}: #{dependent_file.boost_inspect}")
+          unload_dependent_file_without_instrumentation(dependent_file)
+        end
+
+      private
+        RAILS_ROOT = /\A#{Rails.root.to_s}/
+        
+        def inspect_constants(constants_arr)
+          "[#{constants_arr.join(', ')}]"
+        end
+
+        def relative_path
+          @path.sub(RAILS_ROOT, '')
+        end
+        
+        def self.included(klass)
+          klass.singleton_class.send :include, ClassMethods
+          super
+        end
+        
+        module ClassMethods
+          include Instrumenter
+          
+          def unload_modified_with_instrumentation!
+            boost_log('--- START ---')
+            unload_modified_without_instrumentation!.tap do
+              boost_log('--- END ---')
+            end
+          end
+          
+          def unload_containing_file_with_instrumentation(const_name, file)
+            boost_log('UNLOAD_CONTAINING_FILE', "#{const_name} -> #{file.boost_inspect}")
+            unload_containing_file_without_instrumentation(const_name, file)
+          end
+        end
+      end
+      
+      module Files
+        include Instrumenter
+        
+        def unload_modified_file_with_instrumentation(file)
+          boost_log('CHANGED', "#{file.boost_inspect}")
+          unload_modified_file_without_instrumentation(file)
+        end
+        
+        def unload_decorator_file_with_instrumentation(file)
+          boost_log('UNLOAD_DECORATOR_FILE', "#{file.boost_inspect}")
+          unload_decorator_file_without_instrumentation(file)
+        end
+      end
+      
+      def self.apply!
+        unless applied?
+          ActiveSupport::Dependencies.extend self
+          RailsDevelopmentBoost::LoadedFile.send :include, LoadedFile
+          RailsDevelopmentBoost::LoadedFile::Files.send :include, Files
+        end
+      end
+      
+      def self.applied?
+        ActiveSupport::Dependencies.singleton_class.include?(self)
+      end
+      
+      def load_file_without_constant_tracking(path, *args)
+        other_args = ", #{args.map(&:inspect).join(', ')}" if args.any?
+        boost_log('LOAD', "load_file(#{path.inspect}#{other_args})")
+        super
+      end
+      
+      def remove_constant_without_handling_of_connections(const_name)
+        boost_log('REMOVE_CONST', const_name)
+        super
+      end
+      
+      def load_file_from_explicit_load(expanded_path)
+        boost_log('EXPLICIT_LOAD_REQUEST', expanded_path)
+        super
+      end
+      
+      def boost_log(action, msg = nil)
+        action, msg = msg, action unless msg
+        raw_boost_log("#{ "[#{action}] " if action}#{msg}")
+      end
+      
+      private
+      def unprotected_remove_constant(const_name)
+        boost_log('REMOVING', const_name)
+        @removal_nesting = (@removal_nesting || 0) + 1
+        super
+      ensure
+        @removal_nesting -= 1
+      end
+      
+      def error_loading_file(file_path, e)
+        description = RailsDevelopmentBoost::LoadedFile.loaded?(file_path) ? RailsDevelopmentBoost::LoadedFile.for(file_path).boost_inspect : file_path
+        boost_log('ERROR_WHILE_LOADING', "#{description}: #{e.inspect}")
+        super
+      end
+      
+      def remove_explicit_dependency(const_name, depending_const)
+        boost_log('EXPLICIT_DEPENDENCY', "#{const_name} -> #{depending_const}")
+        super
+      end
+      
+      def remove_dependent_constant(original_module, dependent_module)
+        boost_log('DEPENDENT_MODULE', "#{original_module._mod_name} -> #{dependent_module._mod_name}")
+        super
+      end
+      
+      def remove_autoloaded_parent_module(initial_object, parent_object)
+        boost_log('REMOVE_PARENT', "#{initial_object._mod_name} -> #{parent_object._mod_name}")
+        super
+      end
+      
+      def remove_child_module_constant(parent_object, full_child_const_name)
+        boost_log('REMOVE_CHILD', "#{parent_object._mod_name} -> #{full_child_const_name}")
+        super
+      end
+      
+      def remove_nested_constant(parent_const, child_const)
+        boost_log('REMOVE_NESTED', "#{parent_const} :: #{child_const.sub(/\A#{parent_const}::/, '')}")
+        super
+      end
+      
+      def raw_boost_log(msg)
+        Rails.logger.info("[DEV-BOOST] #{"\t" * (@removal_nesting || 0)}#{msg}")
+      end
+    end
+  end
+end

data/lib/rails_development_boost/descendants_tracker_patch.rb

@@ -1,3 +1,5 @@
+require 'active_support/descendants_tracker'
+
 module RailsDevelopmentBoost
   module DescendantsTrackerPatch
     def self.apply!

data/lib/rails_development_boost/loadable_patch.rb

@@ -0,0 +1,18 @@
+module RailsDevelopmentBoost
+  module LoadablePatch
+    def self.apply!
+      Object.send :include, LoadablePatch
+    end
+    
+    def load(file, wrap = false)
+      expanded_path = File.expand_path(file)
+      # force the manual #load calls for autoloadable files to go through the AS::Dep stack
+      if ActiveSupport::Dependencies.in_autoload_path?(expanded_path)
+        expanded_path << '.rb' unless expanded_path =~ /\.(rb|rake)\Z/
+        ActiveSupport::Dependencies.load_file_from_explicit_load(expanded_path)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/rails_development_boost/loaded_file.rb

@@ -1,13 +1,98 @@
 module RailsDevelopmentBoost
   class LoadedFile
-    @constants_to_files = {}
+    class Files < Hash
+      def initialize(*args)
+        super {|hash, file_path| hash[file_path] = LoadedFile.new(file_path)}
+      end
+      
+      def unload_modified!
+        each_file_unload_if_changed {|file| file.changed?}
+      end
+      
+      def each_file_unload_if_changed
+        unloaded_something = false
+        values.each do |file|
+          if yield(file)
+            unload_modified_file(file)
+            unloaded_something = true
+          end
+        end
+        if unloaded_something
+          values.each do |file|
+            unload_decorator_file(file) if file.decorator_like?
+          end
+        end
+        unloaded_something
+      end
+      
+      def unload_modified_file(file)
+        file.unload!
+      end
+      
+      def unload_decorator_file(file)
+        file.unload!
+      end
+      
+      def constants
+        values.map(&:constants).flatten
+      end
+      
+      def stored?(file)
+        key?(file.path) && self[file.path] == file
+      end
+      
+      alias_method :loaded?, :key?
+    end
     
-    class << self
-      attr_reader :constants_to_files
+    class ConstantsToFiles < Hash
+      def associate(const_name, file)
+        (self[const_name] ||= []) << file
+      end
+      
+      def deassociate(const_name, file)
+        if files = self[const_name]
+          files.delete(file)
+          delete(const_name) if files.empty?
+        end
+      end
+      
+      def each_file_with_const(const_name, &block)
+        if files = self[const_name]
+          files.dup.each(&block)
+        end
+      end
+    end
+    
+    class Interdependencies < Hash
+      def associate(file_a, file_b)
+        (self[file_a] ||= Set.new) << file_b
+        (self[file_b] ||= Set.new) << file_a
+      end
+      
+      def each_dependent_on(file)
+        if deps = delete(file)
+          deps.each do |dep|
+            deassociate(dep, file)
+            yield dep
+          end
+        end
+      end
+      
+      private
+      def deassociate(file_a, file_b)
+        if deps = self[file_a]
+          deps.delete(file_b)
+          delete(file_a) if deps.empty?
+        end
+      end
     end
     
+    LOADED             = Files.new
+    CONSTANTS_TO_FILES = ConstantsToFiles.new
+    INTERDEPENDENCIES  = Interdependencies.new
+    NOW_UNLOADING      = Set.new
+    
     attr_accessor :path, :constants
-    delegate :constants_to_files, :to => 'self.class'
   
     def initialize(path, constants=[])
       @path       = path
@@ -21,53 +106,145 @@ module RailsDevelopmentBoost
     end
     
     def add_constants(new_constants)
-      new_constants.each do |new_constant|
-        (constants_to_files[new_constant] ||= []) << self
-      end
+      new_constants.each {|new_constant| CONSTANTS_TO_FILES.associate(new_constant, self)}
       @constants |= new_constants
-      retrieve_associated_files.each {|file| file.add_constants(@constants)} if @associated_files
     end
     
-    def delete_constant(const_name)
-      delete_from_constants_to_files(const_name)
-      @constants.delete(const_name)
+    # "decorator" files are popular with certain Rails frameworks (spree/refinerycms etc.) they don't define their own constants, instead
+    # they are usually used for adding methods to other classes via Model.class_eval { def meth; end }
+    def decorator_like?
+      @constants.empty? && !INTERDEPENDENCIES[self]
     end
     
-    def associate_with(other_loaded_file)
-      (@associated_files ||= []) << other_loaded_file
+    def unload!
+      guard_double_unloading do
+        INTERDEPENDENCIES.each_dependent_on(self) {|dependent_file| unload_dependent_file(dependent_file)}
+        @constants.dup.each {|const| ActiveSupport::Dependencies.remove_constant(const)}
+        clean_up_if_necessary
+      end
     end
     
-    def retrieve_associated_files
-      associated_files, @associated_files = @associated_files, nil
-      associated_files
+    def associate_to_greppable_constants # brute-force approach
+      # we don't know anything about the constants contained in the files up the currently_loading stack
+      ActiveSupport::Dependencies.currently_loading.each {|path| self.class.relate_files(path, self)}
+      add_constants(greppable_constants)
     end
     
-    def require_path
-      @path.sub(/\.rb\Z/, '')
+    # It is important to catch all the intermediate constants as they might be "nested" constants, that are generally not tracked by AS::Dependencies.
+    # Pathological example is as follows:
+    #
+    # File `a.rb` contains `class A; X = :x; end`. AS::Dependencies only associates the 'A' const to the `a.rb` file (ignoring the nested 'A::X'), while
+    # a decorator file `b_decorator.rb` containing `B.class_eval {A::X}` would grep and find the `A::X` const, check that indeed it is in autoloaded
+    # namespace and associate it to itself. When `b_decorator.rb` is then being unloaded it simply does `remove_constant('A::X')` while failing to trigger
+    # the unloading of `a.rb`.
+    def greppable_constants
+      constants = []
+      read_greppable_constants.each do |const_name|
+        intermediates = nil
+        begin
+          if self.class.loaded_constant?(const_name)
+            constants << const_name
+            constants.concat(intermediates) if intermediates
+            break
+          end
+          (intermediates ||= []) << const_name.dup
+        end while const_name.sub!(/::[^:]+\Z/, '')
+      end
+      constants.uniq
+    end
+    
+    def read_greppable_constants
+      File.read(@path).scan(/[A-Z][_A-Za-z0-9]*(?:::[A-Z][_A-Za-z0-9]*)*/).uniq
     end
     
-    def self.each_file_with_const(const_name, &block)
-      if files = constants_to_files[const_name]
-        files.dup.each(&block)
+    # consistent hashing
+    def hash
+      @path.hash
+    end
+    
+    def eql?(other)
+      @path.eql?(other)
+    end
+    
+    def unload_dependent_file(dependent_file)
+      dependent_file.unload!
+    end
+    
+    def guard_double_unloading
+      if NOW_UNLOADING.add?(self)
+        begin
+          yield
+        ensure
+          NOW_UNLOADING.delete(self)
+        end
       end
     end
     
-    def stale!
-      @mtime = 0
-      if associated_files = retrieve_associated_files
-        associated_files.each(&:stale!)
+    def delete_constant(const_name)
+      CONSTANTS_TO_FILES.deassociate(const_name, self)
+      @constants.delete(const_name)
+      clean_up_if_necessary
+    end
+    
+    def clean_up_if_necessary
+      if @constants.empty? && LOADED.stored?(self)
+        LOADED.delete(@path)
+        ActiveSupport::Dependencies.loaded.delete(require_path)
       end
     end
     
-  private
+    def associate_with(other_loaded_file)
+      INTERDEPENDENCIES.associate(self, other_loaded_file)
+    end
+    
+    def require_path
+      File.expand_path(@path.sub(/\.rb\Z/, '')) # be sure to do the same thing as Dependencies#require_or_load and use the expanded path
+    end
     
-    def delete_from_constants_to_files(const_name)
-      if files = constants_to_files[const_name]
-        files.delete(self)
-        constants_to_files.delete(const_name) if files.empty?
+    def stale!
+      @mtime = 0
+      INTERDEPENDENCIES.each_dependent_on(self, &:stale!)
+    end
+    
+    class << self
+      def unload_modified!
+        LOADED.unload_modified!
+      end
+      
+      def for(file_path)
+        LOADED[file_path]
+      end
+      
+      def loaded?(file_path)
+        LOADED.loaded?(file_path)
+      end
+      
+      def loaded_constants
+        LOADED.constants
+      end
+      
+      def loaded_constant?(const_name)
+        CONSTANTS_TO_FILES[const_name]
+      end
+      
+      def unload_files_with_const!(const_name)
+        CONSTANTS_TO_FILES.each_file_with_const(const_name) {|file| unload_containing_file(const_name, file)}
+      end
+      
+      def unload_containing_file(const_name, file)
+        file.unload!
+      end
+      
+      def const_unloaded(const_name)
+        CONSTANTS_TO_FILES.each_file_with_const(const_name) {|file| file.delete_constant(const_name)}
+      end
+      
+      def relate_files(base_file, related_file)
+        LOADED[base_file].associate_with(LOADED[related_file])
       end
     end
     
+  private
     def current_mtime
       # trying to be more efficient: there is no need for a full-fledged Time instance, just grab the timestamp
       File.mtime(@path).to_i rescue nil