rave 0.1.0

data/bin/rave

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

data/lib/commands/create.rb

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

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/usage.rb

@@ -0,0 +1,13 @@
+#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"
+end

data/lib/commands/war.rb

@@ -0,0 +1,51 @@
+#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 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)
+  #Run warbler
+  system("jruby -S warble")
+  web_inf = File.join(".", "tmp", "war", "WEB-INF")
+  rave_jars = File.join(File.dirname(__FILE__), "..", "jars")
+  #Delete the complete JRuby jar that warbler sticks in lib
+  delete_jruby_from_lib(File.join(web_inf, "lib"))
+  #Delete the complete JRuby jar from warbler itself 
+  delete_jruby_from_warbler(File.join(web_inf, "gems", "gems"))
+  #Copy the broken up JRuby jar into warbler #TODO Is warbler necessary? Can we just delete warbler?
+  copy_jruby_chunks_to_warbler(rave_jars, Dir[File.join(web_inf, "gems", "gems", "warbler-*", "lib")].first)
+  #Fix the broken paths in json-jruby
+  fix_json_jruby_paths(File.join(web_inf, "gems", "gems"))
+end
+
+def delete_jruby_from_lib(web_inf_lib)
+  jar = Dir[File.join(web_inf_lib, "jruby-complete-*.jar")].first
+  puts "Deleting #{jar}"
+  File.delete(jar) if jar
+end
+
+def delete_jruby_from_warbler(web_inf_gems)
+  jar = Dir[File.join(web_inf_gems, "warbler-*", "lib", "jruby-complete-*.jar")].first
+  puts "Deleting #{jar}"
+  File.delete(jar) if jar
+end
+
+def copy_jruby_chunks_to_warbler(rave_jar_dir, warbler_jar_dir)
+  puts "Copying jruby chunks"
+  %w( jruby-core.jar ruby-stdlib.jar ).each do |jar|
+    File.copy(File.join(rave_jar_dir, jar), File.join(warbler_jar_dir, jar))
+  end
+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

data/lib/exceptions.rb

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

data/lib/mixins/controller.rb

@@ -0,0 +1,40 @@
+#Contains the Rack #call method - to be mixed in to the Robot class
+module Rave
+  module Mixins
+    module Controller
+      
+      LOGGER = java.util.logging.Logger.getLogger("Controller")
+      
+      def call(env)
+        request = Rack::Request.new(env)
+        path = request.path_info
+        method = request.request_method
+        LOGGER.info("#{method}ing #{path}")
+        begin
+          #There are only 3 URLs that Wave can access: 
+          #  robot capabilities, robot profile, and event notification
+          if path == "/_wave/capabilities.xml" && method == "GET"
+            [ 200, { 'Content-Type' => 'text/xml' }, capabilities_xml ]
+          elsif path == "/_wave/robot/profile" && method == "GET"
+            [ 200, { 'Content-Type' => 'application/json' }, profile_json ]
+          elsif path == "/_wave/robot/jsonrpc" && method == "POST"
+            body = request.body.read
+            context, events = parse_json_body(body)
+            events.each do |event|
+              handle_event(event, context)
+            end
+            [ 200, { 'Content-Type' => 'application/json' }, context.to_json ]
+          else
+            #TODO: Also, give one more option: respond_to?(:non_robot_url) or something - can override in impl
+            #TODO: Log this
+            [ 404, { 'Content-Type' => 'text/html' }, "404 - Not Found" ]
+          end
+        rescue Exception => e
+          #TODO: Log this
+          [ 500, { 'Content-Type' => 'text/html' }, "500 - Internal Server Error"]
+        end
+      end
+      
+    end 
+  end
+end

data/lib/mixins/data_format.rb

