The word processing documents are just HTML documents. So we can use htmlParse() (or htmlTreeParse() ) and the XPath to find what we want. We can get the content or find the nodes of interest and modify them and then upload the resulting document. We have provided some simple functions for accessing elements of a word processing document. These are comments() , images() , footnotes() and sections() . Each of these takes either the name of a document and a connection (returned from getConnection() ) or the parsed HTML document. For example, we can call each of these as either:

comments("Many Parts", con)
doc = htmlParse(getDocContent("Many Parts", con), asText = TRUE, error = function(...) {})
comments(doc)
sections(doc)

The latter approach avoids retrieving the document and parsing it multiple times.

comments() returns a data frame with a row for each comment and columns giving the text of the comment, the date the comment was last modified ( or created?) and the name of the author of the comment.

sections() returns a character vector giving the title of the different sections. The names of the elements of this vector are numbers giving the level of the section. This is taken from the h1, h2, h3, ..., h6 elements in the HTML document.

The footnotes() function returns a character vector giving the text of the footnotes. The names are the unique identifiers within the document of these elements.

images() returns the names of the image files referenced within the document. Note that these are not the original names of the image files, but the names as they are stored within the Google documents repository.

We have added basic functions for working with spreadsheets. We create a connection for working with spreadsheets rather than word processing documents. We do this by specifying the service as "wise" rather than the default "writely".

  sheets.con = getGoogleDocsConnection(getGoogleAuth("dtemplelang@gmail.com", "...", service = "wise"))

When we call getDocs() with this connection, we get back information about spreadsheets only.

  a = getDocs(sheets.con)

The function getWorksheets() is used to obtain a list of objects that identify each of the worksheets within a spreadsheet.

  ts = getWorksheets(a$TwoSheets, sheets.con)
  names(ts)

getWorksheets() is smart enough to be able to work from the name of the spreadsheet, e.g.

  ts = getWorksheets("TwoSheets", sheets.con)

but it is faster to use the GoogleDocument object returned via getDocs() as it avoids an extra request to the Google Docs server.

We can do various things with the spreadsheet and its worksheets. We can query the dimensions and/or the contents of the worksheet or a part of it, we can modify one or more cells, and we can add a worksheet to a spreadsheet. The functions dim() , nrow() and ncol() all work. These report the "declared" dimensions of the worksheet, i.e. how many rows and columns have been allocated. This is often way more than are actually used. The function getExtent() tells us about the rectangular region that is actually in use. This returns a 2 x 2 matrix giving the "bounding box" of the effective cells in use. If there is nothing in the first row and column, this would return 2, 2 as the indices of the first cell.

We can convert a worksheet to a matrix or data frame using the regular as() function, e.g. as(sheet, "matrix") or as(sheet, "data.frame"). The coercion methods are merely calls to the function sheetAsMatrix() which provides more control of the coercion. It allows us to specify how the column names are found (e.g. as the first row of the worksheet, or given in the call as the value of the header parameter) and whether to discard "empty" rows and columns. For example,

  sheetAsMatrix(ts$Sheet1, header = TRUE, as.data.frame = TRUE, trim = TRUE)

If we want to access one or more cells, we can convert the entire worksheet into a data frame and then use R's regular subsetting. However, this is potentially expensive in that we have to download the entire worksheet and then process all of the contents. If the worksheet is large and we only want a few values, we are doing a lot of extra work. So we have provided methods for the subsetting operator [ that do this more efficiently by retrieving and processing only the specified cells. We can use these on the GoogleWorksheetRef objects. For example, suppose we have our sheet with

con = getGoogleDocsConnection("me", "my password")
mine4 = getWorksheets("mine4", con)[[1]]

then we can get a single cell with

mine4[2, 3]

We can get multiple cell values, e.g.

mine4[1:2, ]
mine4[, 2:3]
mine4[1, ]
mine4[, 3]

We can also assign values to one or more cells. Let's start by adding a new worksheet to the spreadsheet mine4:

mine4 = getDocs(con)$mine4
sh = addWorksheet(mine4, con, "test")

Now we can populate it

sh[1,1] = 2
sh[2, 1:10] = letters[1:10]
sh[, 11] = letters[1:5]

When we omit a dimension, the affected cells range over the extent

We can use uploadDoc() to upload a document or even an R object such as a data frame or matrix which will be converted to a spreadsheet via a CSV upload. We can use addSpreadsheet() to create a spreadsheet document with a single empty worksheet of specified dimensions. This is a simple wrapper for uploadDoc() Note that when uploading a document using either of these functions, you are communicating with the documents API, i.e. writely, and you need authentication for that. So if you have a connection for the spreadsheets API, you cannot use that.

We have been focusing on the contents of documents. The Google Docs API allows us to manage the collection of documents. It provides functionality to upload and delete/remove documents, rename documents, create folders and move documents into folders. The function addFolder() allows us to create a new folder. This is created at the top-level. We can then move it to a different folder. The function moveToFolder() does this. addFolder() takes one or more names and a connection and creates the folders with these names.

f = addFolder(c("foo", "bar"), con)

The results are GoogleFolder objects. We can use these as target/destinations in calls to moveToFolder() . For example, we can move the folder bar into foo with

moveToFolder(f$bar, f$foo)

We can change meta data, such as the title, of the document. This is done via the operators $*<- and [<-. (The accessor methods are not supported.) Given a document doc we set, e.g., the title with

doc$title = "new title"

We can also use

doc["title"] = "new title"

The benefit of the second approach (apart from allowing variables, e.g. var = "title"; doc[ var ] = value) is that we can set multiple values in a single call, e.g.

doc["title", "author"] = list("new title", c(name = "Bob", email = "bob@bob.com"))

The Google documents and spreadsheets servics are interesting. The Web-based nature has several attractive aspects. However, the interactive tools are currently quite limited relative to regular office applications. There is little functionality for working richly with styles. The APIs are also reasonably limited. Furthermore, some of the documentation is slightly unclear and even incorrect, e.g. the code for some examples do not correspond to what is being discussed in the text, the batch editing section talks about POST, but in fact PUT works and POST does not appear to. While developing some of the functionality in this package, the Google service claimed it was experiencing technical difficulties and was unable to list all my documents. So I am not ready to trade-in my office tools (not that I use them very much anyway!), but the notion of publishing "live" documents is appealing. The IDynDocs package has a different take on "live".