rave 0.1.1 → 0.1.2

data/bin/rave

@@ -1,24 +1,28 @@
-#!/usr/bin/env ruby
-
-here = File.dirname(__FILE__)
-%w( create server usage war ).each do |cmd|
-	require File.join(here, "..", "lib", "commands", cmd)
-end
-
-args = ARGV
-cmd = args.shift
-
-if cmd
-	case cmd
-	when "create"
-		create_robot(args)
-	when "server"
-		start_robot(args)
-	when "war"
-		create_war(args)
-	else
-		display_usage
-	end
-else
-	usage
+#!/usr/bin/env ruby
+
+here = File.dirname(__FILE__)
+%w( create server usage war appcfg ).each do |cmd|
+	require File.join(here, "..", "lib", "commands", cmd)
+end
+
+args = ARGV
+cmd = args.shift
+
+if cmd
+	case cmd
+	when "create"
+		create_robot(args)
+	when "server"
+		start_robot(args)
+	when "war"
+		create_war(args)
+	when "cleanup"
+	  cleanup_war(args)
+	when "appengine_deploy"
+	  appcfg_update(args)
+	else
+		display_usage
+	end
+else
+	display_usage
 end

data/lib/commands/appcfg.rb

@@ -0,0 +1,9 @@
+#Does an appcfg update to deploy the tmp/war folder to appengine
+def appcfg_update(args)
+  Rake.application.standard_exception_handling do
+    Rake.application.init
+    Rave::Task.new
+    task(:default => "rave:appcfg_update")
+    Rake.application.top_level
+  end
+end

data/lib/commands/create.rb

