autoreload 0.3.1 → 1.0.0

data/HISTORY.rdoc

@@ -1,23 +1,63 @@
 = RELEASE HISTORY
 
+== 1.0.0 (2011-07-15)
+
+This release overhauls the API. The #autoreload method now
+takes a block. All libraries required within this block
+will be autoreloaded. The old API will raise an error!!!
+This was done to simplify the overaul design of the library
+and consequently make it much more efficient, but also to
+fix a rather nasty bug that prevented scripts required by
+other scripts that were to be autoreloaded from autoreloading
+as well. 
+
+The new design rely's solely on $LOADED_FEATURES, rather than
+looking up files on the $LOAD_PATH itself. This has an important
+consequence for Ruby 1.8 or older. Becuase older version of Ruby
+do not put the expanded path in $LOADED_FEATURES, autoreloading
+occurs regardless of whether the file has changed or not. On
+Ruby 1.9+ however, where the full path is available, the file will
+only be reloaded if it has changed, it does this by checking the
+mtime of the file.
+
+Changes:
+
+* Overhaul API to use block form.
+* Remove Lookup module (no longer needed).
+* Fix require of require issue.
+
+
+== 0.3.1 (2011-05-15)
+
+This release simply fixes licensing issues. Autoreload is licensed
+under the GPL v3.
+
 
 == 0.3.0 (2010-10-14)
 
+Changes:
+
 * Fix issue with looking up Roller libraries.
 * Switch testing framework to RSpec2.
 
 
 == 0.2.0 (2010-05-10)
 
+Changes:
+
 * Completely reworked API.
 
 
 == 0.1.0 (2010-05-01)
 
+Changes:
+
 * Same as original, but now a RubyWorks project.
 
 
 == 0.0.1 (2007-07-01)
 
+Changes:
+
 * Initial release
 

data/MANIFEST

@@ -0,0 +1,14 @@
+#!mast .ruby .yardopts bin lib spec try [A-Z][A-Z]*
+.ruby
+.yardopts
+lib/autoreload/reloader.rb
+lib/autoreload/version.rb
+lib/autoreload.rb
+spec/autoreload_spec.rb
+try/changeme.rb
+try/start.rb
+HISTORY.rdoc
+PROFILE
+README.rdoc
+VERSION
+COPYING.rdoc

data/PROFILE

@@ -0,0 +1,28 @@
+--- 
+title  : AutoReload
+summary: Automatically reload library files
+
+requirements:
+  - detroit (build)
+  - minitest (test)
+
+authors:
+  - Thomas Sawyer <transfire@gmail.com>
+  - Kouichirou Eto
+
+description:
+  Autoreload automatically reloads library files when they have been
+  updated. It is especially useful when testing stateless services
+  such as web applications.
+
+resources:
+  home: http://rubyworks.github.com/autoreload
+  code: http://github.com/rubyworks/autoreload
+  gem:  http://rubygems.org/gems/autoreload
+
+created: 2007-07-01
+
+copyrights:
+  - 2010 Thomas Sawyer (BSD-2)
+  - 2003 Kouichiro Eto (RUBY)
+ 

data/README.rdoc

@@ -1,19 +1,26 @@
-= Autoreload
+= AutoReload
 
-== DESCRIPTION
 
-Autoreload automatically reloads library files when they have been
-updated. It is especailly useful when testing stateless services
-such as web applications.
+== Description
 
+Autoreload automatically reloads library files after they
+have been updated. It is especailly useful when testing
+stateless services such as web applications.
 
-== RESOURCES
+IMPORTANT! Version 1.0+ has a new API. It also works best
+under Ruby 1.9 or above. Under Ruby 1.8 or older files are 
+reloaded regardless of whether they actually have changed
+since the last load. Whereas in Ruby 1.9+, they only reload
+if the mtime on the file is newer than the previous time.
 
-* home: http://rubyworks.github.com/autoreload
-* work: http://github.com/rubyworks/autoreload
 
+== Resources
 
