rave 0.1.1 → 0.1.2

data/lib/commands/usage.rb

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

@@ -1,51 +1,28 @@
-#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
+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

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

data/lib/mixins/controller.rb

@@ -1,40 +1,72 @@
-#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
+#Contains the Rack #call method - to be mixed in to the Robot class
+module Rave
+  module Mixins
+    module Controller
+      include Logger
+            
+      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
+            response = context.to_json
+            logger.info("Structure (after):\n#{context.print_structure}")
+            logger.info("Response:\n#{response}")
+            [ 200, { 'Content-Type' => 'application/json' }, response ]
+          elsif cron_job = @cron_jobs.find { |job| job[:path] == path }
+            body = request.body.read
+            context, events = parse_json_body(body)
+            self.send(cron_job[:handler], context)
+            [ 200, { 'Content-Type' => 'application/json' }, context.to_json ]
+          elsif File.exist?(file = File.join(".", "public", *(path.split("/"))))
+            #Static resource
+            [ 200, { 'Content-Type' => static_resource_content_type(file) }, File.open(file) { |f| f.read } ]
+          elsif self.respond_to?(:custom_routes)
+            #Let the custom route method defined in the robot take care of the call
+            self.custom_routes(request, path, method)
+          else
+            logger.warning("404 - Not Found: #{path}")
+            [ 404, { 'Content-Type' => 'text/html' }, "404 - Not Found" ]
+          end
+        rescue Exception => e
+          logger.warning("500 - Internal Server Error: #{path}")
+          logger.warning("#{e.class}: #{e.message}\n\n#{e.backtrace.join("\n")}")
+          [ 500, { 'Content-Type' => 'text/html' }, "500 - Internal Server Error"]
+        end
+      end
+      
+    protected
+      def static_resource_content_type(path)
+        case (ext = File.extname(path))
+        when '.html', '.htm'
+          'text/html'
+        when '.xml'
+          'text/xml'
+        when '.gif'
+          'image/gif'
+        when '.jpeg', '.jpg'
+          'image/jpeg'
+        when '.tif', '.tiff'
+          'image/tiff'
+        when '.txt', ''
+          'text/plain'
+        else
+          "application/#{ext}"
+        end
+      end
+    end 
+  end
+end

data/lib/mixins/data_format.rb

@@ -1,168 +1,206 @@
-#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(blip_data),
-                  :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']['list']
-          json['annotations']['list'].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
+#This mixin provides methods for robots to deal with parsing and presenting JSON and XML
+module Rave
+  module Mixins
+    module DataFormat
+      include Logger
+      
+      PROFILE_JAVA_CLASS = 'com.google.wave.api.ParticipantProfile'
+            
+      #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:version", @version)
+          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], "timerinseconds" => 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,
+          'profileUrl' => @profile_url,
+          'javaClass' => PROFILE_JAVA_CLASS,
+        }.to_json.gsub('\/','/')
+      end
+      
+      #Parses context and event info from JSON input
+      def parse_json_body(json)
+        logger.info("Received:\n#{json.to_s}")
+        data = JSON.parse(json)
+        #Create Context
+        context = context_from_json(data)
+        #Create events
+        events = events_from_json(data, context)
+        logger.info("Structure (before):\n#{context.print_structure}")
+        logger.info("Events: #{events.map { |e| e.type }.join(', ')}")
+        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,
+              :robot => self
+          )
+      end
+      
+      def blips_from_json(json)
+        map_to_hash(json['blips']).values.collect do |blip_data|
+          Rave::Models::Blip.new(
+                :id => blip_data['blipId'],
+                :annotations => annotations_from_json(blip_data),
+                :child_blip_ids => list_to_array(blip_data['childBlipIds']),
+                :content => blip_data['content'],
+                :contributors => list_to_array(blip_data['contributors']),
+                :creator => blip_data['creator'],
+                :elements => elements_from_json(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
+      end
+
+      def elements_from_json(elements_map)
+        elements = {}
+        
+        map_to_hash(elements_map).each_pair do |position, data|
+          elements[position.to_i] = Element.create(data['type'], map_to_hash(data['properties']))
+        end
+
+        elements
+      end
+
+      # Convert a json-java list (which may not be defined) into an array.
+      # Defaults to an empty array.
+      def list_to_array(list)
+        if list.nil?
+          []
+        else
+          list['list'] || []
+        end
+      end
+
+      # Convert a json-java map (which may not be defined) into a hash. Defaults
+      # to an empty hash.
+      def map_to_hash(map)
+        if map.nil?
+          {}
+        else
+          map['map'] || {}
+        end
+      end
+      
+      def annotations_from_json(json)
+        list_to_array(json['annotation']).collect do |annotation|
+          Rave::Models::Annotation.create(
+            annotation['name'],
+            annotation['value'],
+            range_from_json(annotation['range'])
+          )
+          
+        end
+      end
+
+      def range_from_json(json)
+         Range.new(json['start'], json['end'])
+      end
+      
+      def events_from_json(json, context)
+        list_to_array(json['events']).collect do |event|
+          properties = {}
+          event['properties']['map'].each do |key, value|
+            properties[key] = case value
+            when String # Just a string, as in blipId.
+              value
+            when Hash # Serialised array, such as in participantsAdded.
+              value['list']
+            else
+              raise "Unrecognised property #{value} #{value.class}"
+            end
+          end
+          Rave::Models::Event.create(event['type'],
+                :timestamp => event['timestamp'],
+                :modified_by => event['modifiedBy'],
+                :properties => properties,
+                :context => context,
+                :robot => self
+             )
+        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 => map_to_hash(wavelet['dataDocuments']),
+                  :last_modifed_time => wavelet['lastModifiedTime'],
+                  :participants => list_to_array(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