@@ -1,147 +1,153 @@
-require 'ftools'
-
-#Creates a project for a robot.  Args are:
-# => robot_name (required)
-# => image_url=http://imageurl.com/ (optional)
-# => profile_url=http://profileurl.com/ (optional)
-# e.g. rave my_robot image_url=http://appropriate-casey.appspot.com/image.png profile_url=http://appropriate-casey.appspot.com/profile.json
-def create_robot(args)
-  robot_name = args.first
-  module_name = robot_name.split(/_|-/).collect { |word| word[0, 1].upcase + word[1, word.length-1] }.join("")
-  robot_class_name = "#{module_name}::Robot"
-  options = { :name => robot_name }
-  args[1, args.length-1].each do |arg|
-    key, value = arg.split("=").collect { |part| part.strip }
-    options[key.to_sym] = value
-  end
-  dir = File.join(".", robot_name)
-  lib = File.join(dir, "lib")
-  config_dir = File.join(dir, "config")
-  file = File.join(dir, "robot.rb")
-  appengine_web = File.join(dir, "appengine-web.xml")
-  config = File.join(dir, "config.ru")
-  here = File.dirname(__FILE__)
-  jar_dir = File.join(here, "..", "jars")
-  jars = %w( appengine-api-1.0-sdk-1.2.1.jar jruby-core.jar ruby-stdlib.jar )
-  #Create the project dir
-  puts "Creating directory #{File.expand_path(dir)}"
-  Dir.mkdir(dir)
-  puts "Creating robot class #{File.expand_path(file)}"
-  #Make the base robot class
-  File.open(file, "w") do |f|
-    f.puts robot_file_contents(module_name)
-  end
-  #Make the rackup config file
-  puts "Creating rackup config file #{File.expand_path(config)}"
-  options_str = options.collect { |key, val| ":#{key} => \"#{val}\"" }.join(", ")
-  File.open(config, "w") do |f|
-    f.puts config_file_contents(robot_class_name, options_str)
-  end
-  #Make the appengine web xml file
-  puts "Creating appengine config file #{File.expand_path(appengine_web)}"
-  File.open(appengine_web, "w") do |f|
-    f.puts appengine_web_contents(robot_name)
-  end
-  #Copy jars over
-  puts "Creating lib directory #{File.expand_path(lib)}"
-  Dir.mkdir(lib)
-  jars.each do |jar|
-    puts "Adding jar #{jar}"
-    File.copy(File.join(jar_dir, jar), File.join(lib, jar))
-  end
-  #Make the wabler config file
-  puts "Creating config directory #{File.expand_path(config_dir)}"
-  Dir.mkdir(config_dir)
-  warble_file = File.join(config_dir, "warble.rb")
-  puts "Creating warble config file #{File.expand_path(warble_file)}"
-  File.open(warble_file, "w") do |f|
-    f.puts warble_config_contents()
-  end
-end
-
-def robot_file_contents(module_name)
-  <<-ROBOT
-require 'rubygems'
-require 'rave'
-
-module #{module_name}
-  class Robot < Rave::Models::Robot
-    
-    ME = "appropriate-casey@appspot.com"
-    
-    #Define handlers here:
-    # e.g. if the robot should act on a DOCUMENT_CHANGED event:
-    # 
-    # def document_changed(event, context)
-    #   #Do some stuff
-    # end
-    # 
-    # Events are: 
-    # 
-    # WAVELET_BLIP_CREATED, WAVELET_BLIP_REMOVED, WAVELET_PARTICIPANTS_CHANGED,
-    # WAVELET_TIMESTAMP_CHANGED, WAVELET_TITLE_CHANGED, WAVELET_VERSION_CHANGED,
-    # BLIP_CONTRIBUTORS_CHANGED, BLIP_DELETED, BLIP_SUBMITTED, BLIP_TIMESTAMP_CHANGED,
-    # BLIP_VERSION_CHANGED, DOCUMENT_CHANGED, FORM_BUTTON_CLICKED
-    #
-    # If you want to name your event handler something other than the default name, 
-    # or you need to have more than one handler for an event, you can register handlers
-    # in the robot's constructor:
-    #
-    # def initialize(options={})
-    #   super
-    #   register_handler(Rave::Models::Event::DOCUMENT_CHANGED, :custom_doc_changed_handler)
-    # end
-    # 
-    # def custom_doc_changed_handler(event, context)
-    #   #Do some stuff
-    # end
-    # 
-    # Note: Don't forget to call super if you define #initialize
-    
-  end
-end
-ROBOT
-end
-
-def config_file_contents(robot_class_name, options_str)
-  <<-CONFIG
-require 'robot'
-run #{robot_class_name}.new( #{options_str} )
-CONFIG
-end
-
-def appengine_web_contents(robot_name)
-  <<-APPENGINE
-<?xml version="1.0" encoding="utf-8"?>
-<appengine-web-app xmlns="http://appengine.google.com/ns/1.0">
-    <application>#{robot_name}</application>
-    <version>1</version>
-    <static-files />
-    <resource-files />
-    <sessions-enabled>false</sessions-enabled>
-    <system-properties>
-      <property name="jruby.management.enabled" value="false" />
-      <property name="os.arch" value="" />
-      <property name="jruby.compile.mode" value="JIT"/> <!-- JIT|FORCE|OFF -->
-      <property name="jruby.compile.fastest" value="true"/>
-      <property name="jruby.compile.frameless" value="true"/>
-      <property name="jruby.compile.positionless" value="true"/>
-      <property name="jruby.compile.threadless" value="false"/>
-      <property name="jruby.compile.fastops" value="false"/>
-      <property name="jruby.compile.fastcase" value="false"/>
-      <property name="jruby.compile.chainsize" value="500"/>
-      <property name="jruby.compile.lazyHandles" value="false"/>
-      <property name="jruby.compile.peephole" value="true"/>
-   </system-properties>
-</appengine-web-app>
-APPENGINE
-end
-
-def warble_config_contents
-  <<-WARBLE
-Warbler::Config.new do |config|
-  config.gems = %w( rave json-jruby rack builder )
-  config.includes = %w( robot.rb appengine-web.xml )
-end
-WARBLE
-end
+require 'ftools'
+
+#Creates a project for a robot.  Args are:
+# => robot_name (required)
+# => image_url=http://imageurl.com/icon.png (optional)
+# => profile_url=http://profileurl.com/ (optional)
+# e.g. rave my_robot image_url=http://appropriate-casey.appspot.com/image.png profile_url=http://appropriate-casey.appspot.com/profile.json
+def create_robot(args)
+  robot_name = args.first
+  module_name = robot_name.split(/_|-/).collect { |word| word.capitalize }.join
+  robot_class_name = "#{module_name}::Robot"
+  
+  options = { :name => robot_name, :version => 1, :id => "#{robot_name}@appspot.com" }
+  args[1, args.length-1].each do |arg|
+    key, value = arg.split("=").collect { |part| part.strip }
+    options[key.to_sym] = value
+  end
+
+  dir = File.join(".", robot_name)
+  if File.exist? dir
+    puts "Directory #{dir}/ already exists. Exiting..."
+    exit
+  end
+  
+  lib = File.join(dir, "lib")
+  config_dir = File.join(dir, "config")
+  file = File.join(dir, "robot.rb")
+  run = File.join(dir, "config.ru")
+  config = File.join(dir, "config.yaml")
+  public_folder = File.join(dir, "public")
+  html = File.join(public_folder, "index.html")
+  
+  #Create the project dir
+  puts "Creating directory #{File.expand_path(dir)}"
+  Dir.mkdir(dir)
+
+  puts "Creating robot class #{File.expand_path(file)}"
+  #Make the base robot class
+  File.open(file, "w") do |f|
+    f.puts robot_file_contents(module_name)
+  end
+
+  # Make the rackup run file.
+  puts "Creating rackup config file #{File.expand_path(run)}"
+  File.open(run, "w") do |f|
+    f.puts run_file_contents(robot_class_name, file)
+  end
+
+  # Make up the yaml config file.
+  puts "Creating configuration file #{File.expand_path(config)}"
+  File.open(config, "w") do |f|
+    f.puts config_file_contents(options)
+  end
+
+  #Make the public folder for static resources
+  puts "Creating public folder"
+  Dir.mkdir(public_folder)
+
+  # Make up the html index file.
+  puts "Creating html index file #{File.expand_path(html)}"
+  File.open(html, "w") do |f|
+    f.puts html_file_contents(robot_name, options[:id], options[:image_url])
+  end
+
+  #Create lib directory
+  puts "Creating lib directory #{File.expand_path(lib)}"
+  Dir.mkdir(lib)
+end
+
+def robot_file_contents(module_name)
+  <<-ROBOT
+require 'rubygems'
+require 'rave'
+
+module #{module_name}
+  class Robot < Rave::Models::Robot
+    #Define handlers here:
+    # e.g. if the robot should act on a DOCUMENT_CHANGED event:
+    # 
+    # def document_changed(event, context)
+    #   #Do some stuff
+    # end
+    # 
+    # Events are: 
+    # 
+    # WAVELET_BLIP_CREATED, WAVELET_BLIP_REMOVED, WAVELET_PARTICIPANTS_CHANGED,
+    # WAVELET_TIMESTAMP_CHANGED, WAVELET_TITLE_CHANGED, WAVELET_VERSION_CHANGED,
+    # BLIP_CONTRIBUTORS_CHANGED, BLIP_DELETED, BLIP_SUBMITTED, BLIP_TIMESTAMP_CHANGED,
+    # BLIP_VERSION_CHANGED, DOCUMENT_CHANGED, FORM_BUTTON_CLICKED
+    #
+    # If you want to name your event handler something other than the default name, 
+    # or you need to have more than one handler for an event, you can register handlers
+    # in the robot's constructor:
+    #
+    # def initialize(options={})
+    #   super
+    #   register_handler(Rave::Models::Event::DOCUMENT_CHANGED, :custom_doc_changed_handler)
+    # end
+    # 
+    # def custom_doc_changed_handler(event, context)
+    #   #Do some stuff
+    # end
+    # 
+    # Note: Don't forget to call super if you define #initialize
+    
+  end
+end
+ROBOT
+end
+
+def run_file_contents(robot_class_name, robot_file)
+  <<-CONFIG
+require '#{File.basename(robot_file).chomp(File.extname(robot_file))}'
+run #{robot_class_name}.instance
+CONFIG
+end
+
+def config_file_contents(options)
+  <<-CONFIG
+robot:
+  id: #{options[:id]}
+  name: #{options[:name]}
+  image_url: #{options[:image_url]}
+  profile_url: #{options[:profile_url]}
+  version: #{options[:version]}
+appcfg:
+  version: 1
+# Uncomment this section to add gems required by your robot.
+# They will unpacked in your project at appengine deploy time
+# gems:
+#  - some_gem         # Replace this with the name of the gem you require
+#  - some_other_gem   # Replace this with the name of the gem you require
+CONFIG
+end
+
+def html_file_contents(name, id, image_url)
+  img_tag = image_url ? "\n  <img src=\"#{image_url}\" alt=\"#{name} icon\" />\n" : ""
+  <<-HTML
+<html>
+<head>
+  <title>#{name}</title>
+</head>
+<body>
+  <h1>#{name}</h1>
+  #{img_tag}
+  <p>This is a Google Wave robot using <a href="http://github.com/diminish7/rave">Rave</a> running in JRuby.
+   Use this robot in your Google Waves by adding <em>#{id}</em> as a participant</p>
+
+  <img src="http://code.google.com/appengine/images/appengine-silver-120x30.gif" alt="Powered by Google App Engine" />
+</body>
+</html>
+HTML
+end