-== HOW TO USE
+* {Homepage}[http://rubyworks.github.com/autoreload]
+* {Source Code}[http://github.com/rubyworks/autoreload]
+
+
+== Synopsis
 
 Say we have a library <tt>foo.rb</tt> in our load path:
 
@@ -24,24 +31,31 @@ Say we have a library <tt>foo.rb</tt> in our load path:
 We can then run the following script, <tt>example.rb</tt>:
 
   require 'autoreload'
-  require 'foo'
 
-  autoreload('foo.rb', :interval=>2, :verbose=>true)
+  autoreload(:interval=>2, :verbose=>true) do
+    require 'foo.rb'
+  end
 
   loop {
     puts foo
     sleep 2
   }
 
-With that running we can change <tt>foo.rb</tt> and the change will take 
-effect in <tt>example.rb</tt> within two seconds of being made.
+With that running we can change <tt>foo.rb</tt> and the change
+will take effect in <tt>example.rb</tt> within two seconds of
+being made.
+
+Note, that autoreload only works with _required_ files. It cannot
+monitor files that are broght in with _load_. This is because
+$LOADED_FEATURES is used to track which files are monitored.
+
 
+== Copyrights
 
-== COPYRIGHT
+Copyright (c) 2003,2007 Kouichirou Eto
 
-(GPL v3 License)
+Copyright (c) 2010 Thomas Sawyer
 
-* Copyright (c) 2007 Kouichirou Eto
-* Copyright (c) 2010 Thomas Sawyer
+BSD 2-Clause License
 
 See COPYING.rdoc for more information.

data/Rakefile

@@ -0,0 +1,9 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << "lib"
+  t.libs << "tmp"
+  t.test_files = FileList['spec/*_spec.rb']
+  t.verbose = false
+end
+

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/autoreload.gemspec

@@ -0,0 +1,143 @@
+# encoding: utf-8
+
+require 'yaml'
+
+Gem::Specification.new do |gemspec|
+
+  manifest = Dir.glob('manifest{,.txt)', File::FNM_CASEFOLD).first
+
+  scm = case
+        when File.directory?('.git')
+          :git
+        end
+
+  files = case
+          when manifest
+           File.readlines(manifest).
+             map{ |line| line.srtip }.
+             reject{ |line| line.empty? || line[0,1] == '#' }
+          when scm == :git
+           `git ls-files -z`.split("\0")
+          else
+            Dir.glob('{**/}{.*,*}')  # TODO: be more specific using standard locations ?
+          end.select{ |path| File.file?(path) }
+
+  patterns = {
+    :bin_files  => 'bin/*',
+    :lib_files  => 'lib/{**/}*.rb',
+    :ext_files  => 'ext/{**/}extconf.rb',
+    :doc_files  => '*.{txt,rdoc,md,markdown,tt,textile}',
+    :test_files => '{test/{**/}*_test.rb,spec/{**/}*_spec.rb}'
+  }
+
+  glob_files = lambda { |pattern|
+    Dir.glob(pattern).select { |path|
+      File.file?(path) && files.include?(path)
+    }
+  }
+
+  #files = glob_files[patterns[:files]]
+
+  executables = glob_files[patterns[:bin_files]].map do |path|
+                  File.basename(path)
+                end
+
+  extensions = glob_files[patterns[:ext_files]].map do |path|
+                 File.basename(path)
+               end
+
+  metadata = YAML.load_file('.ruby')
+
+  # build-out the gemspec
+
+  case metadata['revision']
+  when 0
+    gemspec.name        = metadata['name']
+    gemspec.version     = metadata['version']
+    gemspec.summary     = metadata['summary']
+    gemspec.description = metadata['description']
+
+    metadata['authors'].each do |author|
+      gemspec.authors << author['name']
+
+      if author.has_key?('email')
+        if gemspec.email
+          gemspec.email << author['email']
+        else
+          gemspec.email = [author['email']]
+        end
+      end
+    end
+
+    gemspec.licenses = metadata['licenses']
+
+    metadata['requirements'].each do |req|
+      name    = req['name']
+      version = req['version']
+      groups  = req['groups']
+
+      #development = req['development']
+      #if development
+      #  # populate development dependencies
+      #  if gemspec.respond_to?(:add_development_dependency)
+      #    gemspec.add_development_dependency(name,*version)
+      #  else
+      #    gemspec.add_dependency(name,*version)
+      #  end
+      #else
+      #  # populate runtime dependencies  
+      #  if gemspec.respond_to?(:add_runtime_dependency)
+      #    gemspec.add_runtime_dependency(name,*version)
+      #  else
+      #    gemspec.add_dependency(name,*version)
+      #  end
+      #end
+
+      if groups.empty? or groups.include?('runtime')
+        # populate runtime dependencies  
+        if gemspec.respond_to?(:add_runtime_dependency)
+          gemspec.add_runtime_dependency(name,*version)
+        else
+          gemspec.add_dependency(name,*version)
+        end
+      else
+        # populate development dependencies
+        if gemspec.respond_to?(:add_development_dependency)
+          gemspec.add_development_dependency(name,*version)
+        else
+          gemspec.add_dependency(name,*version)
+        end
+      end
+    end
+
+    # convert external dependencies into a requirements
+    if metadata['external_dependencies']
+      ##gemspec.requirements = [] unless metadata['external_dependencies'].empty?
+      metadata['external_dependencies'].each do |req|
+        gemspec.requirements << req.to_s
+      end
+    end
+
+    # determine homepage from resources
+    homepage = metadata['resources'].find{ |key, url| key =~ /^home/ }
+    gemspec.homepage = homepage.last if homepage
+
+    gemspec.require_paths        = metadata['load_path'] || ['lib']
+    gemspec.post_install_message = metadata['install_message']
+
+    # RubyGems specific metadata
+    gemspec.files       = files
+    gemspec.extensions  = extensions
+    gemspec.executables = executables
+
+    if Gem::VERSION < '1.7.'
+      gemspec.default_executable = gemspec.executables.first
+    end
+
+    gemspec.test_files = glob_files[patterns[:test_files]]
+
+    unless gemspec.files.include?('.document')
+      gemspec.extra_rdoc_files = glob_files[patterns[:doc_files]]
+    end
+  end
+end

data/lib/autoreload.rb

@@ -1,6 +1,7 @@
 require 'autoreload/version'
 require 'autoreload/reloader'
 
-def autoreload(*files)
-  AutoReload::Reloader.start(*files)
+# Reload features automatically at given intervals.
+def autoreload(options={}, &block)
+  AutoReload::Reloader.start(options, &block)
 end

data/lib/autoreload/reloader.rb

@@ -1,5 +1,4 @@
 require 'thread'
-require 'autoreload/lookup'
 
 module AutoReload
 
@@ -9,8 +8,8 @@ module AutoReload
   class Reloader
 
     # Shortcut for Reloader.new(*args).start.
-    def self.start(*args)
-      self.new(*args).start
+    def self.start(*args, &block)
+      self.new(*args, &block).start
     end
 
     # Default interval is one second.
@@ -20,31 +19,35 @@ module AutoReload
     #
     # === Options
     #
-    #   :interval - seconds betwee updates
+    #   :interval - seconds between updates
     #   :verbose  - true provides reload warning
     #   :reprime  - include $0 in reload list
     #
-    def initialize(*files)
-      options = Hash===files.last ? files.pop : {}
-
-      @files    = files.map{ |file| file.to_s } #Dir.glob(file) }.flatten.compact
-
+    def initialize(options={}, &block)
       @interval = options[:interval] || DEFAULT_INTERVAL
       @verbose  = options[:verbose]
       @reprime  = options[:reprime]
 
       @status   = {}
+
+      features = $".dup
+      if block
+        block.call
+        @files = ($" - features).reverse
+      else
+        @files = []
+      end
     end
 
     # Start the reload thread.
     def start
-      update # primate the path loads
+      update # prime the path loads
       @thread = Thread.new do
         loop do
           begin
             update
           rescue Exception
-            warn 'update failed: ' + $!
+            warn 'autoreload failed unexpectedly: ' + $!
           end
           sleep @interval
         end
@@ -74,14 +77,14 @@ module AutoReload
       @verbose || $VERBOSE
     end
 
-    # Is $0 in the reload list?
+    # Put $0 in the reload list?
     def reprime?
       @reprime
     end
 
   private
 
-    # List of library files to autoreload.
+    # The library files to autoreload.
     #--
     # ISSUE: Why include $0 ?
     #--
@@ -98,30 +101,41 @@ module AutoReload
       libraries.each{ |lib| check(lib) }
     end
 
-    # Check status and reload if out-of-date.
-    def check(lib)
-      if @status.key?(lib)
+    # We can't check mtime under 1.8 b/c $LOADED_FEATURES does not
+    # store the full path.
+    if RUBY_VERSION < '1.9'
+      def check(lib)
+        warn "reload: '#{lib}'" if verbose?
+        begin
+          load lib
+        rescue LoadError
+          # file has been removed
+        end
+      end
+    else
+      # Check status and reload if out-of-date.
+      def check(lib)
         file, mtime = @status[lib]
-
-        return unless file                   # file never was
-        return unless FileTest.exist?(file)  # file has disappered
-
-        curtime = File.mtime(file).to_i
-
-        if mtime < curtime
-          warn "reload: '#{file}'" if verbose?
-          load file
-          @status[lib] = [file, curtime]
+        if file
+          if FileTest.exist?(file)
+            curtime = File.mtime(file).to_i
+            if mtime < curtime
+              warn "reload: '#{file}'" if verbose?
+              load file
+              @status[lib] = [file, curtime]
+            end
+          else
+            # file has been removed
+          end
+        else
+          @status[lib] = get_status(lib)
         end
-      else
-        @status[lib] = get_status(lib)
       end
     end
 
     # Get library file status.
-    def get_status(lib)
-      file = Lookup.find(lib).first
-      if file #FileTest.exist?(file)
+    def get_status(file)
+      if FileTest.exist?(file)
         [file, File.mtime(file).to_i]
       else
         warn "reload fail: library '#{lib}' not found" if verbose?
@@ -135,5 +149,4 @@ module AutoReload
 
 end
 
-# Copyright (C) 2003,2007 Kouichirou Eto
-# Copyright (C) 2010 Thomas Sawyer
+# Copyright (C) 2010 Thomas Sawyer (BSD-2-Clause)