rails-dev-boost 0.1.1

data/.gitignore

@@ -0,0 +1 @@
+.DS_Store

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2008 Roman Le Négrate
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,105 @@
+# RailsDevelopmentBoost
+
+Make your Rails app 10 times faster in development mode (see FAQ below for more details).
+
+Alternative to Josh Goebel's [`rails_dev_mode_performance`](https://github.com/yyyc514/rails_dev_mode_performance) plugin.
+
+## Branches
+
+If you are using **Rails 3**: [`rails-dev-boost/master`](http://github.com/thedarkone/rails-dev-boost/tree/master) branch.
+
+If you are using **Rails 2.3**: [`rails-dev-boost/rails-2-3`](http://github.com/thedarkone/rails-dev-boost/tree/rails-2-3) branch.
+
+If you are using **Rails 2.2**: [`rails-dev-boost/rails-2-2`](http://github.com/thedarkone/rails-dev-boost/tree/rails-2-2) branch.
+
+If you are using **Rails 2.1** or **Rails 2.0** or **anything older**: you are out of luck.
+
+## Background
+
+Why create a similar plugin? Because I couldn't get Josh Goebel's to work in my projects. His attempts to keep templates cached in a way that fails with recent versions of Rails. Also, removing the faulty chunk of code revealed another issue: it stats source files that may not exist, without trying to find their real path beforehand. That would be fixable is the code wasn't such a mess (no offense).
+
+I needed better performance in development mode right away, so here is an alternative implementation.
+
+## Usage
+
+### Rails 3
+
+Usage through `Gemfile`:
+
+    group :development do
+      gem 'rails-dev-boost', :git => 'git://github.com/thedarkone/rails-dev-boost.git', :require => 'rails_development_boost'
+    end
+
+Installing as a plugin:
+
+    script/rails plugin install git://github.com/thedarkone/rails-dev-boost
+
+### Rails 2.3 and older
+
+    script/plugin install git://github.com/thedarkone/rails-dev-boost -r rails-2-3
+
+When the server is started in *development* mode, the special unloading mechanism takes over.
+
+It can also be used in combination with [RailsTestServing](https://github.com/Roman2K/rails-test-serving) for even faster test runs by forcefully enabling it in test mode. To do so, add the following in `config/environments/test.rb`:
+
+    def config.soft_reload() true end if RailsTestServing.active?
+
+## FAQ
+
+### Q: Since the plugin uses its special "unloading mechanism" won't everything break down?
+A: Very unlikely... of course there are some edge cases where you might see some breakage (mainly if you're deviating from the Rails 1 file = 1 class conventions or doing some weird `require`s). This is a 99% solution and the seconds you're wasting waiting for the Rails to spit out a page in the dev mode do add up in the long run.
+
+### Q: How big of a boost is it going to give me?
+A: It depends on the size of your app (the bigger it is the bigger your boost is going to be). The speed is then approximately equal to that of production env. plus the time it takes to stat all your app's `*.rb` files (which is surprisingly fast as it is cached by OS). Empty 1 controller 2 views app will become about 4x times faster more complex apps will see huge improvements.
+
+### Q: I'm using an older version of Rails than 2.2, will this work for me?
+A: Unfortunately you are on your own right now :(.
+
+### Q: My `Article` model does not pick up changes from the `articles` table.
+A: You need to force it to be reloaded (just hit the save button in your editor for `article.rb` file).
+
+### Q: I used `require 'article'` and the `Article` model is not being reloaded.
+A: You really shouldn't be using `require` to load your files in the Rails app (if you want them to be automatically reloaded) and let automatic constant loading handle the require for you. You can also use `require_dependency 'article'`, as it goes through the Rails stack.
+
+### Q: I'm using class variables (by class variables I mean "metaclass instance variables") and they are not being reloaded.
+A: Class level instance variables are not thread safe and you shouldn't be really using them :). There is generally only one case where they might pose a problem for `rails-dev-boost`:
+    
+    #app/models/article.rb
+    class Article < ActiveRecord::Base
+    end
+    
+    #app/models/blog.rb
+    class Blog < ActiveRecord::Base
+      def self.all_articles
+        @all_articles ||= Article.all
+      end
+    end
+
+Modifying `article.rb` will not reload `@all_articles` (you would always need to re-save `blog.rb` as well).
+
+The solution is to move class instance variable to its class like this:
+
+    #app/models/article.rb
+    class Article < ActiveRecord::Base
+      def self.all_articles
+        @all_articles ||= all
+      end
+    end
+    
+    #app/models/blog.rb
+    class Blog < ActiveRecord::Base
+      def self.all_articles
+        Article.all_articles
+      end
+    end
+    
+This way saving `arcticle.rb` will trigger the reload of `@all_articles`.
+
+### Q: I'm using JRuby, is it going to work?
+A: I haven't tested the plugin with JRuby, but the plugin does use `ObjectSpace` to do its magic. `ObjectSpace` is AFAIK disabled by default on JRuby.
+
+FAQ added by [thedarkone](http://github.com/thedarkone).
+
+## Credits
+
+Written by [Roman Le Négrate](http://roman.flucti.com) ([contact](mailto:roman.lenegrate@gmail.com)). Released under the MIT-license: see the `LICENSE` file.

data/Rakefile

@@ -0,0 +1,52 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "rails-dev-boost"
+    gem.summary = %Q{Speeds up Rails development mode}
+    gem.description = %Q{Make your Rails app 10 times faster in development mode}
+    gem.email = "roman.lenegrate@gmail.com"
+    gem.homepage = "http://github.com/thedarkone/rails-dev-boost"
+    gem.authors = ["Roman Le Négrate","thedarkone"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "thing #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/TODO.txt

@@ -0,0 +1,2 @@
+* Update ActiveRecord reflections for which the module passed as the :extend option has been unloaded.
+	- update reference:  MacroReflection#@options[:extend]

data/VERSION

@@ -0,0 +1 @@
+0.1.1

data/init.rb

@@ -0,0 +1,3 @@
+if !$rails_rake_task && (Rails.env.development? || (config.respond_to?(:soft_reload) && config.soft_reload))
+  require 'rails_development_boost'
+end

data/lib/rails_development_boost.rb

@@ -0,0 +1,32 @@
+module RailsDevelopmentBoost
+  ActiveSupport.on_load(:after_initialize) do
+    ReferencePatch.apply!
+    DependenciesPatch.apply!
+    DescendantsTrackerPatch.apply!
+    ObservablePatch.apply!
+    
+    # this should go into ActiveSupport.on_load(:action_pack), alas Rails doesn't provide it
+    if defined?(ActionDispatch::Reloader) # post 0f7c970
+      ActionDispatch::Reloader.to_prepare { ActiveSupport::Dependencies.unload_modified_files! }
+    else
+      ActionDispatch::Callbacks.before    { ActiveSupport::Dependencies.unload_modified_files! }
+    end
+  end
+  
+  ActiveSupport.on_load(:action_controller) do
+    ActiveSupport.on_load(:after_initialize) do
+      ViewHelpersPatch.apply!
+    end
+  end
+  
+  autoload :DependenciesPatch,       'rails_development_boost/dependencies_patch'
+  autoload :DescendantsTrackerPatch, 'rails_development_boost/descendants_tracker_patch'
+  autoload :LoadedFile,              'rails_development_boost/loaded_file'
+  autoload :ObservablePatch,         'rails_development_boost/observable_patch'
+  autoload :ReferencePatch,          'rails_development_boost/reference_patch'
+  autoload :ViewHelpersPatch,        'rails_development_boost/view_helpers_patch'
+  
+  def self.debug!
+    DependenciesPatch.debug!
+  end
+end

data/lib/rails_development_boost/dependencies_patch.rb

@@ -0,0 +1,332 @@
+module RailsDevelopmentBoost
+  module DependenciesPatch
+    module LoadablePatch
+      def require_dependency_with_constant_tracking(*args)
+        ActiveSupport::Dependencies.required_dependency(args.first)
+        # handle plugins such as concerned_with
+        require_dependency_without_constant_tracking(*args)
+      end
+    end
+    
+    def self.apply!
+      # retain the original method in case the application overwrites it on its modules/klasses
+      Module.send :alias_method, :_mod_name, :name
+      
+      patch = self
+      ActiveSupport::Dependencies.module_eval do
+        alias_method :local_const_defined?, :uninherited_const_defined? unless method_defined?(:local_const_defined?) # pre 4da45060 compatibility
+        remove_possible_method :remove_unloadable_constants!
+        remove_possible_method :clear
+        include patch
+        alias_method_chain :load_file, 'constant_tracking'
+        alias_method_chain :remove_constant, 'handling_of_connections'
+        extend patch
+      end
+      
+      ActiveSupport::Dependencies::Loadable.module_eval do
+        include LoadablePatch
+        alias_method_chain :require_dependency, 'constant_tracking'
+      end
+
+      InstrumentationPatch.apply! if @do_instrument
+      
+      ActiveSupport::Dependencies.handle_already_autoloaded_constants!
+    end
+  
+    def self.debug!
+      if ActiveSupport::Dependencies < DependenciesPatch
+        InstrumentationPatch.apply!
+      else
+        @do_instrument = true
+      end
+    end
+    
+    autoload :InstrumentationPatch, 'rails_development_boost/dependencies_patch/instrumentation_patch'
+  
+    mattr_accessor :module_cache
+    self.module_cache = []
+    
+    mattr_accessor :file_map
+    self.file_map = {}
+    
+    mattr_accessor :constants_being_removed
+    self.constants_being_removed = []
+    
+    mattr_accessor :explicit_dependencies
+    self.explicit_dependencies = {}
+    
+    def unload_modified_files!
+      log_call
+      file_map.values.each do |file|
+        unload_modified_file(file) if file.changed?
+      end
+    end
+    
+    def remove_explicitely_unloadable_constants!
+      explicitly_unloadable_constants.each { |const| remove_constant(const) }
+    end
+    
+    # Overridden.
+    def clear
+    end
+    
+    # Augmented `load_file'.
+    def load_file_with_constant_tracking(path, *args, &block)
+      result = now_loading(path) { load_file_without_constant_tracking(path, *args, &block) }
+      
+      unless load_once_path?(path)
+        new_constants = autoloaded_constants - file_map.values.map(&:constants).flatten
+      
+        # Associate newly loaded constants to the file just loaded
+        associate_constants_to_file(new_constants, path)
+      end
+
+      result
+    end
+    
+    def now_loading(path)
+      @currently_loading, old_currently_loading = path, @currently_loading
+      yield
+    rescue Exception => e
+      error_loading_file(@currently_loading, e)
+    ensure
+      @currently_loading = old_currently_loading
+    end
+    
+    def associate_constants_to_file(constants, file_path)
+      # freezing strings before using them as Hash keys is slightly more memory efficient
+      constants.map!(&:freeze)
+      file_path.freeze
+      
+      loaded_file_for(file_path).add_constants(constants)
+    end
+    
+    def loaded_file_for(file_path)
+      file_map[file_path] ||= LoadedFile.new(file_path)
+    end
+    
+    # Augmented `remove_constant'.
+    def remove_constant_with_handling_of_connections(const_name)
+      fetch_module_cache do
+        prevent_further_removal_of(const_name) do
+          unprotected_remove_constant(const_name)
+        end
+      end
+    end
+    
+    def required_dependency(file_name)
+      # Rails uses require_dependency for loading helpers, we are however dealing with the helper problem elsewhere, so we can skip them
+      if @currently_loading && @currently_loading !~ /_controller(?:\.rb)?\Z/ && file_name !~ /_helper(?:\.rb)?\Z/
+        if full_path = ActiveSupport::Dependencies.search_for_file(file_name)
+          loaded_file_for(@currently_loading).associate_with(loaded_file_for(full_path))
+        end
+      end
+    end
+    
+    def add_explicit_dependency(parent, child)
+      (explicit_dependencies[parent._mod_name] ||= []) << child._mod_name
+    end
+    
+    def handle_already_autoloaded_constants! # we might be late to the party and other gems/plugins might have already triggered autoloading of some constants
+      loaded.each do |require_path|
+        associate_constants_to_file(autoloaded_constants, "#{require_path}.rb") # slightly heavy-handed..
+      end
+    end
+    
+  private
+    def unprotected_remove_constant(const_name)
+      if qualified_const_defined?(const_name) && object = const_name.constantize
+        handle_connected_constants(object, const_name)
+        remove_same_file_constants(const_name)
+        if object.kind_of?(Module)
+          remove_parent_modules_if_autoloaded(object)
+          remove_child_module_constants(object)
+        end
+      end
+      result = remove_constant_without_handling_of_connections(const_name)
+      clear_tracks_of_removed_const(const_name, object)
+      result
+    end
+  
+    def unload_file(file)
+      file.constants.dup.each {|const| remove_constant(const)}
+      clean_up_if_no_constants(file)
+    end
+    alias_method :unload_modified_file, :unload_file
+    
+    def error_loading_file(file_path, e)
+      loaded_file_for(file_path).stale!
+      raise e
+    end
+    
+    def handle_connected_constants(object, const_name)
+      return unless Module === object && qualified_const_defined?(const_name)
+      remove_explicit_dependencies_of(const_name)
+      remove_dependent_modules(object)
+      update_activerecord_related_references(object)
+      remove_nested_constants(const_name)
+    end
+    
+    def remove_nested_constants(const_name)
+      autoloaded_constants.grep(/\A#{const_name}::/).each { |const| remove_nested_constant(const_name, const) }
+    end
+    
+    def remove_nested_constant(parent_const, child_const)
+      remove_constant(child_const)
+    end
+    
+    def autoloaded_namespace_object?(object) # faster than going through Dependencies.autoloaded?
+      LoadedFile.constants_to_files[object._mod_name]
+    end
+    
+    # AS::Dependencies doesn't track same-file nested constants, so we need to look out for them on our own.
+    # For example having loaded an abc.rb that looks like this:
+    #   class Abc; class Inner; end; end
+    # AS::Dependencies would only add "Abc" constant name to its autoloaded_constants list, completely ignoring Abc::Inner. This in turn
+    # can cause problems for classes inheriting from Abc::Inner somewhere else in the app.
+    def remove_parent_modules_if_autoloaded(object)
+      unless autoloaded_namespace_object?(object)
+        initial_object = object
+        
+        while (object = object.parent) != Object
+          if autoloaded_namespace_object?(object)
+            remove_autoloaded_parent_module(initial_object, object)
+            break
+          end
+        end
+      end
+    end
+    
+    def remove_autoloaded_parent_module(initial_object, parent_object)
+      remove_constant(parent_object._mod_name)
+    end
+    
+    # AS::Dependencies doesn't track same-file nested constants, so we need to look out for them on our own and remove any dependent modules/constants
+    def remove_child_module_constants(object)
+      object.constants.each do |const_name|
+        # we only care about "namespace" constants (classes/modules)
+        if local_const_defined?(object, const_name) && (child_const = object.const_get(const_name)).kind_of?(Module)
+          remove_child_module_constant(object, child_const)
+        end
+      end
+    end
+    
+    def remove_child_module_constant(parent_object, child_constant)
+      remove_constant(child_constant._mod_name)
+    end
+    
+    def in_autoloaded_namespace?(object)
+      while object != Object
+        return true if autoloaded_namespace_object?(object)
+        object = object.parent
+      end
+      false
+    end    
+    
+    def remove_same_file_constants(const_name)
+      LoadedFile.each_file_with_const(const_name) {|file| unload_containing_file(const_name, file)}
+    end
+    
+    def unload_containing_file(const_name, file)
+      unload_file(file)
+    end
+    
+    def remove_explicit_dependencies_of(const_name)
+      if dependencies = explicit_dependencies.delete(const_name)
+        dependencies.uniq.each {|depending_const| remove_explicit_dependency(const_name, depending_const)}
+      end
+    end
+    
+    def remove_explicit_dependency(const_name, depending_const)
+      remove_constant(depending_const)
+    end
+    
+    def clear_tracks_of_removed_const(const_name, object)
+      autoloaded_constants.delete(const_name)
+      module_cache.delete_if { |mod| mod._mod_name == const_name }
+      clean_up_references(const_name, object)
+      
+      LoadedFile.each_file_with_const(const_name) do |file|
+        file.delete_constant(const_name)
+        clean_up_if_no_constants(file)
+      end
+    end
+    
+    def clean_up_if_no_constants(file)
+      if file.constants.empty?
+        loaded.delete(file.require_path)
+        file_map.delete(file.path)
+      end
+    end
+    
+    def clean_up_references(const_name, object)
+      ActiveSupport::Dependencies::Reference.loose!(const_name)
+      ActiveSupport::DescendantsTracker.delete(object)
+    end
+    
+    def remove_dependent_modules(mod)
+      fetch_module_cache do |modules|
+        modules.dup.each do |other|
+          next unless other < mod || other.singleton_class.ancestors.include?(mod)
+          next unless first_non_anonymous_superclass(other) == mod if Class === mod
+          next unless qualified_const_defined?(other._mod_name) && other._mod_name.constantize == other
+          next unless in_autoloaded_namespace?(other)
+          remove_dependent_constant(mod, other)
+        end
+      end
+    end
+    
+    def remove_dependent_constant(original_module, dependent_module)
+      remove_constant(dependent_module._mod_name)
+    end
+    
+    def first_non_anonymous_superclass(klass)
+      while (klass = klass.superclass) && anonymous?(klass); end
+      klass
+    end
+    
+    # egrep -ohR '@\w*([ck]lass|refl|target|own)\w*' activerecord | sort | uniq
+    def update_activerecord_related_references(klass)
+      return unless defined?(ActiveRecord)
+      return unless klass < ActiveRecord::Base
+
+      # Reset references held by macro reflections (klass is lazy loaded, so
+      # setting its cache to nil will force the name to be resolved again).
+      ActiveRecord::Base.descendants.each do |model|
+        model.reflections.each_value do |reflection|
+          reflection.instance_eval do
+            @klass = nil if @klass == klass
+          end
+        end
+      end
+    end
+    
+    def anonymous?(mod)
+      !(name = mod._mod_name) || name.empty?
+    end
+  
+  private
+
+    def fetch_module_cache
+      return(yield(module_cache)) if module_cache.any?
+      
+      ObjectSpace.each_object(Module) { |mod| module_cache << mod unless anonymous?(mod) }
+      begin
+        yield module_cache
+      ensure
+        module_cache.clear
+      end
+    end
+
+    def prevent_further_removal_of(const_name)
+      return if constants_being_removed.include?(const_name)
+      
+      constants_being_removed << const_name
+      begin
+        yield
+      ensure
+        constants_being_removed.delete(const_name)
+      end
+    end
+  end
+end