autoreload 0.0.1 → 0.2.0

data/HISTORY

@@ -0,0 +1,14 @@
+= RELEASE HISTORY
+
+== 0.2.0 2010-05-10
+
+* Completely reworked API.
+
+== 0.1.0 2010-05-01
+
+* Same as original, but now a RubyWorks project.
+
+== 0.0.1 2007-07-01
+
+* Initial release
+

data/PROFILE

@@ -0,0 +1,20 @@
+--- 
+title  : Autoreload
+summary: Automatically reload library files
+license: MIT 
+contact: rubyworks-mailinglist@googlegroups.com
+suite  : rubyworks
+created: 2007-07-01
+
+authors:
+  - Kouichirou Eto
+  - Thomas Sawyer
+
+description:
+  Autoreload automatically reloads library files when they have been
+  updated. It is especailly useful when testing stateless services
+  such as web applications.
+
+resources:
+  homepage  : http://rubyworks.github.com/autoreload
+  repository: http://github.com/rubyworks/autoreload

data/README.rdoc

@@ -0,0 +1,42 @@
+= Autoreload
+
+* home: http://rubyworks.github.com/autoreload
+* work: http://github.com/rubyworks/autoreload
+
+
+== DESCRIPTION
+
+Autoreload automatically reloads library files when they have been
+updated. It is especailly useful when testing stateless services
+such as web applications.
+
+
+== HOW TO USE
+
+Say we have a library <tt>foo.rb</tt> in our load path:
+
+  def foo
+    1
+  end
+
+We can then run the following script, <tt>example.rb</tt>:
+
+  require 'autoreload'
+  require 'foo'
+
+  autoreload('foo.rb', :interval=>2, :verbose=>true)
+
+  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.
+
+
+== COPYRIGHT
+
+Copyright (c) 2007 Kouichirou Eto
+
+Copyright (c) 2010 Thomas Sawyer

data/VERSION

@@ -0,0 +1,5 @@
+name : autoreload
+major: 0
+minor: 2
+patch: 0
+date : 2010-05-10

data/lib/autoreload.rb

@@ -1,100 +1,9 @@
-# Copyright (C) 2003-2007 Kouichirou Eto, All rights reserved.
-# License: Ruby License
-
-require 'thread'
-
-module AutoReload #:nodoc:
-  module VERSION #:nodoc:
-    MAJOR = 0
-    MINOR = 0
-    TINY  = 1
-    STRING = [MAJOR, MINOR, TINY].join('.')
-  end
-
-  class Reloader
-    def self.start(*a)
-      self.new(*a).start
-    end
-
-    DEFAULT_INTERVAL = 1
-
-    def initialize(interval = DEFAULT_INTERVAL,
-		   verbose = false, name = nil) #:nodoc:
-      @interval = interval
-      @verbose = verbose
-      @name = name
-      @status = {}
-      @thread = nil
-    end
-
-    def start #:nodoc:
-      @thread = Thread.new {
-	loop {
-	  begin
-	    update
-	  rescue Exception
-	    warn 'update failed: ' + $!
-	  end
-	  sleep @interval
-	}
-      }
-      @thread.abort_on_exception = true
-    end
-
-    private
-
-    def warn(msg, out = $stderr)
-      msg = "#{@name}: #{msg}" if @name
-      out << msg + "\n"
-      # $stderr.puts()
-    end
-
-    def update
-      libs = [$0] + $"
-      libs.each {|lib|
-	check_lib(lib)
-      }
-    end
-
-    def check_lib(lib)
-      if @status[lib]
-	file, mtime = @status[lib]
-	return if ! FileTest.exist?(file) # file is disappered.
-	curtime = File.mtime(file).to_i
-	if mtime < curtime
-	  if @verbose
-	    warn "reload: '#{file}'"
-	  end
-	  load file	# Load it.
-	  @status[lib] = [file, curtime]
-	end
-	return
-      end
-
-      check_path = [''] + $LOAD_PATH
-      #check_path = ['']
-      check_path.each {|path|
-	file = File.join(path, lib)
-	file = lib if path.empty?	# Check if the lib is a filename.
-	if FileTest.exist?(file)
-	  @status[lib] = [file, File.mtime(file).to_i]
-	  return 
-	end
-      }
-
-      #raise "The library '#{lib}' is not found."
-      # $stdout.puts(message("The library '#{lib}' is not found.")) if @verbose
-    end
-
-    def get_status(file)
-      if FileTest.exist?(file)
-	return [file, File.mtime(file).to_i]
-      end
-      return nil
-    end
-  end
-end
-
-def autoreload(*a)
-  AutoReload::Reloader.start(*a)
+require 'autoreload/reloader'
+
+module AutoReload
+  # TODO: version constant
+end
+
+def autoreload(*files)
+  AutoReload::Reloader.start(*files)
 end