data/lib/commands/server.rb

@@ -1,8 +1,8 @@
-#Starts up rack based on the config.ru file in the working directory
-# Note that this is of limited use right now, because robots have to
-# run on appengine.  Better to test locally with the appengine sdk
-def start_robot(args)
-  cmd = (RUBY_PLATFORM == 'java') ? "jruby -S rackup" : "rackup"
-  cmd += " " + args.join(" ") if args
-  exec(cmd)
+#Starts up rack based on the config.ru file in the working directory
+# Note that this is of limited use right now, because robots have to
+# run on appengine.  Better to test locally with the appengine sdk
+def start_robot(args)
+  cmd = (RUBY_PLATFORM == 'java') ? "jruby -S rackup" : "rackup"
+  cmd += " " + args.join(" ") if args
+  exec(cmd)
 end

data/lib/commands/task.rb

@@ -0,0 +1,156 @@
+require 'rake'
+require 'rake/tasklib'
+require 'fileutils'
+require 'yaml'
+require 'warbler'
+
+module Rave
+  class Task < Warbler::Task
+    
+    REQUIRED_GEMS = ["rave", "json-jruby", "rack", "builder", "RedCloth"]
+    
+    def initialize
+      warbler_config = Warbler::Config.new do |config|
+        config.gems = ((robot_config['gems'] || []) + REQUIRED_GEMS).uniq
+        config.includes = %w( robot.rb config.yaml )
+      end
+      super(:rave, warbler_config)
+      define_post_war_processes
+      define_deploy_task
+    end
+    
+  private
+    
+    def robot_config
+      @robot_config ||= YAML::load(File.open(File.join(".", "config.yaml")))
+    end
+    
+    def define_post_war_processes
+      namespace :rave do
+        desc "Post-War cleanup"
+        task :create_war  => 'rave' do
+          #TODO: This needs to only run through this if the files have changed
+          #Get config info
+          web_inf = File.join(".", "tmp", "war", "WEB-INF")
+          rave_jars = File.join(File.dirname(__FILE__), "..", "jars")
+          #Cleanup unneeded gems that warbler copies in
+          cleanup_gems(File.join(web_inf, "gems", "gems"), robot_config['gems'] || [])
+          #Copy the appengine sdk jar to the robot
+          copy_appengine_jar_to_robot(rave_jars, File.join(web_inf, "lib"))
+          #Fix the broken paths in json-jruby
+          fix_json_jruby_paths(File.join(web_inf, "gems", "gems"))
+          #Add the appengine-web.xml file
+          robot_name = robot_config['robot']['id'].gsub(/@.+/, '')
+          version = robot_config['appcfg'] && robot_config['appcfg']['version'] ? robot_config['appcfg']['version'] : 1
+          create_appengine_web(File.join(web_inf, "appengine-web.xml"), robot_name, version)
+        end
+      end
+    end
+    
+    def define_deploy_task
+      namespace :rave do
+        desc "Deploy to Appengine"
+        task :appcfg_update => :create_war do
+          staging_folder = File.join(".", "tmp", "war")
+          sdk_path = find_sdk
+          if sdk_path
+            appcfg_jar = File.expand_path(File.join(sdk_path, 'lib', 'appengine-tools-api.jar'))
+            require appcfg_jar
+            Java::ComGoogleAppengineToolsAdmin::AppCfg.main(["update", staging_folder].to_java(:string))
+          else
+            puts "Unable to find the Google Appengine Java SDK"
+            puts "You can either"
+            puts "1. Define the path to the main SDK folder in config.yaml - e.g.:"
+            puts "appcfg:"
+            puts "  sdk: /usr/local/appengine-java-sdk/"
+            puts "2. Add the SDK bin folder to your PATH, or"
+            puts "3. Create an environment variable APPENGINE_JAVA_SDK that defines the path to the main SDK folder"
+          end
+        end
+      end
+    end
+    
+    #Remove warbler and jruby-jars - added by warbler but unneeded
+    def cleanup_gems(gem_dir, gems)
+      ["warbler", "jruby-jars"].each do |g|
+        dir = Dir[File.join(gem_dir, "#{g}*")].first
+        unless dir.nil? || gems.include?(g)
+          puts "Removing #{g} from war"
+          FileUtils.rm_rf(dir)
+        end
+      end
+    end
+    
+    def copy_appengine_jar_to_robot(rave_jar_dir, warbler_jar_dir)
+      jar = "appengine-api-1.0-sdk-1.3.0.jar"
+      rave_jar = File.join(rave_jar_dir, jar)
+      warbler_jar = File.join(warbler_jar_dir, jar)
+      puts "Copying appengine jar from #{rave_jar} to #{warbler_jar}"
+      File.copy(rave_jar, warbler_jar)
+    end
+
+    def fix_json_jruby_paths(web_inf_gems)
+      #TODO: Why is this necessary? Is this an appengine issue?
+      puts "Fixing paths in json-jruby"
+      ext = Dir[File.join(web_inf_gems, "json-jruby-*", "lib", "json", "ext.rb")].first
+      if ext
+        text = File.open(ext, "r") { |f| f.read }
+        text.gsub!("require 'json/ext/parser'", "require 'ext/parser'")
+        text.gsub!("require 'json/ext/generator'", "require 'ext/generator'")
+        File.open(ext, "w") { |f| f.write(text) }
+      end
+    end
+
+    def create_appengine_web(path, robot_name, version)
+      puts "Creating appengine config file #{File.expand_path(path)}"
+      File.open(path, "w") do |f|
+        f.puts appengine_web_contents(robot_name, version)
+      end
+    end
+
+    def appengine_web_contents(robot_name, version)
+      <<-APPENGINE
+<?xml version="1.0" encoding="utf-8"?>
+<appengine-web-app xmlns="http://appengine.google.com/ns/1.0">
+    <application>#{robot_name}</application>
+    <version>#{version}</version>
+    <static-files />
+    <resource-files />
+    <sessions-enabled>false</sessions-enabled>
+    <system-properties>
+      <property name="jruby.management.enabled" value="false" />
+      <property name="os.arch" value="" />
+      <property name="jruby.compile.mode" value="JIT"/> <!-- JIT|FORCE|OFF -->
+      <property name="jruby.compile.fastest" value="true"/>
+      <property name="jruby.compile.frameless" value="true"/>
+      <property name="jruby.compile.positionless" value="true"/>
+      <property name="jruby.compile.threadless" value="false"/>
+      <property name="jruby.compile.fastops" value="false"/>
+      <property name="jruby.compile.fastcase" value="false"/>
+      <property name="jruby.compile.chainsize" value="500"/>
+      <property name="jruby.compile.lazyHandles" value="false"/>
+      <property name="jruby.compile.peephole" value="true"/>
+   </system-properties>
+</appengine-web-app>
+APPENGINE
+    end
+    
+    def find_sdk
+      unless @sdk_path
+        @sdk_path = robot_config['appcfg']['sdk'] if robot_config['appcfg'] && robot_config['appcfg']['sdk'] # Points at main SDK dir.
+        @sdk_path ||= ENV['APPENGINE_JAVA_SDK'] # Points at main SDK dir.
+        unless @sdk_path
+          # Check everything in the PATH, which would point at the bin directory in the SDK.
+          ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+            if File.exists?(File.join(path, "appcfg.sh")) or File.exists?(File.join("appcfg.cmd"))
+              @sdk_path = File.dirname(path)
+              break
+            end
+          end
+        end
+      end
+      @sdk_path
+    end
+    
+  end
+end