appengine-tools 0.0.2 → 0.0.3

data/Rakefile

@@ -5,7 +5,7 @@ require 'date'
 require 'spec/rake/spectask'
 
 GEM = "appengine-tools"
-GEM_VERSION = "0.0.2"
+GEM_VERSION = "0.0.3"
 AUTHOR = "Ryan Brown"
 EMAIL = "ribrdb@gmail.com"
 HOMEPAGE = "http://code.google.com/p/appengine-jruby"

data/lib/appengine-tools/appcfg.rb

@@ -17,6 +17,7 @@
 require 'appengine-sdk'
 require 'appengine-tools/boot'
 require 'appengine-tools/bundler'
+require 'appengine-tools/update_check'
 require 'yaml'
 
 module AppEngine
@@ -26,6 +27,9 @@ module AppEngine
       import Java.ComGoogleAppengineToolsAdmin.AppAdminFactory 
       import Java.ComGoogleAppengineToolsAdmin.AppVersionUpload
       import Java.ComGoogleAppengineToolsUtil.Logging
+      import java.io.FileOutputStream
+      import java.util.jar.JarOutputStream
+      import java.util.zip.ZipEntry
     
       class JRubyAppVersionUpload < AppVersionUpload
         def initialize(connection, app)
@@ -88,12 +92,16 @@ EOF
             return
           end
           if command && ! NO_XML_COMMANDS.include?(command)
-            AppEngine::Admin.bundle_app(parsed_args[0])
-          end
-          if !RUBY_COMMANDS.include?(command)
-            puts "running AppCfg"
-            run_appcfg(args)
+            path = parsed_args[0]
+            AppEngine::Admin.bundle_app(path)
+            AppEngine::Development.boot_jruby
+            updater = AppEngine::Admin::UpdateCheck.new(path)
+            updater.nag
+          else
+            AppEngine::Development.boot_jruby              
           end
+          puts "running AppCfg"
+          run_appcfg(args)
         end
         
         def run_appcfg(args)
@@ -119,27 +127,33 @@ EOF
         end
         
         def gem(*args)
+          AppEngine::Admin.bundle_deps('.')
           AppEngine::Development.boot_jruby
+          puts "=> Running RubyGems"
           require 'rubygems'
           require 'rubygems/command_manager'
           Gem.configuration = Gem::ConfigFile.new(args)
           Gem.use_paths('.gems')
           Gem::Command.add_specific_extra_args(
               'install', %w(--no-rdoc --no-ri))
+          saved_gems = all_gem_specs
           begin
             Gem::CommandManager.instance.run(Gem.configuration.args)
           rescue Gem::SystemExitException => e
             exit e.exit_code unless e.exit_code == 0
           end
-          unless Dir.glob('.gems/specifications/*.gemspec').empty?
+          unless ((all_gem_specs == saved_gems) &&
+                  File.exist?('WEB-INF/lib/gems.jar'))
             Dir.mkdir 'WEB-INF' unless File.exists? 'WEB-INF'
             Dir.mkdir 'WEB-INF/lib' unless File.exists? 'WEB-INF/lib'
             Dir.chdir '.gems'
-            command = %w(jar cf ../WEB-INF/lib/gems.jar gems specifications)
-            if !system(*command)
-              puts 'Error running jar command.'
-              exit $?
+            puts '=> Packaging gems'
+            write_jar('../WEB-INF/lib/gems.jar') do |jar|
+              add_to_jar('gems', jar)
+              add_to_jar('specifications', jar)
             end
+            puts 'If you upgraded any gems, please run `appcfg.rb gem cleanup`'
+            puts 'to remove the old versions.'
           end
         end
         
@@ -154,7 +168,45 @@ Must be run from the application directory.
 EOF
         end
         
+        def all_gem_specs
+          Gem.source_index.map do |_, spec|
+            spec
+          end
+        end
+        
+        def write_jar(filename)
+          filename = File.expand_path(filename)
+          jar = JarOutputStream.new(FileOutputStream.new(filename))
+          begin
+            yield jar
+          ensure
+            jar.close
+          end
+        end
+        
+        def add_to_jar(path, jar)
+          directory = File.directory?(path)
+          if directory
+            path << '/'
+          end
+          entry = ZipEntry.new(path)
+          jar.put_next_entry(entry)
+          unless directory
+            data = IO.read(path)
+            jar.write(data.to_java_bytes, 0, data.size)
+          end
+          jar.close_entry
+          if directory
+            Dir.entries(path).each do |filename|
+              unless ['.', '..'].include?(filename)
+                add_to_jar(path + filename, jar)
+              end
+            end
+          end
+        end
+        
         def run(*args)
