appengine-apis 0.0.8 → 0.0.9

data/lib/appengine-apis/tempfile.rb

@@ -0,0 +1,52 @@
+#! /usr/bin/ruby
+# Copyright:: Copyright 2009 Google Inc.
+# Original Author:: Ryan Brown (mailto:ribrdb@google.com)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Replace TempFile with a StringIO.
+
+$" << "tempfile.rb"
+
+require 'stringio'
+
+TempFile = Class.new(StringIO)
+
+class Tempfile < StringIO
+  attr_reader :path
+
+  def initialize(basename, tmpdir=nil)
+    @path = basename
+    super()
+  end
+
+  def unlink; end
+
+  def close(*args)
+    super()
+  end
+
+  def open; end
+
+  alias close! close
+  alias delete unlink
+  alias length size
+
+  def self.open(*args)
+    if block_given?
+      yield new(*args)
+    else
+      new(*args)
+    end
+  end
+end

data/lib/appengine-apis/urlfetch.rb

@@ -69,6 +69,7 @@ module AppEngine
     #     redirect chaininformation.  If false, you see the HTTP response
     #     yourself, including the 'Location' header, and redirects are not
     #     followed.
+    # [:deadline] Deadline, in seconds, for the request.
     #
     # Returns a Net::HTTPResponse.
     #
@@ -103,6 +104,7 @@ module AppEngine
       headers = options.delete(:headers) || {}
       truncate = options.delete(:allow_truncated)
       follow_redirects = options.delete(:follow_redirects) || true
+      deadline = options.delete(:deadline)
       
       unless options.empty?
         raise ArgumentError, "Unsupported options #{options.inspect}."
@@ -125,6 +127,8 @@ module AppEngine
         options.do_not_follow_redirects
       end
       
+      options.set_deadline(deadline) if deadline
+      
       url = java.net.URL.new(url) unless url.java_kind_of? java.net.URL
       request = HTTPRequest.new(url, method, options)
       

data/lib/appengine-apis/xmpp.rb