@@ -0,0 +1,168 @@
+#This mixin provides methods for robots to deal with parsing and presenting JSON and XML
+module Rave
+  module Mixins
+    module DataFormat
+      
+      LOGGER = java.util.logging.Logger.getLogger("DataFormat") unless defined?(LOGGER)
+      
+      #Returns this robot's capabilities in XML
+      def capabilities_xml
+        xml = Builder::XmlMarkup.new
+        xml.instruct!
+        xml.tag!("w:robot", "xmlns:w" => "http://wave.google.com/extensions/robots/1.0") do
+          xml.tag!("w:capabilities") do
+            @handlers.keys.each do |capability|
+              xml.tag!("w:capability", "name" => capability)
+            end  
+          end
+          unless @cron_jobs.empty?
+            xml.tag!("w:crons") do
+              @cron_jobs.each do |job|
+                xml.tag!("w:cron", "path" => job[:path], "timeinseconds" => job[:seconds])
+              end
+            end
+          end
+          attrs = { "name" => @name }
+          attrs["imageurl"] = @image_url if @image_url
+          attrs["profileurl"] = @profile_url if @profile_url
+          xml.tag!("w:profile", attrs)
+        end
+      end
+      
+      #Returns the robot's profile in json format
+      def profile_json
+        {
+          "name" => @name,
+          "imageurl" => @image_url,
+          "profile_url" => @profile_url
+        }.to_json
+      end
+      
+      #Parses context and event info from JSON input
+      def parse_json_body(json)
+        LOGGER.info("Parsing JSON:")
+        LOGGER.info(json.to_s)
+        data = JSON.parse(json)
+        #Create Context
+        context = context_from_json(data)
+        #Create events
+        events = events_from_json(data)
+        return context, events
+      end
+      
+    protected
+      def context_from_json(json)
+        blips = {}
+        blips_from_json(json).each do |blip|
+          blips[blip.id] = blip
+        end
+        wavelets = {}
+        wavelets_from_json(json).each do |wavelet|
+          wavelets[wavelet.id] = wavelet
+        end
+        waves = {}
+        #Waves aren't sent back, but we can reconstruct them from the wavelets
+        waves_from_wavelets(wavelets).each do |wave|
+          waves[wave.id] = wave
+        end
+        Rave::Models::Context.new(
+              :waves => waves,
+              :wavelets => wavelets,
+              :blips => blips
+          )
+      end
+      
+      def blips_from_json(json)
+        if json['blips']
+          json['blips']['map'].values.collect do |blip_data|
+            blip = Rave::Models::Blip.new(
+                  :id => blip_data['blipId'],
+                  :annotations => annotations_from_json(json),
+                  :child_blip_ids => blip_data['childBlipIds'],
+                  :content => blip_data['content'],
+                  :contributors => blip_data['contributors'],
+                  :creator => blip_data['creator'],
+                  :elements => blip_data['elements'],
+                  :last_modified_time => blip_data['lastModifiedTime'],
+                  :parent_blip_id => blip_data['parentBlipId'],
+                  :version => blip_data['version'],
+                  :wave_id => blip_data['waveId'],
+                  :wavelet_id => blip_data['waveletId']
+              )
+          end
+        else
+          []
+        end
+      end
+      
+      def annotations_from_json(json)
+        if json['annotation']
+          json['annotations'].collect do |annotation|
+            Rave::Models::Annotation.new(
+                  :name => annotation['name'], 
+                  :value => annotation['value'], 
+                  :range => Range.new(annotation['range']['start'], annotation['range']['end'])
+              )
+          end
+        else
+          []
+        end
+      end
+      
+      def events_from_json(json)
+        if json['events'] && json['events']['list']
+          json['events']['list'].collect do |event|
+            properties = {}
+            event['properties']['map'].each { |key, value| properties[key] = value['list'] }
+            Rave::Models::Event.new(
+                  :type => event['type'],
+                  :timestamp => event['timestamp'],
+                  :modified_by => event['modifiedBy'],
+                  :properties => properties
+               )
+          end
+        else
+          []
+        end
+      end
+      
+      def wavelets_from_json(json)
+        #Currently only one wavelet is sent back
+        #TODO: should this look at the wavelet's children too?
+        wavelet = json['wavelet']
+        if wavelet
+          [
+            Rave::Models::Wavelet.new(
+                  :creator => wavelet['creator'],
+                  :creation_time => wavelet['creationTime'],
+                  :data_documents => wavelet['dataDocuments'],
+                  :last_modifed_time => wavelet['lastModifiedTime'],
+                  :participants => wavelet['participants'],
+                  :root_blip_id => wavelet['rootBlipId'],
+                  :title => wavelet['title'],
+                  :version => wavelet['version'],
+                  :wave_id => wavelet['waveId'],
+                  :id => wavelet['waveletId']
+              )
+          ]
+        else
+          []
+        end
+      end
+      
+      def waves_from_wavelets(wavelets)
+        wave_wavelet_map = {}
+        if wavelets
+          wavelets.values.each do |wavelet|
+            wave_wavelet_map[wavelet.wave_id] ||= []
+            wave_wavelet_map[wavelet.wave_id] << wavelet.id
+          end
+        end
+        wave_wavelet_map.collect do |wave_id, wavelet_ids|
+          Rave::Models::Wave.new(:id => wave_id, :wavelet_ids => wavelet_ids)
+        end
+      end
+      
+    end
+  end
+end

