rave 0.1.2-java

data/lib/mixins/controller.rb

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

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

data/lib/mixins/logger.rb

@@ -0,0 +1,19 @@
+module Rave
+  module Mixins
+    module Logger
+      
+      def logger
+        if @logger.nil?
+          if RUBY_PLATFORM == 'java'
+            @logger = java.util.logging.Logger.getLogger(self.class.to_s)
+          else
+            #TODO: Need to be able to configure output
+            @logger = ::Logger.new(STDOUT)
+          end
+        end
+        @logger
+      end
+      
+    end
+  end
+end

data/lib/mixins/object_factory.rb

@@ -0,0 +1,87 @@
+module Rave
+  module Mixins
+    # Abstract object that allows you to create instances of the classes inside
+    # it based on providing a type name.
+    module ObjectFactory
+      WILDCARD = '*' unless defined? WILDCARD
+      
+      def self.included(base)
+        base.class_eval do
+          # Store the registered classes in a class instance variable.
+          class << self
+            attr_reader :class_by_type_mapping
+            attr_reader :class_by_pattern_mapping
+          end
+
+          @class_by_type_mapping = {}
+          @class_by_pattern_mapping = {}
+
+          class_eval(<<-END, __FILE__, __LINE__)
+            def self.classes_by_type
+              ::#{self.name}.class_by_type_mapping
+            end
+            def self.classes_by_pattern
+              ::#{self.name}.class_by_pattern_mapping
+            end
+          END
+
+          # Object factory method.
+          #
+          # :type - Type of object to create [String]
+          def self.create(type, *args, &block)
+            if classes_by_type.has_key? type
+              return classes_by_type[type].new(*args, &block)
+            elsif
+              # Check for pattern-based types. Check for longer matches before shorter ones.
+              patterns = classes_by_pattern.keys.sort { |a, b| b.to_s.length <=> a.to_s.length }
+              patterns.each do |pattern|
+                if type =~ pattern
+                  return classes_by_pattern[pattern].new($1, *args, &block)
+                end
+              end
+              raise ArgumentError.new("Unknown #{self} type #{type}")
+            end
+          end
+
+          # Is this type able to be created?
+          def self.valid_type?(type)
+            classes_by_type.has_key? type
+          end
+
+          # Register this class with its factory.
+          def self.factory_register(type)
+            classes_by_type[type] = self
+
+            # * in a type indicates a wildcard.
+            if type[WILDCARD]
+              classes_by_pattern[/^#{type.sub(WILDCARD, '(.*)')}$/] = self
+            end
+            
+            class << self
+              def type; @type.dup; end
+            end
+
+            @type = type
+
+          end
+
+          # Classes that can be generated by the factory [Array of Class]
+          def self.classes
+            classes_by_type.values
+          end
+
+          # Types that can be generated by the factory [Array of String]
+          def self.types
+            classes_by_type.keys
+          end
+        end
+      end
+
+      # Type name for this class [String]
+      attr_reader :type
+      def type # :nodoc:
+        self.class.type
+      end
+    end
+  end
+end

data/lib/mixins/time_utils.rb

@@ -0,0 +1,19 @@
+module Rave
+  module Mixins
+    module TimeUtils
+      
+      def time_from_json(time)
+        if time
+          time_s = time.to_s
+          epoch = if time_s.length > 10
+            "#{time_s[0, 10]}.#{time_s[10..-1]}".to_f
+          else
+            time.to_i
+          end
+          Time.at(epoch)
+        end
+      end
+      
+    end
+  end
+end

data/lib/models/annotation.rb

@@ -0,0 +1,148 @@
+require 'mixins/object_factory'
+
+module Rave
+  module Models
+    # An annotation applying styling or other meta-data to a section of text.
+    class Annotation
+      include Rave::Mixins::ObjectFactory
+
+      JAVA_CLASS = "com.google.wave.api.Annotation"
+
+      # Name of the annotation type [String]
+      def name # :nodoc:
+        # If @id is defined, then put that into the type, otherwise just the type is fine.
+        @id ? type.sub(WILDCARD, @id) : type
+      end
+
+      # Value of the annotation [String]
+      def value # :nodoc:
+        @value.dup
+      end
+
+      # Range of characters over which the annotation applies [Range]
+      def range # :nodoc:
+        @range.dup
+      end
+
+      # +value+:: Value of the annotation [String]
+      # +range+:: Range of characters that the annotation applies to [Range]
+      def initialize(value, range); end
+      # +id+:: The non-class-dependent part of the name [String]
+      # +value+:: Value of the annotation [String]
+      # +range+:: Range of characters that the annotation applies to [Range]
+      def initialize(id, value, range); end
+      def initialize(*args) # :nodoc:
+        case args.length
+        when 3
+          @id, @value, @range = args
+        when 2
+          @value, @range = args
+        end
+      end
+
+      def to_json # :nodoc:
+        {
+          'javaClass' => JAVA_CLASS,
+          'name' => name,
+          'value' => value,
+          'range' => range,
+        }.to_json
+      end
+
+      factory_register '*' # Accept all unrecognised annotations.
+
+      # Annotation classes:
+
+      # Language selected, such as "en", "de", etc.
+      class Language < Annotation
+        factory_register 'lang'
+      end
+
+      # Style, acting the same as the similarly named CSS properties.
+      class Style < Annotation
+
+        factory_register 'style/*' # Accept all unrecognised style annotations.
+        
+        class BackgroundColor < Style
+          factory_register 'style/backgroundColor'
+        end
+
+        class Color < Style
+          factory_register 'style/color'
+        end
+
+        class FontFamily < Style
+          factory_register 'style/fontFamily'
+        end
+
+        class FontSize < Style
+          factory_register 'style/fontSize'
+        end
+
+        class FontWeight < Style
+          factory_register 'style/fontWeight'
+        end
+
+        class TextDecoration < Style
+          factory_register 'style/textDecoration'
+        end
+
+        class VerticalAlign < Style
+          factory_register 'style/verticalAlign'
+        end
+      end
+
+      class Conversation < Annotation
+        factory_register 'conv/*' # Accept all unrecognised conv annotations.
+
+        class Title < Conversation
+          factory_register "conv/title"
+        end
+      end
+
+      # (Abstract)
+      class Link < Annotation
+        factory_register 'link/*' # Accept all unrecognised link annotations.
+
+        class Manual < Link
+          factory_register "link/manual"
+        end
+
+        class Auto < Link
+          factory_register "link/autoA"
+        end
+
+        class Wave < Link
+          factory_register "link/waveA"
+        end
+      end
+
+      # (Abstract)
+      class User < Annotation
+        factory_register 'user/*' # Accept all unrecognised user annotations.
+
+        # Session ID for the user annotation.
+        def session_id # :nodoc:
+          name =~ %r!/([^/]+)$!
+          $1
+        end
+
+        def initialize(session_id, value, range)
+          super
+        end
+
+        class Document < User
+          factory_register "user/d/*"
+        end
+
+        class Selection < User
+          factory_register "user/r/*"
+        end
+
+        class Focus < User
+          factory_register "user/e/*"
+        end
+      end
+    end
+  end
+end