rave 0.1.1 → 0.1.2

data/lib/models/wavelet.rb

@@ -1,69 +1,269 @@
-# 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
+module Rave
+  module Models
+    # Represents a Wavelet, owned by a Wave
+    class Wavelet < Component
+      include Rave::Mixins::TimeUtils
+      include Rave::Mixins::Logger
+
+      # Creator of the wavelet if it was generated via an operation.
+      GENERATED_CREATOR = "rusty@a.gwave.com" # :nodoc:
+
+      # Current version number of the wavelet [Integer]
+      attr_reader :version
+
+      # ID of the creator [String]
+      def creator_id # :nodoc:
+        @creator_id.dup
+      end
+
+      # Time the wavelet was created [Time]
+      def creation_time # :nodoc:
+        @creation_time.dup
+      end
+
+      # Documents contained within the wavelet [Array of Document]
+      def data_documents # :nodoc:
+        @data_documents.dup
+      end
+
+      # The last time the wavelet was modified [Time]
+      def last_modified_time # :nodoc:
+        @last_modified_time.dup
+      end
+
+      # ID for the root blip [String]
+      def root_blip_id # :nodoc:
+        @root_blip_id.dup
+      end
+
+      # Wavelet title [String]
+      def title # :nodoc:
+        @title.dup
+      end
+      
+      # ID of the wave that the wavelet is a part of [String]
+      def wave_id # :nodoc:
+        @wave_id.dup
+      end
+
+      # IDs of all those who are currently members of the wavelet [Array of String]
+      def participant_ids # :nodoc:
+        @participant_ids.map { |id| id.dup }
+      end
+
+      JAVA_CLASS = 'com.google.wave.api.impl.WaveletData'
+      ROOT_ID_SUFFIX = "conv+root"   #The suffix for the root wavelet in a wave]
+      ROOT_ID_REGEXP = /#{Regexp.escape(ROOT_ID_SUFFIX)}$/
+
+      #
+      # Options include:
+      # - :creator
+      # - :creation_time 
+      # - :data_documents
+      # - :last_modifed_time
+      # - :participants
+      # - :root_blip_id
+      # - :title
+      # - :version
+      # - :wave_id
+      # - :context
+      # - :id
+      def initialize(options = {}) # :nodoc:
+        @participant_ids = options[:participants] || []
+
+        if options[:id].nil? and options[:context]
+          # Generate the wavelet from scratch.
+          super(:id => "#{GENERATED_PREFIX}_wavelet_#{unique_id}_#{ROOT_ID_SUFFIX}", :context => options[:context])
+
+          # Create a wave to live in.
+          wave = Wave.new(:wavelet_ids => [@id], :context => @context)
+          @wave_id = wave.id
+          @context.add_wave(wave)
+          
+          # Ensure the newly created wavelet has a root blip.
+          blip = Blip.new(:wave_id => wave.id, :wavelet_id => @id,
+            :creator => @context.robot.id, :contributors => [@context.robot.id])
+          @context.add_blip(blip)
+          @root_blip_id = blip.id
+
+          @participant_ids.each do |id|
+            @context.add_user(:id => id) unless @context.users[id]
+          end
+
+          @creator_id = GENERATED_CREATOR
+          @context.add_user(:id => @creator_id) unless @context.users[@creator_id]
+        else
+          super(options)
+          @root_blip_id = options[:root_blip_id]
+          @creator_id = options[:creator] || User::NOBODY_ID
+          @wave_id = options[:wave_id]
+        end
+
+        @creation_time = time_from_json(options[:creation_time]) || Time.now
+        @data_documents = options[:data_documents] || {}
+        @last_modified_time = time_from_json(options[:last_modified_time]) || Time.now
+        @title = options[:title] || ''
+        @version = options[:version] || 0
+      end
+
+      # Users that are currently have access the wavelet [Array of User]
+      def participants # :nodoc:
+        @participant_ids.map { |p| @context.users[p] }
+      end
+
+      # Users that originally created the wavelet [User]
+      def creator # :nodoc:
+        @context.users[@creator_id]
+      end
+
+      # Is this the root wavelet for its wave? [Boolean]
+      def root? # :nodoc:
+        not (id =~ ROOT_ID_REGEXP).nil?
+      end
+      
+      #Creates a blip for this wavelet
+      # Returns: Gererated blip [Blip]
+      def create_blip
+        parent = final_blip
+        blip = Blip.new(:wave_id => @wave_id, :parent_blip_id => parent.id,
+          :wavelet_id => @id, :context => @context)
+        parent.add_child_blip(blip)
+        
+        @context.add_operation(:type => Operation::WAVELET_APPEND_BLIP, :wave_id => @wave_id, :wavelet_id => @id, :property => blip)
+        blip
+      end
+
+      # Find the last blip in the main thread [Blip]
+      def final_blip # :nodoc:
+        blip = @context.blips[@root_blip_id]
+        if blip
+          while blip
+            # Find the first blip that is defined, if at all.
+            child_blip = blip.child_blips.find { |b| not b.nil? }
+            break unless child_blip
+            blip = child_blip
+          end
+        end
+        blip
+      end
+      
+      # Adds a participant (human or robot) to the wavelet
+      # +user+:: User to add, as ID or object [String or User]
+      # Returns: The user that was added [User or nil]
+      def add_participant(user) # :nodoc:
+        id = user.to_s.downcase
+        if @participant_ids.include?(id)
+          logger.warning("Attempted to add a participant who was already in the wavelet(#{@id}): #{id}")
+          return nil
+        end
+
+        # Allow string names to be used as participant.
+        user = if @context.users[id]
+          @context.users[id]
+        else
+          @context.add_user(:id => id)
+        end
+
+        @context.add_operation(:type => Operation::WAVELET_ADD_PARTICIPANT,
+          :wave_id => @wave_id, :wavelet_id => @id, :property => user)
+        @participant_ids << id
+        
+        user
+      end
+
+      # Removes a participant (robot only) from the wavelet.
+      # +user+:: User to remove, as ID or object [String or User]
+      # Returns: The user that was removed [User or nil]
+      def remove_participant(user) # :nodoc:
+        id = user.to_s.downcase
+        unless @participant_ids.include?(id)
+          logger.warning("Attempted to remove a participant who was not in the wavelet(#{@id}): #{id}")
+          return nil
+        end
+
+        # Allow string names to be used as participant.
+        user = @context.users[id]
+
+        unless user.robot?
+          logger.warning("Attempted to remove a non-robot from wavelet(#{@id}): #{id}")
+          return nil
+        end
+
+        if user == @context.robot
+          return remove_robot
+        end
+
+        @context.add_operation(:type => Operation::WAVELET_REMOVE_PARTICIPANT,
+          :wave_id => @wave_id, :wavelet_id => @id, :property => user)
+        @participant_ids.delete id
+        
+        user
+      end
+      
+      # Removes the local robot from the wavelet.
+      # Returns: The local robot [Robot]
+      def remove_robot
+        robot = @context.robot
+        @context.add_operation(:type => Operation::WAVELET_REMOVE_SELF,
+          :wave_id => @wave_id, :wavelet_id => @id)
+        @participant_ids.delete robot.id
+
+        robot
+      end
+      
+      #Sets the data document for the wavelet
+      #
+      # NOT IMPLEMENTED
+      def set_data_document(name, data)
+        raise NotImplementedError
+      end
+      
+      #Set the title
+      #
+      def title=(title) # :nodoc: Documented by title() as accessor.
+        title = title.to_s
+        @context.add_operation(:type => Operation::WAVELET_SET_TITLE,
+          :wave_id => @wave_id, :wavelet_id => @id, :property => title)
+        @title = title
+      end
+
+      # First blip in the wavelet [Blip]
+      def root_blip # :nodoc:
+        @context.blips[@root_blip_id]
+      end
+
+      # Wave that the wavelet is contained within.
+      def wave# :nodoc:
+        @context.waves[@wave_id]
+      end
+
+      # *INTERNAL*
+      # Convert to json for sending in an operation.
+      def to_json # :nodoc:
+        {
+          'waveletId' => @id,
+          'javaClass' => JAVA_CLASS,
+          'waveId' => @wave_id,
+          'rootBlipId' => @root_blip_id,
+          'participants' => { "javaClass" => "java.util.ArrayList", "list" => @participant_ids }
+        }.to_json
+      end
+
+      # Convert to string.
+      def to_s
+        text = @title.length > 24 ? "#{@title[0..20]}..." : @title
+        "#{super}:#{participants.join(',')}:#{text}"
+      end
+
+      def print_structure(indent = 0) # :nodoc:
+        str = "#{'  ' * indent}#{to_s}\n"
+        
+        if root_blip
+          str << root_blip.print_structure(indent + 1)
+        end
+
+        str
+      end
+    end
+  end
+end

