rack-unreloader 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7665e2203b2b2f7ac74d05e6c0b5b2c60d7d89d8
+  data.tar.gz: 19cd1b3fcf725bdaf58db40ba67426c38b3823d1
+SHA512:
+  metadata.gz: 7810e9036260c1a517f544783e755997deeb759fcb56e05fdc2ee16109de4c74c907f94a019fe42c503610255797d4f04f76060ff8dde732037eb15df52b90a2
+  data.tar.gz: 17a0ea4463d61cfb959e72ce724c28fecba47dc7ac098ab0b01559c17f8e90026436b982da342335610d281f4fd652b3f13bfd5b1d1b10555d8ec590410036df

data/CHANGELOG

@@ -0,0 +1,3 @@
+= 0.9.0 (2014-08-04)
+
+* Initial public release

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2014 Jeremy Evans
+Copyright (c) 2011 Padrino
+
+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.rdoc

@@ -0,0 +1,177 @@
+= Rack::Unreloader
+
+Rack::Unreloader is a rack library that reloads application files when it
+detects changes, unloading constants defined in those files before reloading.
+Like other rack libraries for reloading, this can make application development
+much faster, as you don't need to restart the whole application when you change
+a single file.  Unlike most other rack libraries for reloading, this unloads
+constants before requiring files, avoiding issues when loading a file is not
+idempotent.
+
+== Installation
+
+  gem install rack-unreloader
+
+== Source Code
+
+Source code is available on GitHub at https://github.com/jeremyevans/rack-unreloader
+
+== Basic Usage
+
+Assuming a basic web application stored in +app.rb+:
+
+  require 'roda'
+
+  class App < Roda
+    route do |r|
+      "Hello world!"
+    end
+  end
+
+With a basic +config.ru+ like this:
+
+  require './app.rb'
+  run App
+
+Change +config.ru+ to:
+
+  require 'rack-unreloader'
+  Unreloader = Rack::Unreloader.new{App}
+  require 'roda'
+  Unreloader.require './app.rb'
+  run Unreloader
+
+The block you pass to Rack::Unreloader.new should return the rack application
+to use.  If you make any changes to +app.rb+, <tt>Rack::Unreloader</tt> will remove any
+constants defined by requiring +app.rb+, and rerequire the file.
+
+Note that this causes problems if +app.rb+ loads any new libraries that define
+constants, as it will unload those constants first.  This is why the example
+code requires the +roda+ library normally before requiring +app.rb+ using
+<tt>Rack::Unreloader</tt>.
+
+However, if +app.rb+ requires more than a single file, it is more 
+practical to tell <tt>Rack::Unreloader</tt> to only unload specific subclasses:
+
+  require 'rack-unreloader'
+  Unreloader = Rack::Unreloader.new(:subclasses=>%w'Roda'){App}
+  Unreloader.require './app.rb'
+  run Unreloader
+  
+When the +:subclasses+ option is given, only subclasses of the given classes
+will be unloaded before reloading the file.  It is recommended that
+you use a +:subclasses+ option when using <tt>Rack::Unreloader</tt>.
+
+== Dependency Handling
+
+If your +app.rb+ requires a +models.rb+ file that you also want to get reloaded:
+
+  require 'roda'
+  require './models.rb'
+
+  class App < Roda
+    route do |r|
+      "Hello world!"
+    end
+  end
+
+You can change +app.rb+ from using:
+
+  require './models.rb'
+
+to using:
+
+  Unreloader.require './models.rb'
+
+The reason that the <tt>Rack::Unreloader</tt> instance is assigned to a constant in
++config.ru+ is to make it easy to add reloadable dependencies in this way.
+
+It's even a better idea to require this dependency manually in +config.ru+,
+before requiring +app.rb+:
+
+  require 'rack-unreloader'
+  Unreloader = Rack::Unreloader.new(:subclasses=>%w'Roda Sequel::Model'){App}
+  Unreloader.require './models.rb'
+  Unreloader.require './app.rb'
+  run Unreloader
+
+This way, changing your +app.rb+ file will not reload your +models.rb+ file.
+
+== Only in Development Mode
+
+In general, you are only going to want to run this in development mode.
+Assuming you use +RACK_ENV+ to determine development mode, you can change
++config.ru+ to:
+
+  if ENV['RACK_ENV'] == 'development'
+    require 'rack-unreloader'
+    Unreloader = Rack::Unreloader.new{App}
+    Unreloader.require './models.rb'
+    Unreloader.require './app.rb'
+    run Unreloader
+  else
+    require './app.rb'
+    run App
+  end
+
+If there are dependencies that you don't want to require directly in your
++config.ru+, but you do want to use <tt>Rack::Unreloader</tt> for them in
+development, you can do:
+
+  (defined?(Unreloader) ? Unreloader : Kernel).require './models.rb'
+
+== Modules
+
+This reloader also handles modules.  Since modules do not have superclasses,
+if you are using the +:subclasses+ option to specify specific subclasses, you
+need to specify the module name if you want to reload it:
+
+  Unreloader = Rack::Unreloader.new(:subclasses=>%w'MyModule'){App}
+
+== Requiring
+
+Rack::Unreloader#require is a little different than require in that it takes
+a file glob, not a normal require path.  For that reason, you must specify
+the extension when requiring the file, and it will only look in the current
+directory by default:
+
+  Unreloader.require 'app.rb'
+
+If you want to require a file in a different directory, you need to provide the
+full path:
+
+  Unreloader.require '/path/to/app.rb'
+
+You can use the usual file globbing:
+
+  Unreloader.require 'models/*.rb'
+
+== History
+
+Rack::Unreloader was derived from Padrino's reloader.  It is significantly smaller
+as it cuts out a lot of Padrino-specific code, and it forces the user to manually
+specify what files to monitor.
+
+== Caveats
+
+Unloading constants and reloading files has a ton of corner cases that this
+will not handle correctly.  If it isn't doing what you expect, add a logger:
+
+  Rack::Unreloader.new(:logger=>Logger.new($stdout)){App}
+
+Unloading constants causes issues whenever references to the constant are
+cached anywhere instead of looking up the constant by name.  This is fairly
+common, and using this library can cause a memory leak in such a case.
+
+Approaches that load a fresh environment for every request (or a fresh
+environment anytime there are any changes) are going to be more robust than
+this approach, but probably slower.  Be aware that you are trading robustness
+for speed when using this library.
+
+== License
+
+MIT
+
+== Maintainer
+
+Jeremy Evans <code@jeremyevans.net>