data/lib/models/annotation.rb

@@ -0,0 +1,18 @@
+module Rave
+  module Models
+    class Annotation
+        attr_reader :name, :value, :range
+        
+        #Options include
+        # - :name
+        # - :value
+        # - :range
+        def initialize(options = {})
+          @name = options[:name]
+          @value = options[:value]
+          @range = options[:range]
+        end
+        
+    end
+  end
+end

data/lib/models/blip.rb

@@ -0,0 +1,61 @@
+#Represents a Blip, owned by a Wavelet
+module Rave
+  module Models
+    class Blip
+      attr_reader :id, :annotations, :child_blip_ids, :content, :constributors, :creator,
+                  :elements, :last_modified_time, :parent_blip_id, :version, :wave_id, :wavelet_id
+      attr_accessor :context
+      
+      #Options include:
+      # - :annotations
+      # - :child_blip_ids
+      # - :content
+      # - :contributors
+      # - :creator
+      # - :elements
+      # - :last_modified_time
+      # - :parent_blip_id
+      # - :version
+      # - :wave_id
+      # - :wavelet_id
+      # - :id
+      # - :context
+      def initialize(options = {})
+        @annotations = options[:annotations] || []
+        @child_blip_ids = Set.new(options[:child_blip_ids])
+        @content = options[:content]
+        @contributors = Set.new(options[:contributors])
+        @creator = options[:creator]
+        @elements = options[:elements] || {}
+        @last_modified_time = options[:last_modified_time] || Time.now
+        @parent_blip_id = options[:parent_blip_id]
+        @version = options[:version] || -1
+        @wave_id = options[:wave_id]
+        @wavelet_id = options[:wavelet_id]
+        @id = options[:id]
+        @context = options[:context]
+      end
+      
+      #Returns true if this is a root blip (no parent blip)
+      def root?
+        @parent_blip_id.nil?
+      end
+      
+      #Returns true if an annotation with the given name exists in this blip
+      def has_annotation?(name)
+        @annotations.any? { |a| a.name == name }
+      end
+      
+      #Creates a child blip under this blip
+      def create_child_blip
+        #TODO
+      end
+      
+      #Delete this blip from its wavelet
+      def delete
+        #TODO
+      end
+      
+    end
+  end
+end

data/lib/models/context.rb