data/lib/autoreload/lookup.rb

@@ -0,0 +1,90 @@
+module AutoReload
+
+  # = Library Lookup
+  #
+  # This library is a slightly modified copy of the +plugin+ library.
+  #
+  module Lookup
+
+    extend self
+
+    # Find plugins, searching through standard $LOAD_PATH,
+    # Roll Libraries and RubyGems.
+    #
+    # Provide a +match+ file glob to find plugins.
+    #
+    #   Lookup.find('syckle/*')
+    #
+    def find(match, options={})
+      plugins = []
+      plugins.concat find_roll(match, options)
+      plugins.concat find_loadpath(match, options)
+      plugins.concat find_gems(match, options)
+      plugins.uniq
+    end
+
+    # Shortcut for #find.
+    #
+    #   Lookup['syckle/*']
+    #
+    alias_method :[], :find
+
+    # Search roll for current or latest libraries.
+    def find_roll(match, options={})
+      plugins = []
+      #directory = options[:directory] || DIRECTORY
+      if defined?(::Roll)
+        ::Roll::Library.ledger.each do |name, lib|
+          lib = lib.sort.first if Array===lib
+          lib.loadpath.each do |path|
+            #find = File.join(lib.location, path, directory, match)
+            find = File.join(lib.location, path, match)
+            list = Dir.glob(find)
+            list = list.map{ |d| d.chomp('/') }
+            plugins.concat(list)
+          end
+        end
+      end
+      plugins
+    end
+
+    # Search standard $LOAD_PATH.
+    #
+    # Activated gem versions are in here too.
+
+    def find_loadpath(match, options={})
+      plugins = []
+      #directory = options[:directory] || DIRECTORY
+      $LOAD_PATH.uniq.each do |path|
+        path = File.expand_path(path)
+        #list = Dir.glob(File.join(path, directory, match))
+        list = Dir.glob(File.join(path, match))
+        list = list.map{ |d| d.chomp('/') }
+        plugins.concat(list)
+      end
+      plugins
+    end
+
+    # Search latest gem versions.
+    #
+    # TODO: Is there anyway to skip active gems?
+
+    def find_gems(match, options={})
+      plugins = []
+      #directory = options[:directory] || DIRECTORY
+      if defined?(::Gem)
+        ::Gem.latest_load_paths do |path|
+          #list = Dir.glob(File.join(path, directory, match))
+          list = Dir.glob(File.join(path, match))
+          list = list.map{ |d| d.chomp('/') }
+          plugins.concat(list)
+        end
+      end
+      plugins
+    end
+
+  end
+
+end
+
+# Copyright (C) 2010 Thomas Sawyer

data/lib/autoreload/reloader.rb

