SCM

SCM Repository

[tm] Diff of /pkg/R/corpus.R
ViewVC logotype

Diff of /pkg/R/corpus.R

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

trunk/R/textmin/R/textdoccol.R revision 74, Tue Nov 21 20:04:17 2006 UTC pkg/R/corpus.R revision 1114, Fri Nov 26 14:05:54 2010 UTC
# Line 1  Line 1 
1  # Author: Ingo Feinerer  # Author: Ingo Feinerer
2    
3  # The "..." are additional arguments for the function_generator parser  .PCorpus <- function(x, cmeta, dmeta, dbcontrol) {
4  setGeneric("TextDocCol", function(object, parser = plaintext_parser, ...) standardGeneric("TextDocCol"))      attr(x, "CMetaData") <- cmeta
5  setMethod("TextDocCol",      attr(x, "DMetaData") <- dmeta
6            signature(object = "Source"),      attr(x, "DBControl") <- dbcontrol
7            function(object, parser = plaintext_parser, ...) {      class(x) <- c("PCorpus", "Corpus", "list")
8                if (inherits(parser, "function_generator"))      x
9                    parser <- parser(...)  }
10    DBControl <- function(x) attr(x, "DBControl")
11    
12    PCorpus <- function(x,
13                        readerControl = list(reader = x$DefaultReader, language = "en"),
14                        dbControl = list(dbName = "", dbType = "DB1"),
15                        ...) {
16        readerControl <- prepareReader(readerControl, x$DefaultReader, ...)
17    
18        if (is.function(readerControl$init))
19            readerControl$init()
20    
21        if (is.function(readerControl$exit))
22            on.exit(readerControl$exit())
23    
24        if (!filehash::dbCreate(dbControl$dbName, dbControl$dbType))
25            stop("error in creating database")
26        db <- filehash::dbInit(dbControl$dbName, dbControl$dbType)
27    
28        # Allocate memory in advance if length is known
29        tdl <- if (x$Length > 0)
30            vector("list", as.integer(x$Length))
31        else
32            list()
33    
               tdl <- list()  
34                counter <- 1                counter <- 1
35                while (!eoi(object)) {      while (!eoi(x)) {
36                    object <- step_next(object)          x <- stepNext(x)
37                    elem <- get_elem(object)          elem <- getElem(x)
38                    # If there is no Load on Demand support          doc <- readerControl$reader(elem, readerControl$language, if (is.null(x$Names)) as.character(counter) else x$Names[counter])
39                    # we need to load the corpus into memory at startup          filehash::dbInsert(db, ID(doc), doc)
40                    if (object@LoDSupport)          if (x$Length > 0) tdl[[counter]] <- ID(doc)
41                        load <- object@Load          else tdl <- c(tdl, ID(doc))
                   else  
                       load <- TRUE  
                   tdl <- c(tdl, list(parser(elem, object@LoDSupport, load, as.character(counter))))  
42                    counter <- counter + 1                    counter <- counter + 1
43                }                }
44        names(tdl) <- x$Names
45    
46                dmeta.df <- data.frame(MetaID = rep(0, length(tdl)), stringsAsFactors = FALSE)      df <- data.frame(MetaID = rep(0, length(tdl)), stringsAsFactors = FALSE)
47                dcmeta.node <- new("MetaDataNode",      filehash::dbInsert(db, "DMetaData", df)
48                              NodeID = 0,      dmeta.df <- data.frame(key = "DMetaData", subset = I(list(NA)))
                             MetaData = list(create_date = date(), creator = Sys.getenv("LOGNAME")),  
                             children = list())  
   
               return(new("TextDocCol", .Data = tdl, DMetaData = dmeta.df, DCMetaData = dcmeta.node))  
           })  
   
 setGeneric("DirSource", function(directory, load = FALSE) standardGeneric("DirSource"))  
 setMethod("DirSource",  
           signature(directory = "character"),  
           function(directory, load = FALSE) {  
               new("DirSource", LoDSupport = TRUE, FileList = dir(directory, full.names = TRUE),  
                   Position = 0, Load = load)  
           })  
   
 setGeneric("CSVSource", function(object) standardGeneric("CSVSource"))  
 setMethod("CSVSource",  
           signature(object = "character"),  
           function(object) {  
               object <- substitute(file(object))  
               con <- eval(object)  
               content <- scan(con, what = "character")  
               close(con)  
               new("CSVSource", LoDSupport = FALSE, URI = object,  
                   Content = content, Position = 0)  
           })  
 setMethod("CSVSource",  
           signature(object = "ANY"),  
           function(object) {  
               object <- substitute(object)  
               con <- eval(object)  
               content <- scan(con, what = "character")  
               close(con)  
               new("CSVSource", LoDSupport = FALSE, URI = object,  
                   Content = content, Position = 0)  
           })  
   
 setGeneric("ReutersSource", function(object) standardGeneric("ReutersSource"))  
 setMethod("ReutersSource",  
           signature(object = "character"),  
           function(object) {  
               object <- substitute(file(object))  
               con <- eval(object)  
               corpus <- paste(readLines(con), "\n", collapse = "")  
               close(con)  
               tree <- xmlTreeParse(corpus, asText = TRUE)  
               content <- xmlRoot(tree)$children  
   
               new("ReutersSource", LoDSupport = FALSE, URI = object,  
                   Content = content, Position = 0)  
           })  
 setMethod("ReutersSource",  
           signature(object = "ANY"),  
           function(object) {  
               object <- substitute(object)  
               con <- eval(object)  
               corpus <- paste(readLines(con), "\n", collapse = "")  
               close(con)  
               tree <- xmlTreeParse(corpus, asText = TRUE)  
               content <- xmlRoot(tree)$children  
   
               new("ReutersSource", LoDSupport = FALSE, URI = object,  
                   Content = content, Position = 0)  
           })  
   
 setGeneric("step_next", function(object) standardGeneric("step_next"))  
 setMethod("step_next",  
           signature(object = "DirSource"),  
           function(object) {  
               object@Position <- object@Position + 1  
               object  
           })  
 setMethod("step_next",  
           signature(object = "CSVSource"),  
           function(object) {  
               object@Position <- object@Position + 1  
               object  
           })  
 setMethod("step_next",  
           signature(object = "ReutersSource"),  
           function(object) {  
               object@Position <- object@Position + 1  
               object  
           })  
   
 setGeneric("get_elem", function(object) standardGeneric("get_elem"))  
 setMethod("get_elem",  
           signature(object = "DirSource"),  
           function(object) {  
               filename <- object@FileList[object@Position]  
               list(content = readLines(filename),  
                    uri = substitute(file(filename)))  
           })  
 setMethod("get_elem",  
           signature(object = "CSVSource"),  
           function(object) {  
               list(content = object@Content[object@Position],  
                    uri = object@URI)  
           })  
 setMethod("get_elem",  
           signature(object = "ReutersSource"),  
           function(object) {  
               # Construct a character representation from the XMLNode  
               con <- textConnection("virtual.file", "w")  
               saveXML(object@Content[[object@Position]], con)  
               close(con)  
   
               list(content = virtual.file, uri = object@URI)  
           })  
   
 setGeneric("eoi", function(object) standardGeneric("eoi"))  
 setMethod("eoi",  
           signature(object = "DirSource"),  
           function(object) {  
               if (length(object@FileList) <= object@Position)  
                   return(TRUE)  
               else  
                   return(FALSE)  
           })  
 setMethod("eoi",  
           signature(object = "CSVSource"),  
           function(object) {  
               if (length(object@Content) <= object@Position)  
                   return(TRUE)  
               else  
                   return(FALSE)  
           })  
 setMethod("eoi",  
           signature(object = "ReutersSource"),  
           function(object) {  
               if (length(object@Content) <= object@Position)  
                   return(TRUE)  
               else  
                   return(FALSE)  
           })  