@@ -0,0 +1,45 @@
+#Contains server request information including current waves and operations
+module Rave
+  module Models
+    class Context
+      attr_reader :waves, :wavelets, :blips, :operations
+      
+      #Options include:
+      # - :waves
+      # - :wavelets
+      # - :blips
+      # - :operations
+      def initialize(options = {})
+        @waves = options[:waves] || {}
+        @waves.values.each { |wave| wave.context = self }          #Set up self as this wave's context
+        @wavelets = options[:wavelets] || {}
+        @wavelets.values.each { |wavelet| wavelet.context = self } #Set up self as this wavelet's context
+        @blips = options[:blips] || {}
+        @blips.values.each { |blip| blip.context = self }          #Set up self as this blip's context
+        @operations = options[:operations] || []
+      end
+      
+      #Find the root wavelet if it exists in this context
+      def root_wavelet
+        @wavelets.values.find { |wavelet| wavelet.id =~ Regexp.new(Rave::Models::Wavelet::ROOT_ID_REGEXP) }
+      end
+      
+      #Serializes the context to JSON format
+      def to_json
+        self.to_hash.to_json
+      end
+      
+      #Serialize the context to a hash map
+      def to_hash
+        hash = {
+          'operations' => { 'javaClass' => 'java.util.ArrayList', 'list' => [] },
+          'javaClass' => 'com.google.wave.api.impl.OperationMessageBundle'
+         }
+        @operations.each do |op|
+          hash['operations']['list'] << op.to_hash
+        end
+        hash
+      end
+    end
+  end
+end

data/lib/models/document.rb

@@ -0,0 +1,9 @@
+module Rave
+  module Models
+    class Document
+      
+      #TODO
+      
+    end
+  end
+end

data/lib/models/event.rb

@@ -0,0 +1,48 @@
+#Represents and event
+module Rave
+  module Models
+    class Event
+      attr_reader :type, :timestamp, :modified_by, :properties
+      
+      #Event types:
+      WAVELET_BLIP_CREATED = 'WAVELET_BLIP_CREATED'
+      WAVELET_BLIP_REMOVED = 'WAVELET_BLIP_REMOVED'
+      WAVELET_PARTICIPANTS_CHANGED = 'WAVELET_PARTICIPANTS_CHANGED'
+      WAVELET_TIMESTAMP_CHANGED = 'WAVELET_TIMESTAMP_CHANGED'
+      WAVELET_TITLE_CHANGED = 'WAVELET_TITLE_CHANGED'
+      WAVELET_VERSION_CHANGED = 'WAVELET_VERSION_CHANGED'
+      BLIP_CONTRIBUTORS_CHANGED = 'BLIP_CONTRIBUTORS_CHANGED'
+      BLIP_DELETED = 'BLIP_DELETED'
+      BLIP_SUBMITTED = 'BLIP_SUBMITTED'
+      BLIP_TIMESTAMP_CHANGED = 'BLIP_TIMESTAMP_CHANGED'
+      BLIP_VERSION_CHANGED = 'BLIP_VERSION_CHANGED'
+      DOCUMENT_CHANGED = 'DOCUMENT_CHANGED'
+      FORM_BUTTON_CLICKED = 'FORM_BUTTON_CLICKED'
+      
+      VALID_EVENTS = [
+              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
+           ]
+      
+      #Options include:
+      # - :type
+      # - :timestamp
+      # - :modified_by
+      # - :properties
+      def initialize(options = {})
+        @type = options[:type]
+        @timestamp = options[:timestamp] || Time.now
+        @modified_by = options[:modified_by]
+        @properties = options[:properties] || {}
+      end
+      
+      #Returns true if the event_type is a possible event type, and false if not
+      def self.valid_event_type?(event_type)
+        VALID_EVENTS.include?(event_type)
+      end
+      
+    end
+  end
+end

data/lib/models/operation.rb