@@ -0,0 +1,140 @@
+require 'thread'
+require 'autoreload/lookup'
+
+module AutoReload
+
+  # Reload class does all the heavy lifting
+  # for AutoReload library.
+  #
+  class Reloader
+
+    # Shortcut for Reloader.new(*args).start.
+    def self.start(*args)
+      self.new(*args).start
+    end
+
+    # Default interval is one second.
+    DEFAULT_INTERVAL = 1
+
+    # New Reloader.
+    #
+    # === Options
+    #
+    #   :interval - seconds betwee 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
+
+      @interval = options[:interval] || DEFAULT_INTERVAL
+      @verbose  = options[:verbose]
+      @reprime  = options[:reprime]
+
+      @status   = {}
+    end
+
+    # Start the reload thread.
+    def start
+      update # primate the path loads
+      @thread = Thread.new do
+        loop do
+          begin
+            update
+          rescue Exception
+            warn 'update failed: ' + $!
+          end
+          sleep @interval
+        end
+      end
+      @thread.abort_on_exception = true
+    end
+
+    # Kills the autoreload thread.
+    def stop
+      @thread.kill if @thread
+    end
+
+    #
+    attr :thread
+
+    # List of files provided to autoreload.
+    attr :files
+
+    # Status hash, used to track reloads.
+    attr :status
+
+    # The periodic interval of reload.
+    attr :interval
+
+    # Provide warning on reload.
+    def verbose?
+      @verbose || $VERBOSE
+    end
+
+    # Is $0 in the reload list?
+    def reprime?
+      @reprime
+    end
+
+  private
+
+    # List of library files to autoreload.
+    #--
+    # ISSUE: Why include $0 ?
+    #--
+    def libraries
+      if @files.empty?
+        @reprime ? [$0] + $" : $"
+      else
+        @files
+      end
+    end
+
+    # Iterate through all selection library files and reload if needed.
+    def update
+      libraries.each{ |lib| check(lib) }
+    end
+
+    # Check status and reload if out-of-date.
+    def check(lib)
+      if @status.key?(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]
+        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)
+        [file, File.mtime(file).to_i]
+      else
+        warn "reload fail: library '#{lib}' not found" if verbose?
+        #raise "The library '#{lib}' is not found."
+        #$stdout.puts(message("The library '#{lib}' is not found.")) if @verbose
+        [nil, nil]
+      end
+    end
+
+  end
+
+end
+
+# Copyright (C) 2003,2007 Kouichirou Eto
+# Copyright (C) 2010 Thomas Sawyer
+

data/test/test_autoreload.rb

@@ -17,43 +17,43 @@ module AutoReload
   end
 end
 
-class TestAutoReload < Test::Unit::TestCase
-  def test_autoreload
-    #autoreload(1, true, 'test_autoreload')
-    autoreload(1)
+class TestAutoReload < Test::Unit::TestCase
 
+  def test_autoreload
     # create a library
     dir = Pathname.new(__FILE__).dirname
     library = dir + 'tmp_library.rb'
     library.write 'def foo; 1; end'
+
+    autoreload(library, :interval => 1) #, :verbose=>true)
 
     # require it
-    require library
-    assert_equal 1, foo
+    require library
+
+    assert_equal(1, foo)
 
-    sleep 2	# wait is necessary.
-    # If not, the time stamp will be same with the next file.
+    sleep 2	# wait is needed for time stamp to not be same with the next file.
 
     # recreate the file
     library.write 'def foo; 2; end'
 
-    sleep 2	# wait again. wait for the autoreload will be started.
+    sleep 2	# wait again for the autoreload loop to repeat.
 
     # check the number again.
-    assert_equal 2, foo
+    assert_equal(2, foo)
 
-    # clean it
+    # clean up
     library.unlink
-    assert_equal false, library.exist?
+    assert_equal(false, library.exist?)
   end
 
-  # ruby -w -Ilib test/test_autoreload.rb -n test_all
-  def test_all
-    rel = AutoReload::Reloader.new
-
-    # test_warn
-    str = ''
-    rel.warn("a", str)
-    assert_equal "a\n", str
-  end
+  ## ruby -w -Ilib test/test_autoreload.rb -n test_all
+  #def test_all
+  #  rel = AutoReload::Reloader.new
+  #
+  #  # test_warn
+  #  str = ''
+  #  rel.warn("a", str)
+  #  assert_equal "a\n", str
+  #end
 end