@@ -0,0 +1,283 @@
+#!/usr/bin/ruby1.8 -w
+#
+# Copyright:: Copyright 2009 Google Inc.
+# Original Author:: Ryan Brown (mailto:ribrdb@google.com)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# XMPP API.
+
+require 'appengine-apis/apiproxy'
+require 'logger'
+
+module AppEngine
+  
+  # The XMPP api provides an interface for accessing XMPP status information,
+  # sending XMPP messages, and parsing XMPP responses.
+  module XMPP
+    module Proto
+      %w(PresenceRequest PresenceResponse
+         XmppInviteRequest XmppInviteResponse
+         XmppMessageRequest XmppMessageResponse
+         XmppServiceError).each do |name|
+           const_set(name, JavaUtilities.get_proxy_or_package_under_package(
+             com.google.appengine.api.xmpp, "XMPPServicePb$#{name}"
+           ))
+         end
+      ErrorCode = XmppServiceError::ErrorCode
+    end
+    
+    class XMPPError < StandardError; end
+
+    module Status
+      NO_ERROR = Proto::XmppMessageResponse::XmppMessageStatus::NO_ERROR.value
+      INVALID_JID =
+          Proto::XmppMessageResponse::XmppMessageStatus::INVALID_JID.value
+      OTHER_ERROR =
+          Proto::XmppMessageResponse::XmppMessageStatus::OTHER_ERROR.value
+    end
+    
+    # Represents presence information returned by the server.
+    class Presence
+      def initialize(available)
+        @available = available
+      end
+      
+      def available?
+        @available
+      end
+    end
+    
+    # Represents an incoming or outgoing XMPP Message.
+    # Also includes support for parsing chat commands. Commands are of the form
+    #   /{command} {arg}?
+    # A backslash is also recognized as the first character to support chat
+    # client which internally handle / commands.
+    class Message      
+      ARG_INDEX = {:to => 0, :body => 1, :from => 2, :type => 3, :xml => 4}
+      COMMAND_REGEX = /^[\\\/](\S+)(\s+(.+))?/
+      
+      attr_reader :type, :sender, :recipients, :body
+      
+      # call-seq:
+      #   Message.new(to, body, from=nil, type=:chat, xml=false)
+      #   or
+      #   Message.new(options)
+      #
+      # Constructor for sending an outgoing XMPP message or parsing
+      # an incoming XMPP message.
+      #
+      # Args / Options:
+      # [:to] Destination JID or array of JIDs for the message.
+      # [:body] Body of the message.
+      # [:from] 
+      #     Optional custom sender JID. The default is <appid>@appspot.com.
+      #     Custom JIDs can be of the form <anything>@<appid>.appspotchat.com.
+      # [:type]
+      #     Optional type. Valid types are :chat, :error, :groupchat,
+      #     :headline, and :normal. See RFC 3921, section 2.1.1. The default
+      #     is :chat.
+      # [:xml]
+      #     If true specifies that the body should be interpreted as XML.
+      #     If false, the contents of the body will be escaped and placed
+      #     inside of a body element inside of the message. If true, the
+      #     contents will be made children of the message.
+      def initialize(*args)
+        if args.size == 1
+          options = args[0]
+        elsif args[-1].kind_of? Hash
+          options = args.pop
+        else
+          options = {}
+        end
+        @recipients = fetch_arg(:to, options, args)
+        @body = fetch_arg(:body, options, args)
+        unless @recipients && @body
+          raise ArgumentError, "Recipient and body are required."
+        end
+        @recipients = [@recipients] unless @recipients.kind_of? Array
+        
+        @sender = fetch_arg(:from, options, args)
+        @type = fetch_arg(:type, options, args) || :chat
+        @xml = !!fetch_arg(:xml, options, args)
+      end
+            
+      def xml?
+        @xml
+      end
+      
+      # Returns the command if this message contains a chat command.
+      def command
+        parse_command
+        @command
+      end
+      
+      # If this message contains a chat command, returns the command argument.
+      # Otherwise, returns the message body.
+      def arg
+        parse_command
+        @arg
+      end
+
+      # Convenience method to reply to a message.
+      def reply(body, type=:chat, xml=false)
+        message = Message.new([sender], body, recipients[0], type, xml)
+        XMPP.send_message(message)
+      end
+
+      private
+      def parse_command
+        return if @arg
+        if body =~ COMMAND_REGEX
+          @command = $1
+          @arg = $3 || ''
+        else
+          @arg = body
+        end
+      end
+      
+      def to_proto
+        proto = Proto::XmppMessageRequest.new
+        recipients.each do |jid|
+          proto.add_jid(jid)
+        end
+        proto.set_body(body)
+        proto.set_raw_xml(xml?)
+        proto.set_from_jid(sender) if sender
+        proto.set_type(type.to_s)
+        proto
+      end
+      
+      def fetch_arg(name, options, args)
+        arg = options[name] || args[ARG_INDEX[name]]
+        unless arg.kind_of? String
+          if arg.respond_to? :read
+            arg = arg.read
+          elsif arg.kind_of? Hash
+            arg.each do |key, value|
+              if value.respond_to? :read
+                arg = value.read
+                break
+              end
+            end
+          end
+        end
+        arg
+      end
+    end
+    
+    class << self
+
+      # Get the presence for a JID.
+      #
+      # Args:
+      # - jid: The JID of the contact whose presence is requested.
+      # - from_jid: Optional custom sender JID.
+      #     The default is <appid>@appspot.com. Custom JIDs can be of the form
+      #     <anything>@<appid>.appspotchat.com.
+      #
+      # Returns:
+      # - A Presence object.
+      def get_presence(jid, from_jid=nil)
+        raise ArgumentError, 'Jabber ID cannot be nil' if jid.nil?
+        request = Proto::PresenceRequest.new
+        request.set_jid(jid)
+        request.set_from_jid(from_jid) if from_jid
+        
+        response = make_sync_call('GetPresence', request,
+                                  Proto::PresenceResponse)
+        Presence.new(response.isIsAvailable)
+      rescue ApiProxy::ApplicationException => ex
+        case Proto::ErrorCode.value_of(ex.application_error)
+        when Proto::ErrorCode::INVALID_JID
+          raise ArgumentError, "Invalid jabber ID: #{jid}"
+        else
+          raise XMPPError, 'Unknown error retrieving presence for jabber ID: ' +
+              jid
+        end
+      end
+      
+      # Send a chat invitaion.
+      #
+      # Args:
+      # - jid: JID of the contact to invite.
+      # - from_jid: Optional custom sender JID. 
+      #     The default is <appid>@appspot.com. Custom JIDs can be of the form
+      #     <anything>@<appid>.appspotchat.com.
+      def send_invitation(jid, from_jid=nil)
+        raise ArgumentError, 'Jabber ID cannot be nil' if jid.nil?
+        request = Proto::XmppInviteRequest.new
+        request.set_jid(jid)
+        request.set_from_jid(from_jid) if from_jid
+
+        make_sync_call('SendInvite', request, Proto::XmppInviteResponse)
+        nil
+      rescue ApiProxy::ApplicationException => ex
+        case Proto::ErrorCode.value_of(ex.application_error)
+        when Proto::ErrorCode::INVALID_JID
+          raise ArgumentError, "Invalid jabber ID: #{jid}"
+        else
+          raise XMPPError, 'Unknown error sending invitation to jabber ID: ' +
+              jid
+        end
+      end
+      
+      
+      # call-seq:
+      #   XMPP.send_message(message)
+      #   or
+      #   XMPP.send_message(*message_args)
+      #
+      # Send a chat message.
+      #
+      # Args:
+      # - message: A Message object to send.
+      # - message_args: Used to create a new Message. See #Message.new
+      #
+      # Returns an Array Statuses, one for each JID, corresponding to the
+      # result of sending the message to that JID.
+      def send_message(*args)
+        if args[0].kind_of? Message
+          message = args[0]
+        else
+          message = Message.new(*args)
+        end
+        request = message.send :to_proto
+        response = make_sync_call('SendMessage', request,
+                                  Proto::XmppMessageResponse)
+        response.status_iterator.to_a
+      rescue ApiProxy::ApplicationException => ex
+        case Proto::ErrorCode.value_of(ex.application_error)
+        when Proto::ErrorCode::INVALID_JID
+          raise ArgumentError, "Invalid jabber ID"
+        when Proto::ErrorCode::NO_BODY
+          raise ArgumentError, "Missing message body"
+        when Proto::ErrorCode::INVALID_XML
+          raise ArgumentError, "Invalid XML body"
+        when Proto::ErrorCode::INVALID_TYPE
+          raise ArgumentError, "Invalid type #{message.type.inspect}"
+        else
+          raise XMPPError, 'Unknown error sending message'
+        end
+      end
+      
+      private
+      def make_sync_call(call, request, response_class)
+        bytes = ApiProxy.make_sync_call('xmpp', call, request.to_byte_array)
+        response = response_class.new
+        response.merge_from(bytes)
+        return response
+      end
+    end
+  end
+end