@@ -0,0 +1,89 @@
+#Represents an operation to be applied on the server
+module Rave
+  module Models
+    class Operation
+      attr_reader :type, :wave_id, :wavelet_id, :blip_id, :index, :property
+      
+      #Constants
+      # Types of operations
+      WAVELET_APPEND_BLIP = 'WAVELET_APPEND_BLIP'
+      WAVELET_ADD_PARTICIPANT = 'WAVELET_ADD_PARTICIPANT'
+      WAVELET_CREATE = 'WAVELET_CREATE'
+      WAVELET_REMOVE_SELF = 'WAVELET_REMOVE_SELF'
+      WAVELET_DATADOC_SET = 'WAVELET_DATADOC_SET'
+      WAVELET_SET_TITLE = 'WAVELET_SET_TITLE'
+      BLIP_CREATE_CHILD = 'BLIP_CREATE_CHILD'
+      BLIP_DELETE = 'BLIP_DELETE'
+      DOCUMENT_ANNOTATION_DELETE = 'DOCUMENT_ANNOTATION_DELETE'
+      DOCUMENT_ANNOTATION_SET = 'DOCUMENT_ANNOTATION_SET'
+      DOCUMENT_ANNOTATION_SET_NORANGE = 'DOCUMENT_ANNOTATION_SET_NORANGE'
+      DOCUMENT_APPEND = 'DOCUMENT_APPEND'
+      DOCUMENT_APPEND_STYLED_TEXT = 'DOCUMENT_APPEND_STYLED_TEXT'
+      DOCUMENT_INSERT = 'DOCUMENT_INSERT'
+      DOCUMENT_DELETE = 'DOCUMENT_DELETE'
+      DOCUMENT_REPLACE = 'DOCUMENT_REPLACE'
+      DOCUMENT_ELEMENT_APPEND = 'DOCUMENT_ELEMENT_APPEND'
+      DOCUMENT_ELEMENT_DELETE = 'DOCUMENT_ELEMENT_DELETE'
+      DOCUMENT_ELEMENT_INSERT = 'DOCUMENT_ELEMENT_INSERT'
+      DOCUMENT_ELEMENT_INSERT_AFTER = 'DOCUMENT_ELEMENT_INSERT_AFTER'
+      DOCUMENT_ELEMENT_INSERT_BEFORE = 'DOCUMENT_ELEMENT_INSERT_BEFORE'
+      DOCUMENT_ELEMENT_REPLACE = 'DOCUMENT_ELEMENT_REPLACE'
+      DOCUMENT_INLINE_BLIP_APPEND = 'DOCUMENT_INLINE_BLIP_APPEND'
+      DOCUMENT_INLINE_BLIP_DELETE = 'DOCUMENT_INLINE_BLIP_DELETE'
+      DOCUMENT_INLINE_BLIP_INSERT = 'DOCUMENT_INLINE_BLIP_INSERT'
+      DOCUMENT_INLINE_BLIP_INSERT_AFTER_ELEMENT = 'DOCUMENT_INLINE_BLIP_INSERT_AFTER_ELEMENT'
+
+      #Options include:
+      # - :type
+      # - :wave_id
+      # - :wavelet_id
+      # - :blip_id
+      # - :index
+      # - :property
+      def initialize(options = {})
+        @type = options[:type]
+        @wave_id = options[:wave_id]
+        @wavelet_id = options[:wavelet_id]
+        @blip_id = options[:blip_id]
+        @index = options[:index] || -1
+        @property = options[:property]
+      end
+      
+      #Serialize the operation to hash
+      def to_hash
+        {
+          'blipId' => @blip_id,
+          'index' => @index,
+          'waveletId' => @wavelet_id,
+          'waveId' => @wave_id,
+          'type' => @type,
+          'javaClass' => 'com.google.wave.api.impl.OperationImpl',
+          'property' => property_to_hash
+        }
+      end
+      
+      #Serialize teh operation to json
+      def to_json
+        to_hash.to_json
+      end
+      
+    protected
+      #Decide what kind of property it is and return the value that should be in the JSON
+      def property_to_hash
+        if @property.kind_of?(String)
+          @property
+        elsif @property.kind_of?(Range)
+          {
+            'javaClass' => 'com.google.wave.api.Range',
+            'start' => @property.first,
+            'end' => @property.last
+          }
+        else
+          #TODO: What else needs to be in here?
+          raise "I don't know what that property is..."
+        end
+      end
+      
+    end
+  end
+end

