rave 0.1.2-java

data/bin/rave

@@ -0,0 +1,28 @@
+#!/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

@@ -0,0 +1,153 @@
+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

@@ -0,0 +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)
+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

data/lib/commands/usage.rb

@@ -0,0 +1,19 @@
+#Display usage for rave command
+def display_usage
+  puts "Useage: rave [create | server | war] [robot_name] [options]"
+  puts "'create' generates a Google Wave robot client stub application."
+  puts "e.g."
+  puts "rave create my_robot image_url=http://my_robot.appspot.com/image.png profile_url=http://my_robot.appspot.com/"
+  puts "'server' launches the robot"
+  puts "e.g."
+  puts "rave server"
+  puts "'war' creates a war file suitable for deploying to Google AppEngine"
+  puts "e.g."
+  puts "rave war"
+  puts "'appengine_deploy' deploys the tmp/war folder to Google AppEngine"
+  puts "e.g."
+  puts "rave appengine_deploy"
+  puts "'cleanup' removes the .war file and the tmp/war staging directory"
+  puts "e.g."
+  puts "rave cleanup"
+end

data/lib/commands/war.rb

@@ -0,0 +1,28 @@
+require 'rubygems'
+require 'rake'
+require File.join(File.dirname(__FILE__), 'task.rb')
+
+#Runs warbler to package up the robot
+# then does some cleanup that is specific to App Engine:
+# => Deletes the complete JRuby jar from both the app's lib folder and
+#    the frozen warbler gem, and replaces them with a broken up version
+# => Changes the file path json-jruby 
+#    TODO: Not sure why this is necessary, but it doesn't run on appengine without it
+def create_war(args)
+  Rake.application.standard_exception_handling do
+    Rake.application.init
+    Rave::Task.new
+    task(:default => "rave:create_war")
+    Rake.application.top_level
+  end
+end
+
+#Runs warbler's cleanup to get rid of the .war file and the tmp/war folder
+def cleanup_war(args)
+  Rake.application.standard_exception_handling do
+    Rake.application.init
+    Rave::Task.new
+    task(:default => "rave:clean")
+    Rake.application.top_level
+  end
+end

data/lib/exceptions.rb

@@ -0,0 +1,20 @@
+module Rave
+  #Exception raised when registering an invalid event
+  class InvalidEventException < Exception ; end
+  
+  #Exception raised when registering an event with an invalid handler
+  class InvalidHandlerException < Exception ; end
+
+  # Raised when trying to create an object with the same ID as one that already exists.
+  class DuplicatedIDError < Exception; end
+
+  # Raised if an unimplemented method is called.
+  class NotImplementedError < Exception; end
+
+  # A method option was not one of the values allowed.
+  class BadOptionError < ArgumentError
+    def initialize(option_name, valid_options, received) # :nodoc:
+      super("#{option_name.inspect} option must be one of #{valid_options.inspect}, not #{received.inspect}")
+    end
+  end
+end

data/lib/ext/logger.rb

@@ -0,0 +1,7 @@
+unless RUBY_PLATFORM == 'java'
+  require 'logger'
+  #Need to alias :warn as :warning to match the java logger
+  class Logger
+    alias :warning :warn
+  end
+end

data/lib/gems.yaml

@@ -0,0 +1,9 @@
+all:
+  rack: >=1.0
+  builder: >=2.1.2
+  warbler: >=0.9.14
+  RedCloth: >=4.2.2
+jruby:
+  json-jruby: >=1.1.6
+mri:
+  json: >=1.2.0