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/textmin/R/textdoccol.R revision 78, Wed Nov 29 14:56:36 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 = "")  
         }  
         else {  
             doc <- new("PlainTextDocument", URI = elem$uri, Cached = FALSE,  
                        Author = "", DateTimeStamp = date(), Description = "", ID = id, Origin = "", Heading = "")  
51          }          }
52    
53          return(doc)  .VCorpus <- function(x, cmeta, dmeta) {
54        attr(x, "CMetaData") <- cmeta
55        attr(x, "DMetaData") <- dmeta
56        class(x) <- c("VCorpus", "Corpus", "list")
57        x
58      }      }
 }  
 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)  
   
         # Mask as list to bypass S4 checks  
         class(tree) <- "list"  
59    
60          # The <AUTHOR></AUTHOR> tag is unfortunately NOT obligatory!  # Register S3 corpus classes to be recognized by S4 methods. This is
61          if (!is.null(node[["TEXT"]][["AUTHOR"]]))  # mainly a fix to be compatible with packages which were originally
62              author <- xmlValue(node[["TEXT"]][["AUTHOR"]])  # developed to cooperate with corresponding S4 tm classes. Necessary
63          else  # since tm's class architecture was changed to S3 since tm version 0.5.
64              author <- ""  setOldClass(c("VCorpus", "Corpus", "list"))
   
         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 <- ""  
65    
66          topics <- unlist(xmlApply(node[["TOPICS"]], function(x) xmlValue(x)), use.names = FALSE)  # The "..." are additional arguments for the FunctionGenerator reader
67    VCorpus <- Corpus <- function(x,
68                                  readerControl = list(reader = x$DefaultReader, language = "en"),
69                                  ...) {
70        readerControl <- prepareReader(readerControl, x$DefaultReader, ...)
71    
72          if (!lodsupport || (lodsupport && load)) {      if (is.function(readerControl$init))
73              doc <- new("XMLTextDocument", .Data = tree, URI = elem$uri, Cached = TRUE, Author = author,          readerControl$init()
                        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))  
         }  
   
         return(doc)  
     }  
 }  
 class(reut21578xml_parser) <- "function_generator"  
   
 rcv1_parser <- function(...) {  
     function(elem, lodsupport, load, id) {  
         corpus <- paste(elem$content, "\n", collapse = "")  
         tree <- xmlTreeParse(corpus, asText = TRUE)  
         node <- xmlRoot(tree)  
   
         # Mask as list to bypass S4 checks  
         class(tree) <- "list"  
   
         datetimestamp <- xmlAttrs(node)[["date"]]  
         id <- xmlAttrs(node)[["itemid"]]  
         heading <- xmlValue(node[["title"]])  
   
         if (!lodsupport || (lodsupport && load)) {  
             doc <- new("XMLTextDocument", .Data = tree, URI = elem$uri, Cached = TRUE, Author = "",  
                        DateTimeStamp = datetimestamp, Description = "", ID = id, Origin = "Reuters Corpus Volume 1 XML",  
                        Heading = heading)  
         } else {  
             doc <- new("XMLTextDocument", URI = elem$uri, Cached = FALSE, Author = "",  
                        DateTimeStamp = datetimestamp, Description = "", ID = id, Origin = "Reuters Corpus Volume 1 XML",  
                        Heading = heading)  
         }  
   
         return(doc)  
     }  
 }  
 class(rcv1_parser) <- "function_generator"  
74    
75  newsgroup_parser <- function(...) {      if (is.function(readerControl$exit))
76      function(elem, lodsupport, load, id) {          on.exit(readerControl$exit())
         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))  
77    
78          if (!lodsupport || (lodsupport && load)) {      # Allocate memory in advance if length is known
79              # The header is separated from the body by a blank line.      tdl <- if (x$Length > 0)
80              # Reference: \url{http://en.wikipedia.org/wiki/E-mail#Internet_e-mail_format}          vector("list", as.integer(x$Length))
81              for (index in seq(along = mail)) {      else
82                  if (mail[index] == "")          list()
                     break  
             }  
             content <- mail[(index + 1):length(mail)]  
83    
84              doc <- new("NewsgroupDocument", .Data = content, URI = elem$uri, Cached = TRUE,      if (x$Vectorized)
85                         Author = author, DateTimeStamp = datetimestamp,          tdl <- mapply(function(x, id) readerControl$reader(x, readerControl$language, id),
86                         Description = "", ID = id, Origin = origin,                        pGetElem(x),
87                         Heading = heading, Newsgroup = newsgroup)                        id = if (is.null(x$Names)) as.character(seq_len(x$Length)) else x$Names,
88          } else {                        SIMPLIFY = FALSE)
89              doc <- new("NewsgroupDocument", URI = elem$uri, Cached = FALSE, Author = author, DateTimeStamp = datetimestamp,      else {
90                         Description = "", ID = id, Origin = origin, Heading = heading, Newsgroup = newsgroup)          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          }          }
   
         return(doc)  
101      }      }
102        names(tdl) <- x$Names
103        df <- data.frame(MetaID = rep(0, length(tdl)), stringsAsFactors = FALSE)
104        .VCorpus(tdl, .MetaDataNode(), df)
105  }  }
 class(newsgroup_parser) <- "function_generator"  