data/spec/datastore_spec.rb

@@ -35,6 +35,14 @@ describe AppEngine::Datastore do
     stored[:b].should == "b"
   end
   
+  it 'should raise EntityNotFound' do
+    p = lambda do
+      key = Datastore::Key.from_path("Does", "not exist")
+      e = Datastore.get(key)
+    end
+    p.should raise_error Datastore::EntityNotFound
+  end
+  
   it "should support Text" do
     entity = Datastore::Entity.new("Test")
     entity[:a] = Datastore::Text.new("a")
@@ -73,6 +81,25 @@ describe AppEngine::Datastore do
     p.should raise_error Datastore::TransactionFailed
   end
 
+  it "should support query transactions" do
+    a = Datastore::Entity.new("A")
+    Datastore.put(a)
+    b = Datastore::Entity.new("B", a.key)
+    b[:a] = 0
+    Datastore.put(b)
+    p = lambda do
+      Datastore.transaction do
+        b2 = Datastore::Query.new("B", a.key).entity
+        b[:a] += 1
+        Datastore.put(nil, b)
+        Datastore.put(b2)
+      end
+    end
+    pending("Local ancestory only queries") do
+      p.should raise_error Datastore::TransactionFailed
+    end
+  end
+
   it "should retry transactions" do
     a = Datastore::Entity.new("A")
     a[:a] = 0
@@ -92,6 +119,29 @@ describe AppEngine::Datastore do
     lambda {Datastore.transaction{ raise "Foo"}}.should raise_error "Foo"
     Datastore.active_transactions.to_a.should == []
   end
+  
+  describe "extract_tx" do
+    it "should support a single key" do
+      key = Datastore::Key.from_path("A", 1)
+      Datastore.extract_tx([key]).should == [key]
+    end
+  end
+  
+  it "should support allocate_ids" do
+    ids = Datastore.allocate_ids('Foo', 1)
+    ids.size.should == 1
+    ids.map{|x| x}.should == [ids.start]
+    ids.start.should == ids.end
+  end
+  
+  it "should support allocate_ids with parent" do
+    parent = Datastore::Key.from_path("A", 1)
+    ids = Datastore.allocate_ids(parent, 'Foo', 2)
+    ids.size.should == 2
+    ids.start.id.should == ids.end.id - 1
+    ids.map {|x| x}.size.should == 2
+    ids.start.parent.should == parent
+  end
 end
 
 describe AppEngine::Datastore::Query do
@@ -159,5 +209,9 @@ describe AppEngine::Datastore::Query do
     q.sort('name', Query::DESCENDING)
     q.fetch.to_a.should == [@aa, @a]
   end
-
+  
+  it "should support count" do
+    q = Query.new("A")
+    q.count.should == 2
+  end
 end

data/spec/datastore_types_spec.rb

@@ -160,6 +160,57 @@ describe AppEngine::Datastore::Entity do
     @entity['time'].class.should == Time
   end
   