data/lib/models/robot.rb

@@ -0,0 +1,61 @@
+#Contains Robot data, event handlers and cron jobs
+module Rave
+  module Models
+    class Robot
+      include Rave::Mixins::DataFormat
+      include Rave::Mixins::Controller
+      
+      attr_reader :name, :image_url, :profile_url
+      
+      #Options include:
+      # - :name
+      # - :image_url
+      # - :profile_url
+      def initialize(options = {})
+        @name = options[:name]
+        @image_url = options[:image_url]
+        @profile_url = options[:profile_url]
+        @handlers = {}
+        @cron_jobs = []
+        register_default_handlers
+      end
+      
+      #Register a handler
+      # event_type is a string, and must be one of Rave::Models::Event::VALID_EVENTS
+      # multiple handlers may be applied to an event
+      def register_handler(event_type, handler)
+        raise Rave::InvalidEventException.new("Unknown event: #{event_type}") unless Rave::Models::Event.valid_event_type?(event_type)
+        raise Rave::InvalidHandlerException.new("Unknown handler: #{handler}") unless self.respond_to?(handler)
+        @handlers[event_type] ||= []
+        @handlers[event_type] << handler unless @handlers[event_type].include?(handler)
+      end
+      
+      #Dispatches events to the appropriate handler
+      def handle_event(event, context)
+        #Ignore unhandled events
+        if (handlers = @handlers[event.type])
+          handlers.each do |handler|
+            self.send(handler, event, context)
+          end
+        end
+      end
+      
+      #Registers a cron job
+      def register_cron_job(path, seconds)
+        @cron_jobs << {:path => path, :seconds => seconds}
+      end
+      
+    protected
+      #Register any handlers that are defined through naming convention
+      def register_default_handlers
+        Event::VALID_EVENTS.each do |event|
+          listener = event.downcase.to_sym
+          if respond_to?(listener)
+            register_handler(event, listener)
+          end
+        end
+      end
+      
+    end
+  end
+end

data/lib/models/wave.rb

@@ -0,0 +1,19 @@
+# Represents a Wave
+module Rave
+  module Models
+    class Wave
+      attr_reader :id, :wavelet_ids
+      
+      attr_accessor :context
+      
+      #Options include:
+      # - :wavelet_ids
+      # - :id
+      def initialize(options = {})
+        @id = options[:id]
+        @wavelet_ids = Set.new(options[:wavelet_ids])
+      end
+      
+    end
+  end
+end

data/lib/models/wavelet.rb

@@ -0,0 +1,69 @@
+# Represents a Wavelet, owned by a Wave
+module Rave
+  module Models
+    class Wavelet
+      attr_reader :creator, :creation_time, :data_documents, :last_modified_time, 
+                  :participants, :root_blip_id, :title, :version, :wave_id, :id
+      attr_accessor :context  #Context needs to be able to set this
+      
+      ROOT_ID_SUFFIX = "conv+root"   #The suffix for the root wavelet in a wave]
+      ROOT_ID_REGEXP = /conv\+root$/
+      
+      # Options include:
+      # - :creator
+      # - :creation_time 
+      # - :data_documents
+      # - :last_modifed_time
+      # - :participants
+      # - :root_blip_id
+      # - :title
+      # - :version
+      # - :wave_id
+      # - :context
+      # - :id
+      def initialize(options = {})
+        @creator = options[:creator]
+        @creation_time = options[:creation_time] || Time.now
+        @data_documents = options[:data_documents] || {}
+        @last_modified_time = options[:last_modified_time] || Time.now
+        @participants = Set.new(options[:participants])
+        @root_blip_id = options[:root_blip_id]
+        @title = options[:title]
+        @version = options[:version] || 0
+        @wave_id = options[:wave_id]
+        @context = options[:context]
+        @id = options[:id]
+      end
+      
+      #Creates a blip for this wavelet
+      def create_blip
+        #TODO
+        blip = Blip.new(:wave_id => @wave_id, :wavelet_id => @id)
+        @context.operations << Operation.new(:type => Operation::WAVELET_APPEND_BLIP, :wave_id => @wave_id, :wavelet_id => @id, :prop => blip)
+        @context.add_blip(blip)
+        blip
+      end
+      
+      #Adds a participant to the wavelet
+      def add_participant(participant_id)
+        #TODO
+      end
+      
+      #Removes this robot from the wavelet
+      def remove_robot
+        #TODO
+      end
+      
+      #Sets the data document for the wavelet
+      def set_data_document(name, data)
+        #TODO
+      end
+      
+      #Set the title
+      def title=(title)
+        @title = title
+      end
+      
+    end
+  end
+end