+          AppEngine::Admin.bundle_deps('.')
           AppEngine::Development.boot_app('.', args)
         end
         

data/lib/appengine-tools/boot.rb

@@ -20,7 +20,7 @@ module AppEngine
   module Development
     
     class << self
-      def boot_jruby(root=nil)
+      def boot_jruby(root=nil, options={})
         unless defined?(JRUBY_VERSION)
           require 'rubygems'
           require 'appengine-jruby-jars'
@@ -31,8 +31,19 @@ module AppEngine
             AppEngine::SDK::TOOLS_JAR,
             ]
 
+          args = options[:args] || ARGV
+          should_exec = options[:exec]
+          should_exec ||= should_exec.nil?
+
           ENV['GEM_HOME'] = Gem.dir
-          exec_jruby(root, jars, [$0] + ARGV)
+          ENV['GEM_PATH'] = Gem.path.compact.join(File::SEPARATOR)
+          appcfg = [File.expand_path(File.join(File.dirname($0),
+                                               'appcfg.rb'))]
+          if should_exec
+            exec_jruby(root, jars, appcfg + args)
+          else
+            run_jruby(root, jars, appcfg + args)
+          end
         end
       end
     
@@ -48,16 +59,28 @@ module AppEngine
         exec_jruby(root, jars, jruby_args)
       end
       
-      def exec_jruby(root, jars, args)
+      def build_command(root, jars, args)
         app_jars = root ? Dir.glob("#{root}/WEB-INF/lib/*.jar") : []
         classpath = (app_jars + jars).join(File::PATH_SEPARATOR)
         utf = "-Dfile.encoding=UTF-8"