+  it "should support Email" do
+    email = "ribrdb@example.com"
+    @entity['email'] = AppEngine::Datastore::Email.new(email)
+    @entity['email'].should == email
+    @entity['email'].class.should == AppEngine::Datastore::Email
+  end
+  
+  it "should support Category" do
+    category = "food"
+    @entity['cat'] = AppEngine::Datastore::Category.new(category)
+    @entity['cat'].should == category
+    @entity['cat'].class.should == AppEngine::Datastore::Category
+  end
+  
+  it "should support PhoneNumbers" do
+    number = '555-1212'
+    @entity['phone'] = AppEngine::Datastore::PhoneNumber.new(number)
+    @entity['phone'].should == number
+    @entity['phone'].class.should == AppEngine::Datastore::PhoneNumber
+  end
+
+  it "should support PostalAddress" do
+    address = '345 Spear St'
+    @entity['address'] = AppEngine::Datastore::PostalAddress.new(address)
+    @entity['address'].should == address
+    @entity['address'].class.should == AppEngine::Datastore::PostalAddress
+  end
+
+  it "should support Rating" do
+    rating = 34
+    @entity['rating'] = AppEngine::Datastore::Rating.new(rating)
+    @entity['rating'].rating.should == rating
+    @entity['rating'].class.should == AppEngine::Datastore::Rating
+  end
+
+  it "should support IMHandle" do
+    im = AppEngine::Datastore::IMHandle.new(:xmpp, 'batman@google.com')
+    @entity['im'] = im
+    @entity['im'].should == im
+    @entity['im'].class.should == AppEngine::Datastore::IMHandle
+  end
+
+  it "should support GeoPt" do
+    latitude = 32.4
+    longitude = 72.2
+    @entity['address'] = AppEngine::Datastore::GeoPt.new(latitude, longitude)
+    @entity['address'].latitude.should be_close latitude, 0.001
+    @entity['address'].longitude.should be_close longitude, 0.001
+    @entity['address'].class.should == AppEngine::Datastore::GeoPt
+  end
+
   it "should support multiple values" do
     list = [1, 2, 3]
     @entity['list'] = list
@@ -211,3 +262,77 @@ describe AppEngine::Datastore::Text do
   end
 end
 
+describe AppEngine::Datastore::Rating do
+  it 'should support ==' do
+    a = AppEngine::Datastore::Rating.new(27)
+    b = AppEngine::Datastore::Rating.new(27)
+    a.should == b
+  end
+  
+  it 'should support <=>' do
+    a = AppEngine::Datastore::Rating.new(3)
+    b = AppEngine::Datastore::Rating.new(4)
+    a.should be < b
+    b.should be > a
+  end
+  
+  it 'should check MIN_VALUE' do
+    l = lambda {AppEngine::Datastore::Rating.new -1}
+    l.should raise_error ArgumentError
+  end
+  
+  it 'should check MAX_VALUE' do
+    l = lambda {AppEngine::Datastore::Rating.new 101}
+    l.should raise_error ArgumentError
+  end
+end
+
+describe AppEngine::Datastore::GeoPt do
+  it 'should support ==' do
+    a = AppEngine::Datastore::GeoPt.new(35, 62)
+    b = AppEngine::Datastore::GeoPt.new(a.latitude, a.longitude)
+    a.should == b
+  end
+  
+  it 'should support <=>' do
+    a = AppEngine::Datastore::GeoPt.new(35, 62)
+    b = AppEngine::Datastore::GeoPt.new(36, 62)
+    a.should be < b
+    b.should be > a
+  end
+  
+  it 'should convert exceptions' do
+    l = lambda {AppEngine::Datastore::GeoPt.new(700, 999)}
+    l.should raise_error ArgumentError
+  end
+end
+
+describe AppEngine::Datastore::IMHandle do
+  it 'should support ==' do
+    a = AppEngine::Datastore::IMHandle.new(:unknown, 'foobar')
+    b = AppEngine::Datastore::IMHandle.new(:unknown, 'foobar')
+    a.should == b
+  end
+  
+  it 'should support symbols' do
+    p = Proc.new do
+      AppEngine::Datastore::IMHandle.new(:sip, "sip_address")
+      AppEngine::Datastore::IMHandle.new(:xmpp, "xmpp_address")
+      AppEngine::Datastore::IMHandle.new(:unknown, "unknown_address")
+    end
+    p.should_not raise_error ArgumentError
+  end
+  
+  it 'should support urls' do
+    protocol = 'http://aim.com/'
+    address = 'foobar'
+    im = AppEngine::Datastore::IMHandle.new(protocol, address)
+    im.protocol.should == protocol
+    im.address.should == address
+  end
+  
+  it 'should convert errors' do
+    l = lambda {AppEngine::Datastore::IMHandle.new 'aim', 'foobar'}
+    l.should raise_error ArgumentError
+  end
+end