data/lib/ops/blip_ops.rb

@@ -0,0 +1,131 @@
+#Reopen the blip class and add operation-related methods
+module Rave
+  module Models
+    class Blip
+      
+      #Clear the content
+      def clear
+        @context.operations << Operation.new(
+                                    :type => Operation::DOCUMENT_DELETE, 
+                                    :blip_id => @id, 
+                                    :wavelet_id => @wavelet_id, 
+                                    :wave_id => @wave_id,
+                                    :index => 0, 
+                                    :property => 0..(@content ? @content.length : 0)
+                                  )
+        @content = ''
+      end
+      
+      #Insert text at an index
+      def insert_text(text, index)
+        @context.operations << Operation.new(
+                                    :type => Operation::DOCUMENT_INSERT, 
+                                    :blip_id => @id, 
+                                    :wavelet_id => @wavelet_id, 
+                                    :wave_id => @wave_id,
+                                    :index => index, 
+                                    :property => text
+                                  )
+        @content = @content ? @content[0, index] + text + @content[index, @content.length - index] : text
+      end
+      
+      #Set the content text of the blip
+      def set_text(text)
+        clear
+        insert_text(text, 0)
+      end
+      
+      #Deletes the text in a given range and replaces it with the given text
+      def set_text_in_range(range, text)
+        delete_range(range)
+        insert_text(text, range.first)
+      end
+      
+      #Appends text to the end of the content
+      def append_text(text)
+        @context.operations << Operation.new(
+                                    :type => Operation::DOCUMENT_APPEND, 
+                                    :blip_id => @id, 
+                                    :wavelet_id => @wavelet_id, 
+                                    :wave_id => @wave_id,
+                                    :property => text
+                                  )
+        @content = @content + text
+      end
+      
+      #Deletes text in the given range
+      def delete_range(range)
+        @context.operations << Operation.new(
+                                    :type => Operation::DOCUMENT_DELETE, 
+                                    :blip_id => @id, 
+                                    :wavelet_id => @wavelet_id, 
+                                    :wave_id => @wave_id,
+                                    :index => range.first, 
+                                    :property => range
+                                  )
+        @content = @content[0..range.first-1] + @content[range.last+1..@content.length-1]
+      end
+      
+      #Annotates the entire content
+      def annotate_document(name, value)
+        #TODO
+        raise "This hasn't been implemented yet"
+      end
+      
+      #Deletes the annotation with the given name
+      def delete_annotation_by_name(name)
+        #TODO
+        raise "This hasn't been implemented yet"
+      end
+      
+      #Deletes the annotations with the given key in the given range
+      def delete_annotation_in_range(range, name)
+        #TODO
+        raise "This hasn't been implemented yet"
+      end
+      
+      #Appends an inline blip to this blip
+      def append_inline_blip
+        #TODO
+        raise "This hasn't been implemented yet"
+      end
+      
+      #Deletes an inline blip from this blip
+      def delete_inline_blip(blip_id)
+        #TODO
+        raise "This hasn't been implemented yet"
+      end
+      
+      #Inserts an inline blip at the given position
+      def insert_inline_blip(position)
+        #TODO
+        raise "This hasn't been implemented yet"
+      end
+      
+      #Deletes an element at the given position
+      def delete_element(position)
+        #TODO
+        raise "This hasn't been implemented yet"
+      end
+      
+      #Inserts the given element in the given position
+      def insert_element(position, element)
+        #TODO
+        raise "This hasn't been implemented yet"
+      end
+      
+      #Replaces the element at the given position with the given element
+      def replace_element(position, element)
+        #TODO
+        raise "This hasn't been implemented yet"
+      end
+      
+      #Appends an element
+      def append_element(element)
+        #TODO
+        raise "This hasn't been implemented yet"
+      end
+      
+    end
+  end
+end