-        java_command = %W(java #{utf} -cp #{classpath} org.jruby.Main) + args
+        command = %W(java #{utf} -cp #{classpath} org.jruby.Main) + args
         if ENV['VERBOSE']
-          puts java_command.map {|a| a.inspect}.join(' ')
+          puts command.map {|a| a.inspect}.join(' ')
         end
+        command
+      end
+      
+      def exec_jruby(root, jars, args)
+        java_command = build_command(root, jars, args)
         exec *java_command
       end
+      
+      def run_jruby(root, jars, args)
+        java_command = build_command(root, jars, args)
+        if !system(*java_command)
+          puts 'Error executing jruby'
+        end
+      end
     end
   end
 end

data/lib/appengine-tools/bundler.rb

@@ -16,6 +16,7 @@
 # limitations under the License.
 
 require 'appengine-rack'
+require 'appengine-tools/boot'
 require 'appengine-tools/web-xml'
 require 'appengine-tools/xml-formatter'
 require 'fileutils'
@@ -78,10 +79,10 @@ module AppEngine
     end
     
     class AppBundler
-      EXISTING_JRUBY = /^appengine-jruby-.*jar$/
+      EXISTING_JRUBY = /^(jruby-abridged|appengine-jruby)-.*jar$/
       EXISTING_RACK = /jruby-rack.*jar$/
       EXISTING_APIS = /^appengine-api.*jar$/
-      JRUBY_RACK = 'jruby-rack-0.9.4.jar'
+      JRUBY_RACK = 'jruby-rack-0.9.5.jar'
       JRUBY_RACK_URL = 'http://kenai.com/projects/jruby-rack/' +
                        "downloads/download/#{JRUBY_RACK}"
       RACKUP = %q{Dir.chdir('..') if Dir.pwd =~ /WEB-INF$/;} +
@@ -92,11 +93,15 @@ module AppEngine
       end
       
       def bundle
+        bundle_deps
+        convert_config_ru
+      end
+      
+      def bundle_deps
         create_webinf
         copy_jruby
         copy_rack
         copy_sdk
-        convert_config_ru
       end
       
       def app
@@ -117,7 +122,6 @@ module AppEngine
       end
       
       def convert_config_ru
-        AppEngine::Development.boot_jruby(app.root)
         if !File.exists?(app.config_ru)
           if File.exists?(app.web_xml)
             unless File.exists?(app.aeweb_xml)
@@ -137,22 +141,14 @@ module AppEngine
       end
       
       def copy_jruby
-        current_jruby = find_jars(EXISTING_JRUBY)
-        if current_jruby.empty?
-          puts "=> Installing JRuby"
-          require 'appengine-jruby-jars'
-          FileUtils.cp([AppEngine::JRubyJars.jruby_jar,
-                        AppEngine::JRubyJars.rubygems_jar],
-                       app.webinf_lib)
-        end
-        # TODO else warn if out of date
+        require 'appengine-jruby-jars'
+        update_jars(
+            "JRuby", EXISTING_JRUBY, [AppEngine::JRubyJars.jruby_jar],
+            /rubygems/, [AppEngine::JRubyJars.rubygems_jar])
       end
       
       def copy_rack
-        current_rack = find_jars(EXISTING_RACK)
-        if current_rack.empty?
-          # TODO cache this somewhere
-          puts "=> Retrieving jruby-rack"
+        update_jars('jruby-rack', EXISTING_RACK, [JRUBY_RACK]) do
           require 'open-uri'
           open(JRUBY_RACK_URL) do |src|
             open(File.join(app.webinf_lib, JRUBY_RACK), 'wb') do |dest|
@@ -163,15 +159,10 @@ module AppEngine
       end
       
       def copy_sdk
-        current_apis = find_jars(EXISTING_APIS)
-        if current_apis.empty?
-          puts "=> Installing appengine-sdk"
-          require 'appengine-sdk'
-          jars = Dir.glob(
-              "#{AppEngine::SDK::SDK_ROOT}/lib/user/appengine-api*.jar")
-          # TODO if there's more than 1 we need to check the api version.
-          FileUtils.cp(jars[0], app.webinf_lib)
-        end
+        require 'appengine-sdk'
+        glob = "appengine-api-1.0-sdk-*.jar"
+        jars = Dir.glob("#{AppEngine::SDK::SDK_ROOT}/lib/user/#{glob}")
+        update_jars('appengine-sdk', EXISTING_APIS, jars)
       end
       
       private
@@ -180,6 +171,40 @@ module AppEngine
         Dir.entries(app.webinf_lib).grep(regex) rescue []
       end
 
+      def update_jars(name, regex, jars, opt_regex=nil, opt_jars=[])
+        existing = find_jars(regex)
+        if existing.empty?
+          message = "Installing #{name}"
+          jars_to_install = jars + opt_jars
+        else
+          has_optional_jars = existing.any? {|j| j =~ opt_regex}
+          expected_jars = jars
+          expected_jars.concat(opt_jars) if has_optional_jars
+          expected = expected_jars.map {|path| File.basename(path)}
+          if existing.size != expected.size ||
+              (expected & existing) != expected
+            message = "Updating #{name}"
+            jars_to_install = expected_jars
+          end
+        end
+        if jars_to_install
+          puts message
+          remove_jars(existing)
+          if block_given?
+            yield
+          else
+            FileUtils.cp(jars_to_install, app.webinf_lib)
+          end
+        end
+      end
+
+      def remove_jars(jars)
+        paths = jars.map do |jar|
+          "#{app.webinf_lib}/#{jar}"
+        end
+        FileUtils.rm_f(paths)
+      end
+
       def valid_build
         return false unless File.exists? app.build_status
         return false unless File.exists? app.web_xml
@@ -193,41 +218,51 @@ module AppEngine
       end
 
       def generate_xml
-        return if valid_build 
-        puts "=> Generating configuration files"
-        Dir.glob("#{app.webinf_lib}/*.jar").each do |path|
-          $: << path
-        end
-        app_root = app.root
-        builder = WebXmlBuilder.new do
-          # First configure the basic jruby-rack settings.
-          add_jruby_rack_defaults(RACKUP)
+        return if valid_build
+        if defined? JRUBY_VERSION
+          puts "=> Generating configuration files"
+          Dir.glob("#{app.webinf_lib}/*.jar").each do |path|
+            $: << path
+          end
+          app_root = app.root
+          builder = WebXmlBuilder.new do
+            # First configure the basic jruby-rack settings.
+            add_jruby_rack_defaults(RACKUP)
 
-          # Now read the user's rackup file
-          # TODO generate a skeleton if it's missing
-          Dir.chdir(app_root) do
-            eval IO.read('config.ru'), nil, 'config.ru', 1
+            # Now read the user's rackup file
+            # TODO generate a skeleton if it's missing
+            Dir.chdir(app_root) do
+              eval IO.read('config.ru'), nil, 'config.ru', 1
+            end
           end
+          open(app.web_xml, 'w') do |webxml|
+            xml = AppEngine::Rack::XmlFormatter.format(builder.to_xml)
+            webxml.write(xml)
+          end
+          open(app.aeweb_xml, 'w') do |aeweb|
+            xml = AppEngine::Rack::XmlFormatter.format(app.rack_app.to_xml)
+            aeweb.write(xml)
+          end
+          yaml = {
+              :config_ru => File.stat(app.config_ru).mtime,
+              :aeweb_xml => File.stat(app.aeweb_xml).mtime,
+              :web_xml   => File.stat(app.web_xml).mtime }
+          open(app.build_status, 'w') { |f| YAML.dump(yaml, f) }
+        else
+          AppEngine::Development.boot_jruby(app.root,
+                                            :args => ['bundle', app.root],
+                                            :exec => false)
         end
-        open(app.web_xml, 'w') do |webxml|
-          xml = AppEngine::Rack::XmlFormatter.format(builder.to_xml)
-          webxml.write(xml)
-        end
-        open(app.aeweb_xml, 'w') do |aeweb|
-          xml = AppEngine::Rack::XmlFormatter.format(app.rack_app.to_xml)
-          aeweb.write(xml)
-        end
-        yaml = {
-            :config_ru => File.stat(app.config_ru).mtime,
-            :aeweb_xml => File.stat(app.aeweb_xml).mtime,
-            :web_xml   => File.stat(app.web_xml).mtime }
-        open(app.build_status, 'w') { |f| YAML.dump(yaml, f) } 
       end
     end
 
     def self.bundle_app(root_path)
       AppBundler.new(root_path).bundle
     end
+    
+    def self.bundle_deps(root_path)
+      AppBundler.new(root_path).bundle_deps
+    end
 
   end
 end

data/lib/appengine-tools/dev_appserver.rb

@@ -17,29 +17,65 @@
 require 'appengine-sdk'
 require 'appengine-tools/boot'
 require 'appengine-tools/bundler'
+require 'appengine-tools/update_check'
 
 module AppEngine
   module Development
-    DEV_APPSERVER = 'com.google.appengine.tools.development.DevAppServerMain'
+    DEV_APPSERVER = ['com.google.appengine.tools.development.DevAppServerMain']
     class JRubyDevAppserver
       class << self
         def run(args)
-          path = args[-1] || '.'
-          if args.length > 0 and File::directory?(args[-1])
-            unless ENV['BOOTING_DEVAPPSERVER']
-              puts  "=> Booting DevAppServer"
-              puts  "=> Press Ctrl-C to shutdown server"
-              ENV['BOOTING_DEVAPPSERVER'] = 'true'
-            end
+          path, java_args, server_args = parse_argv(ARGV)
+          if path and File::directory?(path)
+            puts  "=> Booting DevAppServer"
+            puts  "=> Press Ctrl-C to shutdown server"
             AppEngine::Admin.bundle_app(path)
+            updater = AppEngine::Admin::UpdateCheck.new(path)
+            updater.nag if updater.can_nag?
+          end
+          start_java(path, java_args, server_args)
+        end
+        
+        def parse_argv(argv)
+          java_args = []
+          server_args = ['--disable_update_check']
+          start_on_first_thread = false
+          if RUBY_PLATFORM =~ /darwin/ ||
+             (RUBY_PLATFORM == 'java' &&
+              java.lang.System.getProperty("os.name").downcase == "mac os x")
+            start_on_first_thread = true
+          end
+          argv.each do |arg|
+            if arg =~ /^--jvm_flag=(.+)/
+              java_args << $1
+            elsif arg =~ /--startOnFirstThread=(true|false)/
+              start_on_first_thread = ($1 == "true")
+            else
+              server_args << arg
+            end
+          end
+          if start_on_first_thread
+            java_args << '-XstartOnFirstThread'
+          end
+          return server_args[-1], java_args, server_args
+        end
+        
+        def start_java(path, java_args, server_args)
+          if path
+            jruby_home = get_jruby_home(path)
+            java_args << "-Djruby.home=#{jruby_home}" if jruby_home
+            server_args[-1] = File.expand_path(path)
+            Dir.chdir(path)
           end
-          AppEngine::Development.boot_jruby
-          args.unshift(DEV_APPSERVER)
-          jruby_home = get_jruby_home(args[-1])
-          if jruby_home
-            args.unshift("--jvm_flag=-Djruby.home=#{jruby_home}")
+          ENV.delete 'GEM_HOME'
+          ENV.delete 'GEM_PATH'
+          java_args << '-classpath'
+          java_args << AppEngine::SDK::TOOLS_JAR
+          command = ['java'] + java_args + DEV_APPSERVER + server_args
+          if ENV['VERBOSE']
+            puts "exec #{command.map{|x| x.inspect}.join(' ')}"
           end
-          AppEngine::SDK.load_kickstart.main(args.to_java(:string))
+          exec(*command)
         end
         
         def get_jruby_home(path)

data/lib/appengine-tools/update_check.rb

@@ -0,0 +1,118 @@
+#!/usr/bin/ruby1.8 -w
+#
+# Copyright:: Copyright 2009 Google Inc.
+# Original Author:: Ryan Brown (mailto:ribrdb@google.com)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'yaml'
+require 'open-uri'
+begin
+  require 'google-appengine'
+rescue LoadError
+end
+require 'rubygems/version'
+
+module AppEngine
+  module Admin
+    class UpdateCheck
+      NAG_FILE = "~/.appcfg_rb_nag"
+      MAX_NAG_FREQUENCY = 60 * 60 * 24 * 7
+      DEFAULT_URL = 'http://appengine-jruby.googlecode.com/hg/updatecheck'
+      
+      def initialize(approot, url=nil, nag_file=nil)
+        @url = url || DEFAULT_URL
+        @approot = approot
+        @nag_file = nag_file || File.expand_path(NAG_FILE)
+      end
+      
+      def local_versions
+        sdk_version = Gem::Version.new(AppEngine::VERSION) rescue nil
+        {
+          'google-appengine' => sdk_version,
+          'appengine-apis' => find_gem_version('appengine-apis'),
+          'dm-appengine' => find_gem_version('dm-appengine'),
+        }
+      end
+      
+      def find_gem_version(name)
+        specs = Dir.glob("#{@approot}/.gems/specifications/#{name}-*.gemspec")
+        versions = specs.map do |filename|
+          if filename =~ /-(\w+\.\w+.\w+).gemspec$/
+            Gem::Version.new($1)
+          end
+        end
+        versions.sort[-1]
+      end
+      
+      def remote_versions
+        versions = YAML.load(open(@url).read)
+        versions.inject({}) do |versions, (name, version)|
+          versions[name] = Gem::Version.new(version)
+          versions
+        end
+      end
+
+      def check_for_updates
+        local = local_versions
+        unless local['google-appengine']
+          puts 'Skipping update check'
+          return
+        end
+        latest = remote_versions
+        local.each do |name, version|
+          current = latest[name]
+          if version && version < current
+            prefix = if name == 'google-appengine'
+              "sudo"
+            else
+              "appcfg.rb"
+            end
+            puts "There is a new version of #{name}: #{current} " +
+                "(You have #{version})"
+            puts "Please run #{prefix} gem update #{name}."
+          end
+        end
+      end
+      
+      def parse_nag_file
+        @nag ||= if File.exist?(@nag_file)
+          YAML.load_file(@nag_file)
+        else
+          {'opt_in' => true, 'timestamp' => 0}
+        end
+      end
+      
+      def write_nag_file(options)
+        open(@nag_file, 'w') do |file|
+          file.write(YAML.dump(options))
+        end
+      end
+      
+      def nag
+        nag = parse_nag_file
+        return if Time.now.to_i - nag['timestamp'] < MAX_NAG_FREQUENCY
+        check_for_updates
+        nag['timestamp'] = Time.now.to_i
+        write_nag_file(nag)
+      rescue OpenURI::HTTPError, Errno::ENOENT
+        # check_for_updates will raise an error if we're not online
+        # just ignore it, and don't update the nag timestamp.
+      end
+      
+      def can_nag?
+        parse_nag_file['opt_in']
+      end
+    end
+  end
+end

data/spec/appengine-web.xml

@@ -2,11 +2,18 @@
   <application>tools-test</application>
   <version>foo</version>
   <public-root>/public</public-root>
-  <static-files/>
+  <static-files>
+    <include expiration='365d' path='/public/images/**'/>
+    <include path='/public/**'/>
+  </static-files>
   <resource-files/>
   <system-properties>
     <property name='os.arch' value=''/>
     <property name='jruby.management.enabled' value='false'/>
+    <property name='jruby.rack.input.rewindable' value='false'/>
   </system-properties>
   <ssl-enabled>true</ssl-enabled>
+  <inbound-services>
+    <service>xmpp_message</service>
+  </inbound-services>
 </appengine-web-app>

data/spec/config.ru

@@ -2,6 +2,9 @@ require 'appengine-rack'
 
 AppEngine::Rack.configure_app(
   :application => 'tools-test', :version => 'foo', :ssl_enabled => true)
+AppEngine::Rack.app.inbound_services << :xmpp_message
+AppEngine::Rack.app.static_files.include('/public/images/**', '365d')
+AppEngine::Rack.app.static_files.include('/public/**')
 
 ruby_app = lambda {|env| [200, {}, "Hello Rack!"]}
 

data/spec/update_check_spec.rb

@@ -0,0 +1,176 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+require 'appengine-tools/update_check'
+require 'stringio'
+
+module AppEngine
+  VERSION = "3.2.1"
+end
+
+describe AppEngine::Admin::UpdateCheck do
+  before :each do
+    @update_check = AppEngine::Admin::UpdateCheck.new('approot', 'url', 'nag')
+  end
+  
+  def versions(sdk, apis, dm)
+    keys = ['google-appengine', 'appengine-apis', 'dm-appengine']
+    hash = {}
+    keys.zip([sdk, apis, dm]) do |key, value|
+      hash[key] = value && Gem::Version.new(value)
+    end
+    hash
+  end
+  
+  it 'should expand path' do
+    File.should_receive(:expand_path).with(
+        AppEngine::Admin::UpdateCheck::NAG_FILE)
+    uc = AppEngine::Admin::UpdateCheck.new('/')
+  end
+  
+  it 'should support local_versions' do
+    expected = versions('3.2.1', '1.2.3', nil)
+    @update_check.should_receive(:find_gem_version).twice.and_return(
+        Gem::Version.new("1.2.3"), nil)
+    @update_check.local_versions.should == expected
+  end
+  
+  it 'should support find_gem_version' do
+    Dir.should_receive(:glob).and_return(
+        ['appengine-apis-0.0.20.gemspec','appengine-apis-0.0.3.gemspec'])
+    @update_check.find_gem_version("appengine-apis").should ==
+        Gem::Version.new('0.0.20')
+  end
+  
+  it 'should support remote_versions' do
+    expected = versions('3.2.2', '1.2.4', '2.3.4')
+    io = StringIO.new(YAML.dump(expected))
+    @update_check.stub!(:open)
+    @update_check.should_receive(:open).with("url").and_return(io)
+    @update_check.remote_versions.should == expected
+  end
+  
+  describe 'check_for_updates' do
+    before :each do
+      @update_check.stub!(:puts)
+    end
+    
+    
+    def expect_puts(*messages)
+      length = messages.length
+      @update_check.should_receive(:puts) do |arg|
+        arg.should == messages.shift
+      end.exactly(length).times
+    end
+
+    it 'should skip check if no sdk version' do
+      @update_check.should_receive(:local_versions).and_return(
+          versions(nil, nil, nil))
+      expect_puts("Skipping update check")
+      @update_check.check_for_updates
+    end
+    
+    it 'should warn about old sdk' do
+      @update_check.should_receive(:local_versions).and_return(
+        versions('0.0.1', nil, nil))
+      @update_check.should_receive(:remote_versions).and_return(
+        versions('0.0.2', '0.0.2', '0.0.2'))
+      expect_puts(
+        "There is a new version of google-appengine: 0.0.2 (You have 0.0.1)",
+        "Please run sudo gem update google-appengine."
+      )
+      @update_check.check_for_updates
+    end
+    
+    it 'should warn about old apis' do
+      @update_check.should_receive(:local_versions).and_return(
+        versions('0.0.2', '0.0.2', '0.0.2'))
+      @update_check.should_receive(:remote_versions).and_return(
+        versions('0.0.2', '0.0.4', '0.0.2'))
+      expect_puts(
+        "There is a new version of appengine-apis: 0.0.4 (You have 0.0.2)",
+        "Please run appcfg.rb gem update appengine-apis."
+      )
+      @update_check.check_for_updates
+    end
+    
+    it 'should warn about old dm adapter' do
+      @update_check.should_receive(:local_versions).and_return(
+        versions('0.0.2', '0.0.2', '0.0.2'))
+      @update_check.should_receive(:remote_versions).and_return(
+        versions('0.0.2', '0.0.2', '0.0.3'))
+      expect_puts(
+        "There is a new version of dm-appengine: 0.0.3 (You have 0.0.2)",
+        "Please run appcfg.rb gem update dm-appengine."
+      )
+      @update_check.check_for_updates      
+    end
+
+    
+    it 'should warn about multiple old gems' do
+      @update_check.should_receive(:local_versions).and_return(
+        versions('0.0.1', '0.0.3', '0.0.5'))
+      @update_check.should_receive(:remote_versions).and_return(
+        versions('0.0.2', '0.0.4', '0.0.5'))
+      expect_puts(
+        "There is a new version of google-appengine: 0.0.2 (You have 0.0.1)",
+        "Please run sudo gem update google-appengine.",
+        "There is a new version of appengine-apis: 0.0.4 (You have 0.0.3)",
+        "Please run appcfg.rb gem update appengine-apis."
+      )
+      @update_check.check_for_updates      
+    end
+  end
+  
+  describe 'parse_nag_file' do
+    it 'should support missing file' do
+      File.should_receive(:exist?).with('nag').and_return(false)
+      @update_check.parse_nag_file.should == {
+        'opt_in' => true,
+        'timestamp' => 0
+      }
+    end
+    
+    it 'should parse existing file' do
+      File.should_receive(:exist?).with('nag').and_return(true)
+      YAML.should_receive(:load_file).with('nag').and_return("parsed_yaml")
+      @update_check.parse_nag_file.should == "parsed_yaml"
+    end
+  end
+  
+  describe 'nag' do
+    it 'should nag if old timestamp' do
+      @update_check.should_receive(:parse_nag_file).and_return({
+        'opt_in' => true,
+        'timestamp' => Time.now.to_i - (60 * 60 * 24 * 8)
+      })
+      @update_check.should_receive(:check_for_updates)
+      @update_check.should_receive(:write_nag_file)
+      @update_check.nag
+    end
+    
+    it 'should not nag if new timestamp' do
+      @update_check.should_receive(:parse_nag_file).and_return({
+        'opt_in' => true,
+        'timestamp' => Time.now.to_i - (60 * 60 * 24 * 6)
+      })
+      @update_check.nag
+    end
+  end
+  
+  describe 'can_nag?' do
+    it 'should return true of opted in' do
+      @update_check.should_receive(:parse_nag_file).and_return({
+        'opt_in' => true,
+        'timestamp' => Time.now.to_i
+      })
+      @update_check.can_nag?.should == true
+    end
+
+    it 'should return false of opted out' do
+      @update_check.should_receive(:parse_nag_file).and_return({
+        'opt_in' => false,
+        'timestamp' => Time.now.to_i
+      })
+      @update_check.can_nag?.should == false
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: appengine-tools
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - Ryan Brown
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-13 00:00:00 -07:00
+date: 2009-09-03 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -60,6 +60,7 @@ files:
 - lib/appengine-tools/boot.rb
 - lib/appengine-tools/bundler.rb
 - lib/appengine-tools/dev_appserver.rb
+- lib/appengine-tools/update_check.rb
 - lib/appengine-tools/web-xml.rb
 - lib/appengine-tools/xml-formatter.rb
 - spec/appengine-web.xml
@@ -67,6 +68,7 @@ files:
 - spec/rack_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
+- spec/update_check_spec.rb
 - spec/web-xml_spec.rb
 - spec/web.xml
 has_rdoc: true