106    
107  # Parse a <newsitem></newsitem> element from a well-formed RCV1 XML file  `[.PCorpus` <- function(x, i) {
108  rcv1_to_plain <- function(node, ...) {      if (missing(i)) return(x)
109      datetimestamp <- xmlAttrs(node)[["date"]]      index <- attr(x, "DMetaData")[[1 , "subset"]]
110      id <- xmlAttrs(node)[["itemid"]]      attr(x, "DMetaData")[[1 , "subset"]] <- if (is.numeric(index)) index[i] else i
111      origin <- "Reuters Corpus Volume 1 XML"      dmeta <- attr(x, "DMetaData")
112      corpus <- unlist(xmlApply(node[["text"]], xmlValue), use.names = FALSE)      .PCorpus(NextMethod("["), CMetaData(x), dmeta, DBControl(x))
     heading <- xmlValue(node[["title"]])  
   
     new("PlainTextDocument", .Data = corpus, Cached = TRUE, URI = "", Author = "", DateTimeStamp = datetimestamp,  
         Description = "", ID = id, Origin = "Reuters Corpus Volume 1 XML", Heading = heading)  
113  }  }
114    
115  # Parse a <REUTERS></REUTERS> element from a well-formed Reuters-21578 XML file  `[.VCorpus` <- function(x, i) {
116  reut21578xml_to_plain <- function(node, ...) {      if (missing(i)) return(x)
117      # The <AUTHOR></AUTHOR> tag is unfortunately NOT obligatory!      .VCorpus(NextMethod("["), CMetaData(x), DMetaData(x)[i, , drop = FALSE])
     if (!is.null(node[["TEXT"]][["AUTHOR"]]))  
         author <- xmlValue(node[["TEXT"]][["AUTHOR"]])  
     else  
         author <- ""  
   
     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))  
118  }  }
119    
120  setGeneric("load_doc", function(object, ...) standardGeneric("load_doc"))  `[<-.PCorpus` <- function(x, i, value) {
121  setMethod("load_doc",      db <- filehash::dbInit(DBControl(x)[["dbName"]], DBControl(x)[["dbType"]])
122            signature(object = "PlainTextDocument"),      counter <- 1
123            function(object, ...) {      for (id in unclass(x)[i]) {
124                if (!Cached(object)) {          if (identical(length(value), 1L)) db[[id]] <- value
125                    con <- eval(URI(object))          else db[[id]] <- value[[counter]]
126                    corpus <- readLines(con)          counter <- counter + 1
                   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]])))  
     }  
     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)  
                 if (length(m) > 1) {  
                     nl <- vector("list", length(l.meta))  
                     nl[1:(i-1)] <- before  
                     nl[i] <- list(m)  
                     nl[(i+1):length(l.meta)] <- after  
                     insert <- data.frame(I(nl), stringsAsFactors = FALSE)  
                 }  
                 else  
                     insert <- c(before, m, after)  
                 query.df <- cbind(query.df, insert, stringsAsFactors = FALSE)  
                 names(query.df)[length(query.df)] <- m.name  
             }  
             else {  
                 if (is.null(m))  
                     m <- NA  
                 if (length(m) > 1) {  
                     rl <- query.df[ , m.name]  
                     rl[i] <- list(m)  
                     query.df[ , m.name] <- data.frame(I(rl), stringsAsFactors = FALSE)  
                 }  
                 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)  
 }  
   
 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("append_elem", function(object, data, meta = NULL) standardGeneric("append_elem"))  
 setMethod("append_elem",  
           signature(object = "TextDocCol", data = "TextDocument"),  
           function(object, data, meta = NULL) {  
               object@.Data[[length(object)+1]] <- data  
               object@DMetaData <- rbind(object@DMetaData, c(MetaID = DCMetaData(object)@NodeID, meta))  
               return(object)  
           })  
   
 setGeneric("append_meta", function(object, dcmeta = NULL, dmeta = NULL) standardGeneric("append_meta"))  
 setMethod("append_meta",  
           signature(object = "TextDocCol"),  
           function(object, dcmeta = NULL, dmeta = NULL) {  
               object@DCMetaData@MetaData <- c(object@DCMetaData@MetaData, dcmeta)  
               if (!is.null(dcmeta))  
                   object@DMetaData <- cbind(object@DMetaData, dmeta)  
               return(object)  
           })  
   
 setGeneric("remove_meta", function(object, dcname = NULL, dname = NULL) standardGeneric("remove_meta"))  
 setMethod("remove_meta",  
           signature(object = "TextDocCol"),  
           function(object, dcname = NULL, dname = NULL) {  
               if (!is.null(dcname)) {  
                   object@DCMetaData@MetaData <- DCMetaData(object)@MetaData[names(DCMetaData(object)@MetaData) != dcname]  
               }  
               if (!is.null(dname)) {  
                   object@DMetaData <- DMetaData(object)[names(DMetaData(object)) != dname]  
               }  
               return(object)  
           })  
   
 setGeneric("prescind_meta", function(object, meta) standardGeneric("prescind_meta"))  
 setMethod("prescind_meta",  
           signature(object = "TextDocCol", meta = "character"),  
           function(object, meta) {  
               for (m in meta) {  
                   if (m %in% c("Author", "DateTimeStamp", "Description", "ID", "Origin", "Heading")) {  
                       local.m <- lapply(object, m)  
                       local.m <- lapply(local.m, function(x) if (is.null(x)) return(NA) else return(x))  
                       local.m <- unlist(local.m)  
                       object@DMetaData <- cbind(DMetaData(object), data.frame(m = local.m), stringsAsFactors = FALSE)  
                       names(object@DMetaData)[length(object@DMetaData)] <- m  
                   }  
                   else {  
                       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  
127                    }                    }
128        x
129                }                }
               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                df <- as.data.frame(DMetaData(object)[i, ])          if (is.null(names(x)))