data/Rakefile

@@ -0,0 +1,68 @@
+require "rake"
+require "rake/clean"
+
+CLEAN.include ["rack-unreloader-*.gem", "rdoc"]
+
+desc "Build rack-unreloader gem"
+task :package=>[:clean] do |p|
+  sh %{#{FileUtils::RUBY} -S gem build rack-unreloader.gemspec}
+end
+
+### Specs
+
+begin
+  begin
+    # RSpec 1
+    require "spec/rake/spectask"
+    spec_class = Spec::Rake::SpecTask
+    spec_files_meth = :spec_files=
+  rescue LoadError
+    # RSpec 2
+    require "rspec/core/rake_task"
+    spec_class = RSpec::Core::RakeTask
+    spec_files_meth = :pattern=
+  end
+
+  spec = lambda do |name, files, d|
+    lib_dir = File.join(File.dirname(File.expand_path(__FILE__)), 'lib')
+    ENV['RUBYLIB'] ? (ENV['RUBYLIB'] += ":#{lib_dir}") : (ENV['RUBYLIB'] = lib_dir)
+    desc d
+    spec_class.new(name) do |t|
+      t.send(spec_files_meth, files)
+    end
+  end
+
+  task :default => [:spec]
+  spec.call("spec", Dir["spec/*_spec.rb"], "Run specs")
+rescue LoadError
+  task :default do
+    puts "Must install rspec to run the default task (which runs specs)"
+  end
+end
+
+### RDoc
+
+RDOC_DEFAULT_OPTS = ["--quiet", "--line-numbers", "--inline-source", '--title', 'Rack::Unreloader: Reload application when files change, unloading constants first']
+
+begin
+  gem 'hanna-nouveau'
+  RDOC_DEFAULT_OPTS.concat(['-f', 'hanna'])
+rescue Gem::LoadError
+end
+
+rdoc_task_class = begin
+  require "rdoc/task"
+  RDoc::Task
+rescue LoadError
+  require "rake/rdoctask"
+  Rake::RDocTask
+end
+
+RDOC_OPTS = RDOC_DEFAULT_OPTS + ['--main', 'README.rdoc']
+
+rdoc_task_class.new do |rdoc|
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.options += RDOC_OPTS
+  rdoc.rdoc_files.add %w"README.rdoc CHANGELOG MIT-LICENSE lib/**/*.rb"
+end
+

data/lib/rack/unreloader.rb

@@ -0,0 +1,264 @@
+require 'set'
+
+module Rack
+  # Reloading application that unloads constants before reloading the relevant
+  # files, calling the new rack app if it gets reloaded.
+  class Unreloader
+    class Reloader
+      # Reference to ::File as File would return Rack::File by default.
+      F = ::File
+
+      # Regexp for valid constant names, to prevent code execution.
+      VALID_CONSTANT_NAME_REGEXP = /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/.freeze
+
+      # Setup the reloader.  Supports :logger and :subclasses options, see
+      # Rack::Unloader.new for details.
+      def initialize(opts={})
+        @logger = opts[:logger]
+        @classes = opts[:subclasses] ?  Array(opts[:subclasses]).map{|s| s.to_s} : %w'Object'
+
+        # Hash of files being monitored for changes, keyed by absolute path of file name,
+        # with values being the last modified time (or nil if the file has not yet been loaded).
+        @monitor_files = {}
+
+        # Hash keyed by absolute path of file name, storing constants and other
+        # filenames that the key loads.  Values should be hashes with :constants
+        # and :features keys, and arrays of values.
+        @files = {}
+
+        # Similar to @files, but stores previous entries, used when rolling back.
+        @old_entries = {}
+      end
+
+      # Tries to find a declared constant with the name specified
+      # in the string. It raises a NameError when the name is not in CamelCase
+      # or is not initialized.
+      def constantize(s)
+        s = s.to_s
+        if m = VALID_CONSTANT_NAME_REGEXP.match(s)
+          Object.module_eval("::#{m[1]}", __FILE__, __LINE__)
+        else
+          log("#{s.inspect} is not a valid constant name!")
+        end
+      end
+
+      # Log the given string at info level if there is a logger.
+      def log(s)
+        @logger.info(s) if @logger
+      end
+  
+      # If there are any changed files, reload them.  If there are no changed
+      # files, do nothing.
+      def reload!
+        @monitor_files.to_a.each do |file, time|
+          if file_changed?(file, time)
+            safe_load(file)
+          end
+        end
+      end
+
+      # Require the given dependencies, monitoring them for changes.
+      # Paths should be a file glob or an array of file globs.
+      def require_dependencies(paths)
+        options = {:cyclic => true}
+        error = nil 
+
+        Array(paths).
+          flatten.
+          map{|path| Dir.glob(path).sort_by{|filename| filename.count('/')}}.
+          flatten.
+          map{|path| F.expand_path(path)}.
+          uniq.
+          each do |file|
+
+          @monitor_files[file] = nil
+          begin
+            safe_load(file, options)
+          rescue NameError, LoadError => error
+            log "Cyclic dependency reload for #{error}"
+          rescue Exception => error
+            break
+          end
+        end
+
+        if error
+          log error
+          raise error
+        end
+      end
+
+      # Requires the given file, logging which constants or features are added
+      # by the require, and rolling back the constants and features if there
+      # are any errors.
+      def safe_load(file, options={})
+        return unless @monitor_files.has_key?(file)
+        return unless options[:force] || file_changed?(file)
+
+        prepare(file) # might call #safe_load recursively
+        log "#{@monitor_files[file] ? 'Reloading' : 'Loading'} #{file}"
+        begin
+          require(file)
+          commit(file)
+        rescue Exception
+          if !options[:cyclic]
+            log "Failed to load #{file}; removing partially defined constants"
+          end
+          rollback(file)
+          raise
+        end
+      end
+
+      # Removes the specified constant.
+      def remove_constant(const)
+        base, _, object = const.to_s.rpartition('::')
+        base = base.empty? ? Object : constantize(base)
+        base.send :remove_const, object
+        log "Removed constant #{const}"
+      rescue NameError
+      end
+
+      # Remove a feature if it is being monitored for reloading, so it
+      # can be required again.
+      def remove_feature(file)
+        $LOADED_FEATURES.delete(file) if @monitor_files.has_key?(file)
+      end
+
+      # Unload all reloadable constants and features, and clear the list
+      # of files to monitor.
+      def clear!
+        @files.keys.each do |file|
+          remove(file)
+          remove_feature(file)
+        end
+        @monitor_files = {}
+        @old_entries = {}
+      end
+
+      # Remove the given file, removing any constants and other files loaded
+      # by the file.
+      def remove(name)
+        file = @files[name] || return
+        file[:constants].each{|constant| remove_constant(constant)}
+        file[:features].each{|feature| remove_feature(feature)}
+        @files.delete(name)
+      end
+
+      # Store the currently loaded classes and features, so in case of an error
+      # this state can be rolled back to.
+      def prepare(name)
+        file = remove(name)
+        old_features = Set.new($LOADED_FEATURES)
+        @old_entries[name] = {:constants => all_classes, :features => old_features}
+        features = file && file[:features] || []
+        features.each{|feature| safe_load(feature, :force => true)}
+        remove_feature(name) if old_features.include?(name)
+      end
+
+      # Commit the changed state after requiring the the file, recording the new
+      # classes and features added by the file.
+      def commit(name)
+        entry = {
+          :constants => new_classes(@old_entries[name][:constants]),
+          :features  => Set.new($LOADED_FEATURES) - @old_entries[name][:features] - [name]
+        }
+        @files[name] = entry
+        @old_entries.delete(name)
+        @monitor_files[name] = modified_at(name)
+      end
+
+      # Rollback the changes made by requiring the file, restoring the previous state.
+      def rollback(name)
+        new_classes(@old_entries[name][:constants]).each{|klass| remove_constant(klass)}
+        @old_entries.delete(name)
+      end
+
+      private
+
+      # Return a set of all classes in the ObjectSpace.
+      def all_classes
+        rs = Set.new
+
+        ObjectSpace.each_object(Module).each do |klass|
+          if monitored_class?(klass)
+            rs << klass
+          end
+        end
+
+        rs
+      end
+
+      # Return whether the given klass is a monitored class that could
+      # be unloaded.
+      def monitored_class?(klass)
+        @classes.any? do |c|
+          c = constantize(c) rescue false
+
+          if klass.is_a?(Class)
+            # Reload the class if it is a subclass if the current class
+            (klass < c) rescue false
+          elsif c == Object
+            # If reloading for all classes, reload for all modules as well
+            true
+          else
+            # Otherwise, reload only if the module matches exactly, since
+            # modules don't have superclasses.
+            klass == c
+          end
+        end
+      end
+
+      # Return a set of all classes in the ObjectSpace that are not in the
+      # given set of classes.
+      def new_classes(snapshot)
+        all_classes - snapshot
+      end
+
+      # Returns true if the file is new or it's modification time changed.
+      def file_changed?(file, time = @monitor_files[file])
+        !time || modified_at(file) > time
+      end
+
+      # Return the time the file was modified at.  This can be overridden
+      # to base the reloading on something other than the file's modification
+      # time.
+      def modified_at(file)
+        F.mtime(file)
+      end
+    end
+
+    # The Rack::Unreloader::Reloader instead related to this instance.
+    attr_reader :reloader
+
+    # Setup the reloader. Options:
+    # 
+    # :cooldown :: The number of seconds to wait between checks for changed files.
+    #              Defaults to 1.
+    # :logger :: A Logger instance which will log information related to reloading.
+    # :subclasses :: A string or array of strings of class names that should be unloaded.
+    #                Any classes that are not subclasses of these classes will not be
+    #                unloaded.  This also handles modules, but module names given must
+    #                match exactly, since modules don't have superclasses.
+    def initialize(opts={}, &block)
+      @app_block = block
+      @cooldown = opts[:cooldown] || 1
+      @last = Time.at(0)
+      @reloader = Reloader.new(opts)
+      @reloader.reload!
+    end
+
+    # If the cooldown time has been passed, reload any application files that have changed.
+    # Call the app with the environment.
+    def call(env)
+      if @cooldown && Time.now > @last + @cooldown
+        Thread.exclusive{@reloader.reload!}
+        @last = Time.now
+      end
+      @app_block.call.call(env)
+    end
+
+    # Add a file glob or array of file globs to monitor for changes.
+    def require(depends)
+      @reloader.require_dependencies(depends)
+    end
+  end
+end

data/spec/unreloader_spec.rb

@@ -0,0 +1,145 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), '../lib/rack/unreloader')
+
+module ModifiedAt
+  def set_modified_time(file, time)
+    modified_times[File.expand_path(file)] = time
+  end
+
+  def modified_times
+    @modified_times ||= {}
+  end
+
+  private
+
+  def modified_at(file)
+    modified_times[file] || super
+  end
+end
+
+describe Rack::Unreloader do
+  def code(i)
+    "class App; def self.call(env) @a end; @a ||= []; @a << #{i}; end"
+  end
+
+  def update_app(code, file=@filename)
+    ru.reloader.set_modified_time(file, @i += 1)
+    File.open(file, 'wb'){|f| f.write(code)}
+  end
+
+  def logger
+    return @logger if @logger
+    @logger = []
+    def @logger.method_missing(meth, log)
+      self << log
+    end
+    @logger
+  end
+
+  def ru(opts={})
+    return @ru if @ru
+    block = opts[:block] || proc{App}
+    @ru = Rack::Unreloader.new({:logger=>logger, :cooldown=>0}.merge(opts), &block)
+    @ru.reloader.extend ModifiedAt
+    Object.const_set(:RU, @ru)
+    update_app(opts[:code]||code(1))
+    yield if block_given?
+    @ru.require 'spec/app.rb'
+    @ru
+  end
+
+  def log_match(*logs)
+    logs.length == @logger.length
+    logs.zip(@logger).each{|l, log| l.is_a?(String) ? log.should == l : log.should =~ l}
+  end
+
+  before do
+    @i = 0
+    @filename = 'spec/app.rb'
+  end
+
+  after do
+    ru.reloader.clear!
+    Object.send(:remove_const, :RU)
+    Object.send(:remove_const, :App) if defined?(::App)
+    Object.send(:remove_const, :App2) if defined?(::App2)
+    Dir['spec/app*.rb'].each{|f| File.delete(f)}
+  end
+
+  it "it should unload constants contained in file and reload file if file changes" do
+    ru.call({}).should == [1]
+    update_app(code(2))
+    ru.call({}).should == [2]
+    log_match(%r{\ALoading.*spec/app\.rb\z}, "Removed constant App", %r{\AReloading.*spec/app\.rb\z})
+  end
+
+  it "it should pickup files added as dependencies" do
+    ru.call({}).should == [1]
+    update_app("RU.require 'spec/app2.rb'; class App; def self.call(env) [@a, App2.call(env)] end; @a ||= []; @a << 2; end")
+    update_app("class App2; def self.call(env) @a end; @a ||= []; @a << 3; end", 'spec/app2.rb')
+    ru.call({}).should == [[2], [3]]
+    update_app("class App2; def self.call(env) @a end; @a ||= []; @a << 4; end", 'spec/app2.rb')
+    ru.call({}).should == [[2], [4]]
+    update_app("RU.require 'spec/app2.rb'; class App; def self.call(env) [@a, App2.call(env)] end; @a ||= []; @a << 2; end")
+    log_match(%r{\ALoading.*spec/app\.rb\z}, "Removed constant App", %r{\AReloading.*spec/app\.rb\z},
+              %r{\ALoading.*spec/app2\.rb\z}, "Removed constant App2", %r{\AReloading.*spec/app2\.rb\z})
+  end
+
+  it "it should support :subclasses option and only unload subclasses of given class" do
+    ru(:subclasses=>'App').call({}).should == [1]
+    update_app("RU.require 'spec/app2.rb'; class App; def self.call(env) [@a, App2.call(env)] end; @a ||= []; @a << 2; end")
+    update_app("class App2 < App; def self.call(env) @a end; @a ||= []; @a << 3; end", 'spec/app2.rb')
+    ru.call({}).should == [[1, 2], [3]]
+    update_app("class App2 < App; def self.call(env) @a end; @a ||= []; @a << 4; end", 'spec/app2.rb')
+    ru.call({}).should == [[1, 2], [4]]
+    update_app("RU.require 'spec/app2.rb'; class App; def self.call(env) [@a, App2.call(env)] end; @a ||= []; @a << 2; end")
+    log_match(%r{\ALoading.*spec/app\.rb\z}, %r{\AReloading.*spec/app\.rb\z},
+              %r{\ALoading.*spec/app2\.rb\z}, "Removed constant App2", %r{\AReloading.*spec/app2\.rb\z})
+  end
+
+  it "it log invalid constant names in :subclasses options" do
+    ru(:subclasses=>%w'1 Object').call({}).should == [1]
+    logger.uniq!
+    log_match('"1" is not a valid constant name!', %r{\ALoading.*spec/app\.rb\z})
+  end
+
+  it "it should unload modules before reloading similar to classes" do
+    ru(:code=>"module App; def self.call(env) @a end; @a ||= []; @a << 1; end").call({}).should == [1]
+    update_app("module App; def self.call(env) @a end; @a ||= []; @a << 2; end")
+    ru.call({}).should == [2]
+    log_match(%r{\ALoading.*spec/app\.rb\z}, "Removed constant App", %r{\AReloading.*spec/app\.rb\z})
+  end
+
+  it "it should unload specific modules by name via :subclasses option" do
+    ru(:subclasses=>'App', :code=>"module App; def self.call(env) @a end; @a ||= []; @a << 1; end").call({}).should == [1]
+    update_app("module App; def self.call(env) @a end; @a ||= []; @a << 2; end")
+    ru.call({}).should == [2]
+    log_match(%r{\ALoading.*spec/app\.rb\z}, "Removed constant App", %r{\AReloading.*spec/app\.rb\z})
+  end
+
+  it "it should not unload modules by name if :subclasses option used and module not present" do
+    ru(:subclasses=>'Foo', :code=>"module App; def self.call(env) @a end; @a ||= []; @a << 1; end").call({}).should == [1]
+    update_app("module App; def self.call(env) @a end; @a ||= []; @a << 2; end")
+    ru.call({}).should == [1, 2]
+    log_match(%r{\ALoading.*spec/app\.rb\z}, %r{\AReloading.*spec/app\.rb\z})
+  end
+
+  it "it unload partially loaded modules if loading fails, and allow future loading" do
+    ru.call({}).should == [1]
+    update_app("module App; def self.call(env) @a end; @a ||= []; raise 'foo'; end")
+    proc{ru.call({})}.should raise_error
+    defined?(::App).should == nil
+    update_app(code(2))
+    ru.call({}).should == [2]
+    log_match(%r{\ALoading.*spec/app\.rb\z}, "Removed constant App", %r{\AReloading.*spec/app\.rb\z},
+              %r{\AFailed to load .*spec/app\.rb; removing partially defined constants\z},
+             "Removed constant App", %r{\AReloading.*spec/app\.rb\z})
+  end
+
+  it "it should unload classes in namespaces" do
+    ru(:code=>"class Array::App; def self.call(env) @a end; @a ||= []; @a << 1; end", :block=>proc{Array::App}).call({}).should == [1]
+    update_app("class Array::App; def self.call(env) @a end; @a ||= []; @a << 2; end")
+    ru.call({}).should == [2]
+    log_match(%r{\ALoading.*spec/app\.rb\z}, "Removed constant Array::App", %r{\AReloading.*spec/app\.rb\z})
+  end
+
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: rack-unreloader
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+platform: ruby
+authors:
+- Jeremy Evans
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-04 00:00:00.000000000 Z
+dependencies: []
+description: |
+  Rack::Unreloader is a rack middleware that reloads application files when it
+  detects changes, unloading constants defined in those files before reloading.
+email: code@jeremyevans.net
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+- CHANGELOG
+- MIT-LICENSE
+files:
+- CHANGELOG
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- lib/rack/unreloader.rb
+- spec/unreloader_spec.rb
+homepage: http://gihub.com/jeremyevans/rack-unreloader
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--quiet"
+- "--line-numbers"
+- "--inline-source"
+- "--title"
+- 'Rack::Unreloader: Reload application when files change, unloading constants first'
+- "--main"
+- README.rdoc
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Reload application when files change, unloading constants first
+test_files: []