49    
50  plaintext_parser <- function(...) {      .PCorpus(tdl, .MetaDataNode(), dmeta.df, dbControl)
     function(elem, lodsupport, load, id) {  
         if (!lodsupport || (lodsupport && load)) {  
             doc <- new("PlainTextDocument", .Data = elem$content, URI = elem$uri, Cached = TRUE,  
                        Author = "", DateTimeStamp = date(), Description = "", ID = id, Origin = "", Heading = "")  
51          }          }
         else {  
             doc <- new("PlainTextDocument", URI = elem$uri, Cached = FALSE,  
                        Author = "", DateTimeStamp = date(), Description = "", ID = id, Origin = "", Heading = "")  
         }  
   
         return(doc)  
     }  
 }  
 class(plaintext_parser) <- "function_generator"  
   
 reut21578xml_parser <- function(...) {  
     function(elem, lodsupport, load, id) {  
         corpus <- paste(elem$content, "\n", collapse = "")  
         tree <- xmlTreeParse(corpus, asText = TRUE)  
         node <- xmlRoot(tree)  
52    
53          # Mask as list to bypass S4 checks  .VCorpus <- function(x, cmeta, dmeta) {
54          class(tree) <- "list"      attr(x, "CMetaData") <- cmeta
55        attr(x, "DMetaData") <- dmeta
56          # The <AUTHOR></AUTHOR> tag is unfortunately NOT obligatory!      class(x) <- c("VCorpus", "Corpus", "list")
57          if (!is.null(node[["TEXT"]][["AUTHOR"]]))      x
             author <- xmlValue(node[["TEXT"]][["AUTHOR"]])  
         else  
             author <- ""  
   
         datetimestamp <- xmlValue(node[["DATE"]])  
         description <- ""  
         id <- xmlAttrs(node)[["NEWID"]]  
   
         # The <TITLE></TITLE> tag is unfortunately NOT obligatory!  
         if (!is.null(node[["TEXT"]][["TITLE"]]))  
             heading <- xmlValue(node[["TEXT"]][["TITLE"]])  
         else  
             heading <- ""  
   
         topics <- unlist(xmlApply(node[["TOPICS"]], function(x) xmlValue(x)), use.names = FALSE)  
   
         if (!lodsupport || (lodsupport && load)) {  
             doc <- new("XMLTextDocument", .Data = tree, URI = elem$uri, Cached = TRUE, Author = author,  
                        DateTimeStamp = datetimestamp, Description = "", ID = id, Origin = "Reuters-21578 XML",  
                        Heading = heading, LocalMetaData = list(Topics = topics))  
         } else {  
             doc <- new("XMLTextDocument", URI = elem$uri, Cached = FALSE, Author = author,  
                        DateTimeStamp = datetimestamp, Description = "", ID = id, Origin = "Reuters-21578 XML",  
                        Heading = heading, LocalMetaData = list(Topics = topics))  
58          }          }
59    
60          return(doc)  # Register S3 corpus classes to be recognized by S4 methods. This is
61      }  # mainly a fix to be compatible with packages which were originally
62  }  # developed to cooperate with corresponding S4 tm classes. Necessary
63  class(reut21578xml_parser) <- "function_generator"  # since tm's class architecture was changed to S3 since tm version 0.5.
64    setOldClass(c("VCorpus", "Corpus", "list"))
65    
66  rcv1_parser <- function(...) {  # The "..." are additional arguments for the FunctionGenerator reader
67      function(elem, lodsupport, load, id) {  VCorpus <- Corpus <- function(x,
68          corpus <- paste(elem$content, "\n", collapse = "")                                readerControl = list(reader = x$DefaultReader, language = "en"),
69          tree <- xmlTreeParse(corpus, asText = TRUE)                                ...) {
70          node <- xmlRoot(tree)      readerControl <- prepareReader(readerControl, x$DefaultReader, ...)
71    
72          # Mask as list to bypass S4 checks      if (is.function(readerControl$init))
73          class(tree) <- "list"          readerControl$init()
74    
75          datetimestamp <- xmlAttrs(node)[["date"]]      if (is.function(readerControl$exit))
76          id <- xmlAttrs(node)[["itemid"]]          on.exit(readerControl$exit())
         heading <- xmlValue(node[["title"]])  
77    
78          if (!lodsupport || (lodsupport && load)) {      # Allocate memory in advance if length is known
79              doc <- new("XMLTextDocument", .Data = tree, URI = elem$uri, Cached = TRUE, Author = "",      tdl <- if (x$Length > 0)
80                         DateTimeStamp = datetimestamp, Description = "", ID = id, Origin = "Reuters Corpus Volume 1 XML",          vector("list", as.integer(x$Length))
81                         Heading = heading)      else
82          } else {          list()
             doc <- new("XMLTextDocument", URI = elem$uri, Cached = FALSE, Author = "",  
                        DateTimeStamp = datetimestamp, Description = "", ID = id, Origin = "Reuters Corpus Volume 1 XML",  
                        Heading = heading)  
         }  
83    
84          return(doc)      if (x$Vectorized)
85      }          tdl <- mapply(function(x, id) readerControl$reader(x, readerControl$language, id),
86                          pGetElem(x),
87                          id = if (is.null(x$Names)) as.character(seq_len(x$Length)) else x$Names,
88                          SIMPLIFY = FALSE)
89        else {
90            counter <- 1
91            while (!eoi(x)) {
92                x <- stepNext(x)
93                elem <- getElem(x)
94                doc <- readerControl$reader(elem, readerControl$language, if (is.null(x$Names)) as.character(counter) else x$Names[counter])
95                if (x$Length > 0)
96                    tdl[[counter]] <- doc
97                else
98                    tdl <- c(tdl, list(doc))
99                counter <- counter + 1
100  }  }
 class(rcv1_parser) <- "function_generator"  
   
 newsgroup_parser <- function(...) {  
     function(elem, lodsupport, load, id) {  
         mail <- elem$content  
         author <- gsub("From: ", "", grep("^From:", mail, value = TRUE))  
         datetimestamp <- gsub("Date: ", "", grep("^Date:", mail, value = TRUE))  
         origin <- gsub("Path: ", "", grep("^Path:", mail, value = TRUE))  
         heading <- gsub("Subject: ", "", grep("^Subject:", mail, value = TRUE))  
         newsgroup <- gsub("Newsgroups: ", "", grep("^Newsgroups:", mail, value = TRUE))  
   
         if (!lodsupport || (lodsupport && load)) {  
             # The header is separated from the body by a blank line.  
             # Reference: \url{http://en.wikipedia.org/wiki/E-mail#Internet_e-mail_format}  
             for (index in seq(along = mail)) {  
                 if (mail[index] == "")  
                     break  
101              }              }
102              content <- mail[(index + 1):length(mail)]      names(tdl) <- x$Names
103        df <- data.frame(MetaID = rep(0, length(tdl)), stringsAsFactors = FALSE)
104              doc <- new("NewsgroupDocument", .Data = content, URI = elem$uri, Cached = TRUE,      .VCorpus(tdl, .MetaDataNode(), df)
                        Author = author, DateTimeStamp = datetimestamp,  
                        Description = "", ID = id, Origin = origin,  
                        Heading = heading, Newsgroup = newsgroup)  
         } else {  
             doc <- new("NewsgroupDocument", URI = elem$uri, Cached = FALSE, Author = author, DateTimeStamp = datetimestamp,  
                        Description = "", ID = id, Origin = origin, Heading = heading, Newsgroup = newsgroup)  
105          }          }
106    
107          return(doc)  `[.PCorpus` <- function(x, i) {
108      }      if (missing(i)) return(x)
109        index <- attr(x, "DMetaData")[[1 , "subset"]]
110        attr(x, "DMetaData")[[1 , "subset"]] <- if (is.numeric(index)) index[i] else i
111        dmeta <- attr(x, "DMetaData")
112        .PCorpus(NextMethod("["), CMetaData(x), dmeta, DBControl(x))
113  }  }
 class(newsgroup_parser) <- "function_generator"  
   
 # Parse a <newsitem></newsitem> element from a well-formed RCV1 XML file  
 rcv1_to_plain <- function(node, ...) {  
     datetimestamp <- xmlAttrs(node)[["date"]]  
     id <- xmlAttrs(node)[["itemid"]]  
     origin <- "Reuters Corpus Volume 1 XML"  
     corpus <- unlist(xmlApply(node[["text"]], xmlValue), use.names = FALSE)  
     heading <- xmlValue(node[["title"]])  
114    
115      new("PlainTextDocument", .Data = corpus, Cached = TRUE, URI = "", Author = "", DateTimeStamp = datetimestamp,  `[.VCorpus` <- function(x, i) {
116          Description = "", ID = id, Origin = "Reuters Corpus Volume 1 XML", Heading = heading)      if (missing(i)) return(x)
117        .VCorpus(NextMethod("["), CMetaData(x), DMetaData(x)[i, , drop = FALSE])
118  }  }
119    
120  # Parse a <REUTERS></REUTERS> element from a well-formed Reuters-21578 XML file  `[<-.PCorpus` <- function(x, i, value) {
121  reut21578xml_to_plain <- function(node, ...) {      db <- filehash::dbInit(DBControl(x)[["dbName"]], DBControl(x)[["dbType"]])
122      # The <AUTHOR></AUTHOR> tag is unfortunately NOT obligatory!      counter <- 1
123      if (!is.null(node[["TEXT"]][["AUTHOR"]]))      for (id in unclass(x)[i]) {
124          author <- xmlValue(node[["TEXT"]][["AUTHOR"]])          if (identical(length(value), 1L)) db[[id]] <- value
125      else          else db[[id]] <- value[[counter]]
126          author <- ""          counter <- counter + 1
   
     datetimestamp <- xmlValue(node[["DATE"]])  
     description <- ""  
     id <- xmlAttrs(node)[["NEWID"]]  
   
     origin <- "Reuters-21578 XML"  
   
     # The <BODY></BODY> tag is unfortunately NOT obligatory!  
     if (!is.null(node[["TEXT"]][["BODY"]]))  
         corpus <- xmlValue(node[["TEXT"]][["BODY"]])  
     else  
         corpus <- ""  
   
     # The <TITLE></TITLE> tag is unfortunately NOT obligatory!  
     if (!is.null(node[["TEXT"]][["TITLE"]]))  
         heading <- xmlValue(node[["TEXT"]][["TITLE"]])  
     else  
         heading <- ""  
   
     topics <- unlist(xmlApply(node[["TOPICS"]], function(x) xmlValue(x)), use.names = FALSE)  
   
     new("PlainTextDocument", .Data = corpus, Cached = TRUE, URI = "", Author = author, DateTimeStamp = datetimestamp,  
         Description = description, ID = id, Origin = origin, Heading = heading, LocalMetaData = list(Topics = topics))  
127  }  }
128        x
 setGeneric("load_doc", function(object, ...) standardGeneric("load_doc"))  
 setMethod("load_doc",  
           signature(object = "PlainTextDocument"),  
           function(object, ...) {  
               if (!Cached(object)) {  
                   con <- eval(URI(object))  
                   corpus <- readLines(con)  
                   close(con)  
                   Corpus(object) <- corpus  
                   Cached(object) <- TRUE  
                   return(object)  
               } else {  
                   return(object)  
               }  
           })  
 setMethod("load_doc",  
           signature(object =  "XMLTextDocument"),  
           function(object, ...) {  
               if (!Cached(object)) {  
                   con <- eval(URI(object))  
                   corpus <- paste(readLines(con), "\n", collapse = "")  
                   close(con)  
                   doc <- xmlTreeParse(corpus, asText = TRUE)  
                   class(doc) <- "list"  
                   Corpus(object) <- doc  
                   Cached(object) <- TRUE  
                   return(object)  
               } else {  
                   return(object)  
               }  
           })  
 setMethod("load_doc",  
           signature(object = "NewsgroupDocument"),  
           function(object, ...) {  
               if (!Cached(object)) {  
                   con <- eval(URI(object))  
                   mail <- readLines(con)  
                   close(con)  
                   Cached(object) <- TRUE  
                   for (index in seq(along = mail)) {  
                       if (mail[index] == "")  
                           break  
                   }  
                   Corpus(object) <- mail[(index + 1):length(mail)]  
                   return(object)  
               } else {  
                   return(object)  
               }  
           })  
   
 setGeneric("tm_update", function(object, origin, parser = plaintext_parser, ...) standardGeneric("tm_update"))  
 # Update is only supported for directories  
 # At the moment no other LoD devices are available anyway  
 setMethod("tm_update",  
           signature(object = "TextDocCol", origin = "DirSource"),  
           function(object, origin, parser = plaintext_parser, ...) {  
               if (inherits(parser, "function_generator"))  
                   parser <- parser(...)  
   
               object.filelist <- unlist(lapply(object, function(x) {as.character(URI(x))[2]}))  
               new.files <- setdiff(origin@FileList, object.filelist)  
   
               for (filename in new.files) {  
                   elem <- list(content = readLines(filename),  
                                uri = substitute(file(filename)))  
                   object <- append_doc(object, parser(elem, TRUE, origin@Load, filename), NA)  
               }  
   
               return(object)  
           })  
   
 setGeneric("tm_transform", function(object, FUN, ...) standardGeneric("tm_transform"))  
 setMethod("tm_transform",  
           signature(object = "TextDocCol", FUN = "function"),  
           function(object, FUN, ...) {  
               result <- object  
               result@.Data <- lapply(object, FUN, ..., DMetaData = DMetaData(object))  
               return(result)  
           })  
   
 setGeneric("as.plaintext_doc", function(object, FUN, ...) standardGeneric("as.plaintext_doc"))  
 setMethod("as.plaintext_doc",  
           signature(object = "PlainTextDocument"),  
           function(object, FUN, ...) {  
               return(object)  
           })  
 setMethod("as.plaintext_doc",  
           signature(object = "XMLTextDocument", FUN = "function"),  
           function(object, FUN, ...) {  
               if (!Cached(object))  
                   object <- load_doc(object)  
   
               corpus <- Corpus(object)  
   
               # As XMLDocument is no native S4 class, restore valid information  
               class(corpus) <- "XMLDocument"  
               names(corpus) <- c("doc","dtd")  
   
               return(FUN(xmlRoot(corpus), ...))  
           })  
   
 setGeneric("tm_tolower", function(object, ...) standardGeneric("tm_tolower"))  
 setMethod("tm_tolower",  
           signature(object = "PlainTextDocument"),  
           function(object, ...) {  
               if (!Cached(object))  
                   object <- load_doc(object)  
   
               Corpus(object) <- tolower(object)  
               return(object)  
           })  
   
 setGeneric("strip_whitespace", function(object, ...) standardGeneric("strip_whitespace"))  
 setMethod("strip_whitespace",  
           signature(object = "PlainTextDocument"),  
           function(object, ...) {  
               if (!Cached(object))  
                   object <- load_doc(object)  
   
               Corpus(object) <- gsub("[[:space:]]+", " ", object)  
               return(object)  
           })  
   
 setGeneric("stem_doc", function(object, ...) standardGeneric("stem_doc"))  
 setMethod("stem_doc",  
           signature(object = "PlainTextDocument"),  
           function(object, ...) {  
               if (!Cached(object))  
                   object <- load_doc(object)  
   
               require(Rstem)  
               splittedCorpus <- unlist(strsplit(object, " ", fixed = TRUE))  
               stemmedCorpus <- wordStem(splittedCorpus)  
               Corpus(object) <- paste(stemmedCorpus, collapse = " ")  
               return(object)  
           })  
   
 setGeneric("remove_words", function(object, stopwords, ...) standardGeneric("remove_words"))  
 setMethod("remove_words",  
           signature(object = "PlainTextDocument", stopwords = "character"),  
           function(object, stopwords, ...) {  
               if (!Cached(object))  
                   object <- load_doc(object)  
   
               require(Rstem)  
               splittedCorpus <- unlist(strsplit(object, " ", fixed = TRUE))  
               noStopwordsCorpus <- splittedCorpus[!splittedCorpus %in% stopwords]  
               Corpus(object) <- paste(noStopwordsCorpus, collapse = " ")  
               return(object)  
           })  
   
 setGeneric("tm_filter", function(object, ..., FUN = s_filter, doclevel = FALSE) standardGeneric("tm_filter"))  
 setMethod("tm_filter",  
           signature(object = "TextDocCol"),  
           function(object, ..., FUN = s_filter, doclevel = FALSE) {  
               if (doclevel)  
                   return(object[sapply(object, FUN, ..., DMetaData = DMetaData(object))])  
               else  
                   return(object[FUN(object, ...)])  
           })  
   
 setGeneric("tm_index", function(object, ..., FUN = s_filter, doclevel = FALSE) standardGeneric("tm_index"))  
 setMethod("tm_index",  
           signature(object = "TextDocCol"),  
           function(object, ..., FUN = s_filter, doclevel = FALSE) {  
               if (doclevel)  
                   return(sapply(object, FUN, ..., DMetaData = DMetaData(object)))  
               else  
                   return(FUN(object, ...))  
           })  
   
 s_filter <- function(object, s, ...) {  
     query.df <- DMetaData(object)  
     con <- textConnection(s)  
     tokens <- scan(con, "character")  
     close(con)  
     local.meta <- lapply(object, LocalMetaData)  
     local.used.meta <- lapply(local.meta, function(x) names(x) %in% tokens)  
     l.meta <- NULL  
     for (i in 1:length(object)) {  
         l.meta <- c(l.meta, list(local.meta[[i]][local.used.meta[[i]]]))  
     }  
     # Load local meta data from text documents into data frame  
     for (i in 1:length(l.meta)) {  
         l.meta[[i]] <- c(l.meta[[i]], list(author = Author(object[[i]])))  
         l.meta[[i]] <- c(l.meta[[i]], list(datetimestamp = DateTimeStamp(object[[i]])))  
         l.meta[[i]] <- c(l.meta[[i]], list(description = Description(object[[i]])))  
         l.meta[[i]] <- c(l.meta[[i]], list(identifier = ID(object[[i]])))  
         l.meta[[i]] <- c(l.meta[[i]], list(origin = Origin(object[[i]])))  
         l.meta[[i]] <- c(l.meta[[i]], list(heading = Heading(object[[i]])))  
     }  
     # TODO: Handle entries (\code{m} with length greater 1, i.e., lists)  
     for (i in 1:length(l.meta)) {  
         for (j in 1:length(l.meta[[i]])) {  
             m <- l.meta[[i]][[j]]  
             m.name <- names(l.meta[[i]][j])  
             if (!(m.name %in% names(query.df))) {  
                 before <- rep(NA, i - 1)  
                 after <- rep(NA, length(l.meta) - i)  
                 insert <- c(before, m, after)  
                 query.df <- cbind(query.df, insert, stringsAsFactors = FALSE)  
                 names(query.df)[length(query.df)] <- m.name  
129              }              }
             else {  
                 if (is.null(m))  
                     m <- NA  
                 #if (length(m) > 1)  
                 #    query.df[i,names(l.meta[[i]])] <- list(m)  
                 #else  
                     query.df[i,m.name] <- m  
             }  
         }  
     }  
     attach(query.df)  
     try(result <- rownames(query.df) %in% row.names(query.df[eval(parse(text = s)), ]))  
     detach(query.df)  
     return(result)  
 }  
   
 #s_filter <- function(object, s, ..., DMetaData) {  
 #    b <- TRUE  
 #    for (tag in names(s)) {  
 #        if (tag %in% names(LocalMetaData(object))) {  
 #            b <- b && any(grep(s[[tag]], LocalMetaData(object)[[tag]]))  
 #        } else if (tag %in% names(DMetaData)){  
 #            b <- b && any(grep(s[[tag]], DMetaData[[tag]]))  
 #        } else {  
 #            b <- b && any(grep(s[[tag]], eval(call(tag, object))))  
 #        }  
 #    }  
 #    return(b)  
 #}  
   
 setGeneric("fulltext_search_filter", function(object, pattern, ...) standardGeneric("fulltext_search_filter"))  
 setMethod("fulltext_search_filter",  
           signature(object = "PlainTextDocument", pattern = "character"),  
           function(object, pattern, ...) {  
               if (!Cached(object))  
                   object <- load_doc(object)  
   
               return(any(grep(pattern, Corpus(object))))  
           })  
   
 setGeneric("attach_data", function(object, data) standardGeneric("attach_data"))  
 setGeneric("attach_metadata", function(object, name, metadata) standardGeneric("attach_metadata"))  
   
 setGeneric("append_doc", function(object, data, meta = NULL) standardGeneric("append_doc"))  
 setMethod("append_doc",  
           signature(object = "TextDocCol", data = "TextDocument"),  
           function(object, data, meta = NULL) {  
               object@.Data <- c(object@.Data, list(data))  
               if (length(meta) > 0)  
                   object@DMetaData <- rbind(object@DMetaData, c(MetaID = DCMetaData(object)@NodeID, meta))  
               return(object)  
           })  
   
 setGeneric("append_meta", function(object, dcmeta = list(), dmeta = NULL) standardGeneric("append_meta"))  
 setMethod("append_meta",  
           signature(object = "TextDocCol"),  
           function(object, dcmeta = list(), dmeta = NULL) {  
               object@DCMetaData@MetaData <- c(object@DCMetaData@MetaData, dcmeta)  
               if (length(dmeta) > 0)  
                   object@DMetaData <- cbind(object@DMetaData, dmeta)  
               return(object)  
           })  
   
 setGeneric("remove_metadata", function(object, name) standardGeneric("remove_metadata"))  
 #setMethod("remove_metadata",  
 #          signature(object = "TextDocCol"),  
 #          function(object, name) {  
 #              object@DMetaData <- DMetaData(object)[names(DMetaData(object)) != name]  
 #              return(object)  
 #          })  
   
 setGeneric("modify_metadata", function(object, name, metadata) standardGeneric("modify_metadata"))  
 #setMethod("modify_metadata",  
 #          signature(object = "TextDocCol"),  
 #          function(object, name, metadata) {  
 #              object@DMetaData[[name]] <- metadata  
 #              return(object)  
 #          })  
   
 # TODO: Handle metadata in document slots  
 setGeneric("prescind_meta", function(object, meta) standardGeneric("prescind_meta"))  
 setMethod("prescind_meta",  
           signature(object = "TextDocCol", meta = "character"),  
           function(object, meta) {  
               for (m in meta) {  
                   local.meta <- lapply(object, LocalMetaData)  
                   local.m <- lapply(local.meta, "[[", m)  
                   local.m <- lapply(local.m, function(x) if (is.null(x)) return(NA) else return(x))  
                   if (length(local.m) == length(unlist(local.m)))  
                       local.m <- unlist(local.m)  
                   else  
                       local.m <- I(local.m)  
                   object@DMetaData <- cbind(DMetaData(object), data.frame(m = local.m), stringsAsFactors = FALSE)  
                   names(object@DMetaData)[length(object@DMetaData)] <- m  
               }  
               return(object)  
           })  
   
 setMethod("[",  
           signature(x = "TextDocCol", i = "ANY", j = "ANY", drop = "ANY"),  
           function(x, i, j, ... , drop) {  
               if(missing(i))  
                   return(x)  
130    
131                object <- x  .map_name_index <- function(x, i) {
132                object@.Data <- x@.Data[i, ..., drop = FALSE]      if (is.character(i)) {
133                object@DMetaData <- DMetaData(object)[i, ]          if (is.null(names(x)))
134                return(object)              match(i, meta(x, "ID", type = "local"))
135            })          else
136                match(i, names(x))
137  setMethod("[<-",      }
138            signature(x = "TextDocCol", i = "ANY", j = "ANY", value = "ANY"),      i
139            function(x, i, j, ... , value) {  }
140                object <- x  
141                object@.Data[i, ...] <- value  `[[.PCorpus` <-  function(x, i) {
142                return(object)      i <- .map_name_index(x, i)
143            })      db <- filehash::dbInit(DBControl(x)[["dbName"]], DBControl(x)[["dbType"]])
144        filehash::dbFetch(db, NextMethod("[["))
145  setMethod("[[",  }
146            signature(x = "TextDocCol", i = "ANY", j = "ANY"),  `[[.VCorpus` <-  function(x, i) {
147            function(x, i, j, ...) {      i <- .map_name_index(x, i)
148                return(x@.Data[[i, ...]])      lazyTmMap <- meta(x, tag = "lazyTmMap", type = "corpus")
149            })      if (!is.null(lazyTmMap))
150            .Call("copyCorpus", x, materialize(x, i))
151  setMethod("[[<-",      NextMethod("[[")
152            signature(x = "TextDocCol", i = "ANY", j = "ANY", value = "ANY"),  }
153            function(x, i, j, ..., value) {  
154                object <- x  `[[<-.PCorpus` <-  function(x, i, value) {
155                object@.Data[[i, ...]] <- value      i <- .map_name_index(x, i)
156                return(object)      db <- filehash::dbInit(DBControl(x)[["dbName"]], DBControl(x)[["dbType"]])
157            })      index <- unclass(x)[[i]]
158        db[[index]] <- value
159  # Update \code{NodeID}s of a DCMetaData tree      x
160  # TODO: Avoid global variables outside of update_id function  }
161  update_id <- function(object) {  `[[<-.VCorpus` <-  function(x, i, value) {
162      id <<- 0      i <- .map_name_index(x, i)
163      mapping <<- left.mapping <<- NULL      # Mark new objects as not active for lazy mapping
164      level <<- 0      lazyTmMap <- meta(x, tag = "lazyTmMap", type = "corpus")
165      return(list(root = set_id(object), left.mapping = left.mapping, right.mapping = mapping))      if (!is.null(lazyTmMap)) {
166  }          lazyTmMap$index[i] <- FALSE
167            meta(x, tag = "lazyTmMap", type = "corpus") <- lazyTmMap
168  # Traversal of (binary) DCMetaData tree with setup of \code{NodeID}s      }
169  set_id <- function(object) {      # Set the value
170      object@NodeID <- id      cl <- class(x)
171        y <- NextMethod("[[<-")
172        class(y) <- cl
173        y
174    }
175    
176    # Update NodeIDs of a CMetaData tree
177    .update_id <- function(x, id = 0, mapping = NULL, left.mapping = NULL, level = 0) {
178        # Traversal of (binary) CMetaData tree with setup of NodeIDs
179        set_id <- function(x) {
180            x$NodeID <- id
181      id <<- id + 1      id <<- id + 1
182      level <<- level + 1      level <<- level + 1
183            if (length(x$Children) > 0) {
184      if (length(object@children) > 0) {              mapping <<- cbind(mapping, c(x$Children[[1]]$NodeID, id))
185          mapping <<- cbind(mapping, c(object@children[[1]]@NodeID, id))              left <- set_id(x$Children[[1]])
         left <- set_id(object@children[[1]])  
186          if (level == 1) {          if (level == 1) {
187              left.mapping <<- mapping              left.mapping <<- mapping
188              mapping <<- NULL              mapping <<- NULL
189          }          }
190          mapping <<- cbind(mapping, c(object@children[[2]]@NodeID, id))              mapping <<- cbind(mapping, c(x$Children[[2]]$NodeID, id))
191          right <- set_id(object@children[[2]])              right <- set_id(x$Children[[2]])
192    
193          object@children <- list(left, right)              x$Children <- list(left, right)
194      }      }
195      level <<- level - 1      level <<- level - 1
196            x
197      return(object)      }
198        list(root = set_id(x), left.mapping = left.mapping, right.mapping = mapping)
199  }  }
200    
201  setMethod("c",  # Find indices to be updated for a CMetaData tree
202            signature(x = "TextDocCol"),  .find_indices <- function(x) {
           function(x, y, ..., meta = list(merge_date = date(), merger = Sys.getenv("LOGNAME")), recursive = TRUE) {  
               if (!inherits(y, "TextDocCol"))  
                   stop("invalid argument")  
   
               object <- x  
               # Concatenate data slots  
               object@.Data <- c(as(x, "list"), as(y, "list"))  
   
               # Update the DCMetaData tree  
               dcmeta <- new("MetaDataNode", NodeID = 0, MetaData = meta, children = list(DCMetaData(x), DCMetaData(y)))  
               update.struct <- update_id(dcmeta)  
               object@DCMetaData <- update.struct$root  
   
               # Find indices to be updated for the left tree  
203                indices.mapping <- NULL                indices.mapping <- NULL
204                for (m in levels(as.factor(DMetaData(x)$MetaID))) {                for (m in levels(as.factor(DMetaData(x)$MetaID))) {
205                    indices <- (DMetaData(x)$MetaID == m)                    indices <- (DMetaData(x)$MetaID == m)
206                    indices.mapping <- c(indices.mapping, list(m = indices))                    indices.mapping <- c(indices.mapping, list(m = indices))
207                    names(indices.mapping)[length(indices.mapping)] <- m                    names(indices.mapping)[length(indices.mapping)] <- m
208                }                }
209        indices.mapping
210    }
211    
212    c2 <- function(x, y, ...) {
213        # Update the CMetaData tree
214        cmeta <- .MetaDataNode(0, list(merge_date = as.POSIXlt(Sys.time(), tz = "GMT"), merger = Sys.getenv("LOGNAME")), list(CMetaData(x), CMetaData(y)))
215        update.struct <- .update_id(cmeta)
216    
217        new <- .VCorpus(c(unclass(x), unclass(y)), update.struct$root, NULL)
218    
219        # Find indices to be updated for the left tree
220        indices.mapping <- .find_indices(x)
221    
222                # Update the DMetaData data frames for the left tree                # Update the DMetaData data frames for the left tree
223                for (i in 1:ncol(update.struct$left.mapping)) {                for (i in 1:ncol(update.struct$left.mapping)) {
224                    map <- update.struct$left.mapping[,i]                    map <- update.struct$left.mapping[,i]
225                    x@DMetaData$MetaID <- replace(DMetaData(x)$MetaID, indices.mapping[[as.character(map[1])]], map[2])          DMetaData(x)$MetaID <- replace(DMetaData(x)$MetaID, indices.mapping[[as.character(map[1])]], map[2])
226                }                }
227    
228                # Find indices to be updated for the right tree                # Find indices to be updated for the right tree
229                indices.mapping <- NULL      indices.mapping <- .find_indices(y)
               for (m in levels(as.factor(DMetaData(y)$MetaID))) {  
                   indices <- (DMetaData(y)$MetaID == m)  
                   indices.mapping <- c(indices.mapping, list(m = indices))  
                   names(indices.mapping)[length(indices.mapping)] <- m  
               }  
230    
231                # Update the DMetaData data frames for the right tree                # Update the DMetaData data frames for the right tree
232                for (i in 1:ncol(update.struct$right.mapping)) {                for (i in 1:ncol(update.struct$right.mapping)) {
233                    map <- update.struct$right.mapping[,i]                    map <- update.struct$right.mapping[,i]
234                    y@DMetaData$MetaID <- replace(DMetaData(y)$MetaID, indices.mapping[[as.character(map[1])]], map[2])          DMetaData(y)$MetaID <- replace(DMetaData(y)$MetaID, indices.mapping[[as.character(map[1])]], map[2])
235                }                }
236    
237                # Merge the DMetaData data frames                # Merge the DMetaData data frames
# Line 740  Line 241 
241                labels <- setdiff(names(DMetaData(x)), names(DMetaData(y)))                labels <- setdiff(names(DMetaData(x)), names(DMetaData(y)))
242                na.matrix <- matrix(NA, nrow = nrow(DMetaData(y)), ncol = length(labels), dimnames = list(row.names(DMetaData(y)), labels))                na.matrix <- matrix(NA, nrow = nrow(DMetaData(y)), ncol = length(labels), dimnames = list(row.names(DMetaData(y)), labels))
243                y.dmeta.aug <- cbind(DMetaData(y), na.matrix)                y.dmeta.aug <- cbind(DMetaData(y), na.matrix)
244                object@DMetaData <- rbind(x.dmeta.aug, y.dmeta.aug)      DMetaData(new) <- rbind(x.dmeta.aug, y.dmeta.aug)
245    
246        new
247    }
248    
249                return(object)  c.Corpus <-
250            })  function(x, ..., recursive = FALSE)
251  setMethod("c",  {
           signature(x = "TextDocument"),  
           function(x, ..., recursive = TRUE){  
252                args <- list(...)                args <- list(...)
253                if(length(args) == 0)  
254        if (identical(length(args), 0L))
255            return(x)
256    
257        if (!all(unlist(lapply(args, inherits, class(x)))))
258            stop("not all arguments are of the same corpus type")
259    
260        if (inherits(x, "PCorpus"))
261            stop("concatenation of corpora with underlying databases is not supported")
262    
263        l <- base::c(list(x), args)
264        if (recursive)
265            Reduce(c2, l)
266        else {
267            l <- do.call("c", lapply(l, unclass))
268            .VCorpus(l,
269                     cmeta = .MetaDataNode(),
270                     dmeta = data.frame(MetaID = rep(0, length(l)), stringsAsFactors = FALSE))
271        }
272    }
273    
274    c.TextDocument <- function(x, ..., recursive = FALSE) {
275        args <- list(...)
276    
277        if (identical(length(args), 0L))
278                    return(x)                    return(x)
279    
280                dmeta.df <- data.frame(MetaID = rep(0, length(list(x, ...))), stringsAsFactors = FALSE)      if (!all(unlist(lapply(args, inherits, class(x)))))
281                dcmeta.node <- new("MetaDataNode",          stop("not all arguments are text documents")
282                              NodeID = 0,  
283                              MetaData = list(create_date = date(), creator = Sys.getenv("LOGNAME")),      dmeta <- data.frame(MetaID = rep(0, length(list(x, ...))), stringsAsFactors = FALSE)
284                              children = list())      .VCorpus(list(x, ...), .MetaDataNode(), dmeta)
285    }
286                return(new("TextDocCol", .Data = list(x, ...), DMetaData = dmeta.df, DCMetaData = dcmeta.node))  
287            })  print.Corpus <- function(x, ...) {
288        cat(sprintf(ngettext(length(x),
289  setMethod("length",                           "A corpus with %d text document\n",
290            signature(x = "TextDocCol"),                           "A corpus with %d text documents\n"),
291            function(x){                  length(x)))
292                return(length(as(x, "list")))      invisible(x)
293      })  }
294    
295  setMethod("show",  summary.Corpus <- function(object, ...) {
296            signature(object = "TextDocCol"),      print(object)
           function(object){  
               cat(sprintf(ngettext(length(object),  
                                    "A text document collection with %d text document\n",  
                                    "A text document collection with %d text documents\n"),  
                           length(object)))  
     })  
   
 setMethod("summary",  
           signature(object = "TextDocCol"),  
           function(object){  
               show(object)  
297                if (length(DMetaData(object)) > 0) {                if (length(DMetaData(object)) > 0) {
298                    cat(sprintf(ngettext(length(DMetaData(object)),          cat(sprintf(ngettext(length(attr(CMetaData(object), "MetaData")),
299                                                "\nThe global metadata consists of %d tag-value pair\n",                               "\nThe metadata consists of %d tag-value pair and a data frame\n",
300                                                "\nThe global metadata consists of %d tag-value pairs\n"),                               "\nThe metadata consists of %d tag-value pairs and a data frame\n"),
301                                         length(DMetaData(object))))                      length(CMetaData(object)$MetaData)))
302                    cat("Available tags are:\n")                    cat("Available tags are:\n")
303                    cat(names(DMetaData(object)), "\n")          cat(strwrap(paste(names(CMetaData(object)$MetaData), collapse = " "), indent = 2, exdent = 2), "\n")
304            cat("Available variables in the data frame are:\n")
305            cat(strwrap(paste(names(DMetaData(object)), collapse = " "), indent = 2, exdent = 2), "\n")
306        }
307                }                }
     })  
308    
309  setGeneric("inspect", function(object) standardGeneric("inspect"))  inspect <- function(x) UseMethod("inspect", x)
310  setMethod("inspect",  inspect.PCorpus <- function(x) {
311            signature("TextDocCol"),      summary(x)
           function(object) {  
               summary(object)  
312                cat("\n")                cat("\n")
313                show(as(object, "list"))      db <- filehash::dbInit(DBControl(x)[["dbName"]], DBControl(x)[["dbType"]])
314            })      show(filehash::dbMultiFetch(db, unlist(x)))
315    }
316    inspect.VCorpus <- function(x) {
317        summary(x)
318        cat("\n")
319        print(noquote(lapply(x, identity)))
320    }
321    
322  # No metadata is checked  lapply.PCorpus <- function(X, FUN, ...) {
323  setGeneric("%IN%", function(x, y) standardGeneric("%IN%"))      db <- filehash::dbInit(DBControl(X)[["dbName"]], DBControl(X)[["dbType"]])
324  setMethod("%IN%",      lapply(filehash::dbMultiFetch(db, unlist(X)), FUN, ...)
325            signature(x = "TextDocument", y = "TextDocCol"),  }
326            function(x, y) {  lapply.VCorpus <- function(X, FUN, ...) {
327                x %in% y      lazyTmMap <- meta(X, tag = "lazyTmMap", type = "corpus")
328            })      if (!is.null(lazyTmMap))
329            .Call("copyCorpus", X, materialize(X))
330        base::lapply(X, FUN, ...)
331    }
332    
333    writeCorpus <-  function(x, path = ".", filenames = NULL) {
334        filenames <- file.path(path,
335                               if (is.null(filenames)) unlist(lapply(x, function(x) sprintf("%s.txt", ID(x))))
336                               else filenames)
337        i <- 1
338        for (o in x) {
339            writeLines(as.PlainTextDocument(o), filenames[i])
340            i <- i + 1
341        }
342    }

Legend:
Removed from v.74  
changed lines
  Added in v.1114

root@r-forge.r-project.org
ViewVC Help
Powered by ViewVC 1.0.0  
Thanks to:
Vienna University of Economics and Business Powered By FusionForge