data/lib/ops/blip_ops.rb

@@ -1,134 +1,233 @@
-#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)
-        #Note: I'm doing this in the opposite order from the python API, because
-        # otherwise, if you are setting text at the end of the content, the cursor
-        # gets moved to the start of the range...
-        insert_text(text, range.first)
-        delete_range(range.first+text.length..range.last+text.length)
-      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
+module Rave
+  module Models
+    class Blip
+      # Reopen the blip class and add operation-related methods
+
+      VALID_FORMATS = [:plain, :html, :textile] # :nodoc: For set_text/append_text
+
+      # Clear the content.
+      def clear
+        return if content.empty? # No point telling the server to clear an empty blip.
+        delete_range(0..(@content.length))
+      end
+      
+      # Insert text at an index.
+      def insert_text(index, text)
+        add_operation(:type => Operation::DOCUMENT_INSERT, :index => index, :property => text)
+        @content.insert(index, text)
+        # TODO: Shift annotations.
+
+        text
+      end
+      
+      # Set the content text of the blip.
+      #
+      # === Options
+      # :+format+ - Format of the text, which can be any one of:
+      # * :+html+ - Text marked up with HTML.
+      # * :+plain+ - Plain text (default).
+      # * :+textile+ - Text marked up with textile.
+      #
+      # Returns: An empty string [String]
+      def set_text(text, options = {})
+        clear
+        append_text(text, options)
+      end
+      
+      # Deletes the text in a given range and replaces it with the given text.
+      # Returns: The text altered [String]
+      def set_text_in_range(range, text)
+        raise ArgumentError.new("Requires a Range, not a #{range.class.name}") unless range.kind_of? Range
+        
+        #Note: I'm doing this in the opposite order from the python API, because
+        # otherwise, if you are setting text at the end of the content, the cursor
+        # gets moved to the start of the range...
+        unless text.empty?
+          begin # Failures in this method should give us a range error.
+            insert_text(range.min, text)
+          rescue IndexError => e
+            raise RangeError.new(e.message)
+          end
+        end
+        delete_range(range.min+text.length..range.max+text.length)
+        # TODO: Shift annotations.
+
+        text
+      end
+      
+      # Appends text to the end of the blip's current content.
+      # 
+      # === Options
+      # :+format+ - Format of the text, which can be any one of:
+      # * :+html+ - Text marked up with HTML.
+      # * :+plain+ - Plain text (default).
+      # * :+textile+ - Text marked up with textile.
+      #
+      # Returns: The new content string [String]
+      def append_text(text, options = {})
+        format = options[:format] || :plain
+        raise BadOptionError.new(:format, VALID_FORMATS, format) unless VALID_FORMATS.include? format
+        
+        plain_text = text
+        
+        if format == :textile
+          text = RedCloth.new(text).to_html
+          format = :html # Can now just treat it as HTML.
+        end
+
+        if format == :html
+          type = Operation::DOCUMENT_APPEND_MARKUP
+          plain_text = strip_html_tags(text)
+        else
+          type = Operation::DOCUMENT_APPEND
+        end
+        
+        add_operation(:type => type, :property => text)
+        # TODO: Add annotations for the tags we removed?
+        @content += plain_text # Plain text added to text field.
+
+        @content.dup
+      end
+      
+      # Deletes text in the given range.
+      # Returns: An empty string [String]
+      def delete_range(range)
+        raise ArgumentError.new("Requires a Range, not a #{range.class.name}") unless range.kind_of? Range
+        
+        add_operation(:type => Operation::DOCUMENT_DELETE, :index => range.min, :property => range)
+
+         @content[range] = ''
+         # TODO: Shift and/or delete annotations.
+
+        ''
+      end
+      
+      # Annotates the entire content.
+      #
+      # NOT IMPLEMENTED
+      def annotate_document(name, value)
+        raise NotImplementedError
+      end
+      
+      # Deletes the annotation with the given name.
+      #
+      # NOT IMPLEMENTED
+      def delete_annotation_by_name(name)
+        raise NotImplementedError
+      end
+      
+      # Deletes the annotations with the given key in the given range.
+      #
+      # NOT IMPLEMENTED
+      def delete_annotation_in_range(range, name)
+        raise NotImplementedError
+      end
+      
+      # Appends an inline blip to this blip.
+      # Returns: Blip created by operation [Blip]
+      def append_inline_blip
+        # TODO: What happens if there already is an element at end of content?
+        blip = Blip.new(:wave_id => @wave_id, :wavelet_id => @wavelet_id)
+        @context.add_blip(blip)
+        element = Element::InlineBlip.new('blipId' => blip.id)
+        element.context = @context
+        @elements[@content.length] = element
+        add_operation(:type => Operation::DOCUMENT_INLINE_BLIP_APPEND, :property => blip)
+        
+        blip
+      end
+      
+      # Deletes an inline blip from this blip.
+      # +value+:: Inline blip to delete [Blip]
+      #
+      # Returns: Blip ID of the deleted blip [String]
+      def delete_inline_blip(blip) # :nodoc:
+        element = @elements.values.find { |e| e.kind_of?(Element::InlineBlip) and e.blip == blip }
+        raise "Blip '#{blip.id}' is not an inline blip of blip '#{id}'" if element.nil?
+        #element.blip.destroy_me # TODO: How to deal with children?
+        @elements.delete_if { |pos, el| el == element }
+        add_operation(:type => Operation::DOCUMENT_INLINE_BLIP_DELETE, :property => blip.id)
+
+        blip.id
+      end
+      
+      # Inserts an inline blip at the given position.
+      # Returns: Blip element created by operation [Blip]
+      def insert_inline_blip(position)
+        # TODO: Complain if element does exist at that position.
+        blip = Blip.new(:wave_id => @wave_id, :wavelet_id => @wavelet_id)
+        @context.add_blip(blip)
+        element = Element::InlineBlip.new('blipId' => blip.id)
+        element.context = @context
+        @elements[@content.length] = element
+        add_operation(:type => Operation::DOCUMENT_INLINE_BLIP_INSERT, :index => position, :property => blip)
+
+        blip
+      end
+      
+      # Deletes an element at the given position.
+      def delete_element(position)
+        element = @elements[position]
+        case element
+        when Element::InlineBlip
+          return delete_inline_blip(element.blip)
+        when Element
+          @elements[position] = nil
+          add_operation(:type => Operation::DOCUMENT_ELEMENT_DELETE, :index => position)
+        else
+          raise "No element to delete at position #{position}"
+        end
+
+        self
+      end
+      
+      # Inserts the given element in the given position.
+      def insert_element(position, element)
+        # TODO: Complain if element does exist at that position.
+        @elements[position] = element
+        add_operation(:type => Operation::DOCUMENT_ELEMENT_INSERT, :index => position, :property => element)
+
+        element
+      end
+      
+      # Replaces the element at the given position with the given element.
+      def replace_element(position, element)
+        # TODO: Complain if element does not exist at that position.
+        @elements[position] = element
+        add_operation(:type => Operation::DOCUMENT_ELEMENT_REPLACE, :index => position, :property => element)
+
+        element
+      end
+      
+      # Appends an element
+      def append_element(element)
+        # TODO: What happens if there already is an element at end of content?
+        @elements[@content.length] = element
+        add_operation(:type => Operation::DOCUMENT_ELEMENT_APPEND, :property => element)
+
+        element
+      end
+
+    protected
+      def add_operation(options) # :nodoc:
+        @context.add_operation(options.merge(:blip_id => @id, :wavelet_id => @wavelet_id, :wave_id => @wave_id))
+      end
+
+      # Strips all HTML tags from a string, returning what it would look like unformatted.
+      def strip_html_tags(text) # :nodoc:
+        # Replace existing newlines/tabs with spaces, since they don't affect layout.
+        str = text.gsub(/[\n\t]/, ' ')
+        # Replace all <br /> with a newline.
+        str.gsub!(/<br\s*\/>\s*/, "\n")
+        # Put newline where are </h?>, </p> </div>, unless at the end.
+        str.gsub!(/<\/(?:h\d|p|div)>\s*(?!$)/, "\n")
+        # Remove all tags.
+        str.gsub!(/<\/?[^<]*>/, '')
+        # Remove spaces at each end.
+        str.gsub!(/^ +| +$/, '')
+        # Compress all adjacent spaces into a single space.
+        str.gsub(/ {2,}/, ' ')
+      end
+    end
+  end
+end