134                names(df) <- names(DMetaData(object))              match(i, meta(x, "ID", type = "local"))
135                object@DMetaData <- df          else
136                return(object)              match(i, names(x))
137            })      }
138        i
139  setMethod("[<-",  }
140            signature(x = "TextDocCol", i = "ANY", j = "ANY", value = "ANY"),  
141            function(x, i, j, ... , value) {  `[[.PCorpus` <-  function(x, i) {
142                object <- x      i <- .map_name_index(x, i)
143                object@.Data[i, ...] <- value      db <- filehash::dbInit(DBControl(x)[["dbName"]], DBControl(x)[["dbType"]])
144                return(object)      filehash::dbFetch(db, NextMethod("[["))
145            })  }
146    `[[.VCorpus` <-  function(x, i) {
147  setMethod("[[",      i <- .map_name_index(x, i)
148            signature(x = "TextDocCol", i = "ANY", j = "ANY"),      lazyTmMap <- meta(x, tag = "lazyTmMap", type = "corpus")
149            function(x, i, j, ...) {      if (!is.null(lazyTmMap))
150                return(x@.Data[[i, ...]])          .Call("copyCorpus", x, materialize(x, i))
151            })      NextMethod("[[")
152    }
153  setMethod("[[<-",  
154            signature(x = "TextDocCol", i = "ANY", j = "ANY", value = "ANY"),  `[[<-.PCorpus` <-  function(x, i, value) {
155            function(x, i, j, ..., value) {      i <- .map_name_index(x, i)
156                object <- x      db <- filehash::dbInit(DBControl(x)[["dbName"]], DBControl(x)[["dbType"]])
157                object@.Data[[i, ...]] <- value      index <- unclass(x)[[i]]
158                return(object)      db[[index]] <- value
159            })      x
160    }
161  # Update \code{NodeID}s of a DCMetaData tree  `[[<-.VCorpus` <-  function(x, i, value) {
162  # TODO: Avoid global variables outside of update_id function      i <- .map_name_index(x, i)
163  update_id <- function(object) {      # Mark new objects as not active for lazy mapping
164      id <<- 0      lazyTmMap <- meta(x, tag = "lazyTmMap", type = "corpus")
165      mapping <<- left.mapping <<- NULL      if (!is.null(lazyTmMap)) {
166      level <<- 0          lazyTmMap$index[i] <- FALSE
167      return(list(root = set_id(object), left.mapping = left.mapping, right.mapping = mapping))          meta(x, tag = "lazyTmMap", type = "corpus") <- lazyTmMap
168  }      }
169        # Set the value
170  # Traversal of (binary) DCMetaData tree with setup of \code{NodeID}s      cl <- class(x)
171  set_id <- function(object) {      y <- NextMethod("[[<-")
172      object@NodeID <- id      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 739  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                return(object)      new
247            })  }
248  setMethod("c",  
249            signature(x = "TextDocument"),  c.Corpus <-
250            function(x, ..., recursive = TRUE){  function(x, ..., recursive = FALSE)
251    {
252        args <- list(...)
253    
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(...)                args <- list(...)
276                if(length(args) == 0)  
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(DCMetaData(object)@MetaData),          cat(sprintf(ngettext(length(attr(CMetaData(object), "MetaData")),
299                                                "\nThe metadata consists of %d tag-value pair and a data frame\n",                                                "\nThe metadata consists of %d tag-value pair and a data frame\n",
300                                                "\nThe metadata consists of %d tag-value pairs and a data frame\n"),                                                "\nThe metadata consists of %d tag-value pairs and a data frame\n"),
301                                         length(DCMetaData(object)@MetaData)))                      length(CMetaData(object)$MetaData)))
302                    cat("Available tags are:\n")                    cat("Available tags are:\n")
303                    cat(names(DCMetaData(object)@MetaData), "\n")          cat(strwrap(paste(names(CMetaData(object)$MetaData), collapse = " "), indent = 2, exdent = 2), "\n")
304                    cat("Available variables in the data frame are:\n")                    cat("Available variables in the data frame are:\n")
305                    cat(names(DMetaData(object)), "\n")          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)
312            function(object) {      cat("\n")
313                summary(object)      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")                cat("\n")
319                show(as(object, "list"))      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.78  
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