data/lib/rave.rb

@@ -0,0 +1,23 @@
+require 'rubygems'
+require 'set'
+require 'builder'
+require 'json'
+
+here = File.dirname(__FILE__)
+mixins = File.join(here, "mixins")
+models = File.join(here, "models")
+ops = File.join(here, "ops")
+
+require File.join(here, 'exceptions')
+
+%w( data_format controller ).each do |dep|
+  require File.join(mixins, dep)
+end
+
+%w( annotation blip context document event operation robot wave wavelet).each do |dep|
+  require File.join(models, dep)
+end
+
+%w( blip_ops ).each do |dep|
+  require File.join(ops, dep)
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification 
+extensions: []
+
+homepage: http://github.com/diminish7/rave
+executables: 
+- rave
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+post_install_message: 
+date: 2009-06-20 07:00:00 +00:00
+files: 
+- lib/exceptions.rb
+- lib/rave.rb
+- lib/commands/create.rb
+- lib/commands/server.rb
+- lib/commands/usage.rb
+- lib/commands/war.rb
+- lib/jars/appengine-api-1.0-sdk-1.2.1.jar
+- lib/jars/jruby-core.jar
+- lib/jars/ruby-stdlib.jar
+- lib/mixins/controller.rb
+- lib/mixins/data_format.rb
+- lib/models/annotation.rb
+- lib/models/blip.rb
+- lib/models/context.rb
+- lib/models/document.rb
+- lib/models/event.rb
+- lib/models/operation.rb
+- lib/models/robot.rb
+- lib/models/wave.rb
+- lib/models/wavelet.rb
+- lib/ops/blip_ops.rb
+- bin/rave
+rubygems_version: 1.3.3
+rdoc_options: []
+
+signing_key: 
+cert_chain: []
+
+name: rave
+has_rdoc: true
+platform: ruby
+summary: A Google Wave robot client API for Ruby
+default_executable: 
+bindir: bin
+licenses: []
+
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  version: 
+  requirements: 
+  - - '>='
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_ruby_version: !ruby/object:Gem::Requirement 
+  version: 
+  requirements: 
+  - - '>='
+    - !ruby/object:Gem::Version 
+      version: 1.8.6
+require_paths: 
+- lib
+specification_version: 3
+test_files: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  type: :runtime
+  name: rack
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    version: 
+    requirements: 
+    - - '>='
+      - !ruby/object:Gem::Version 
+        version: "1.0"
+- !ruby/object:Gem::Dependency 
+  type: :runtime
+  name: builder
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    version: 
+    requirements: 
+    - - '>='
+      - !ruby/object:Gem::Version 
+        version: 2.1.2
+- !ruby/object:Gem::Dependency 
+  type: :runtime
+  name: json-jruby
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    version: 
+    requirements: 
+    - - '>='
+      - !ruby/object:Gem::Version 
+        version: 1.1.6
+- !ruby/object:Gem::Dependency 
+  type: :runtime
+  name: warbler
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    version: 
+    requirements: 
+    - - '>='
+      - !ruby/object:Gem::Version 
+        version: 0.9.13
+description: A toolkit for building Google Wave robots in Ruby
+email: diminish7@gmail.com
+authors: 
+- Jason Rush
+- Jay Donnell
+extra_rdoc_files: []
+
+requirements: []
+
+rubyforge_project: rave
+autorequire: