taskjuggler 0.0.3 → 0.0.4

data/lib/BatchProcessor.rb

@@ -1,9 +1,9 @@
 #!/usr/bin/env ruby -w
 # encoding: UTF-8
 #
-# = Project.rb -- The TaskJuggler III Project Management Software
+# = BatchProcessor.rb -- The TaskJuggler III Project Management Software
 #
-# Copyright (c) 2006, 2007, 2008, 2009 by Chris Schlaeger <cs@kde.org>
+# Copyright (c) 2006, 2007, 2008, 2009, 2010 by Chris Schlaeger <cs@kde.org>
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of version 2 of the GNU General Public License as
@@ -21,8 +21,8 @@ class TaskJuggler
   class JobInfo
 
     attr_reader :jobId, :block, :tag
-    attr_accessor :pid, :retVal, :stdoutP, :stdoutC, :stdout,
-                  :stderrP, :stderrC, :stderr
+    attr_accessor :pid, :retVal, :stdoutP, :stdoutC, :stdout, :stdoutEOT,
+                  :stderrP, :stderrC, :stderr, :stderrEOT
 
     def initialize(jobId, block, tag)
       # The job id. A unique number that is used by the BatchProcessor objects
@@ -34,13 +34,22 @@ class TaskJuggler
       # to uniquely identify the job.
       @tag = tag
       # The pipe to transfer stdout data from the child to the parent.
-      @stdoutP, @stdoutC = IO.pipe
+      @stdoutP, @stdoutC = nil
       # The stdout output of the child
       @stdout = ''
+      # This flag is set to true when the EOT character has been received.
+      @stdoutEOF = false
       # The pipe to transfer stderr data from the child to the parent.
-      @stderrP, @stderrC = IO.pipe
+      @stderrP, @stderrC = nil
       # The stderr output of the child
       @stderr = ''
+      # This flag is set to true when the EOT character has been received.
+      @stderrEOT = false
+    end
+
+    def openPipes
+      @stdoutP, @stdoutC = IO.pipe
+      @stderrP, @stderrC = IO.pipe
     end
 
   end
@@ -50,7 +59,7 @@ class TaskJuggler
   # executed in parallel. The number of CPU cores to use is limited at object
   # creation time. The submitted jobs will be queued and scheduled to the
   # given number of CPUs. The usage model is simple. Create an BatchProcessor
-  # object. use BatchProcessor#queue to submit all the jobs and then use
+  # object. Use BatchProcessor#queue to submit all the jobs and then use
   # BatchProcessor#wait to wait for completion and to process the results.
   class BatchProcessor
 
@@ -58,59 +67,89 @@ class TaskJuggler
     # simultaneously spawned processes.
     def initialize(maxCpuCores)
       @maxCpuCores = maxCpuCores
-      # The job queue.
-      @queue = Queue.new
-      # A semaphore to guard accesses to shared data structures.`
+      # Jobs submitted by calling queue() are put in the @toRunQueue. The
+      # pusher Thread will pick them up and fork them off into another
+      # process.
+      @toRunQueue = Queue.new
+      # A hash that maps the JobInfo objects of running jobs by their PID.
+      @runningJobs = { }
+      # A list of jobs that wait to complete their writing.
+      @spoolingJobs = [ ]
+      # The wait() method will then clean the @toDropQueue, executes the post
+      # processing block and removes all JobInfo related objects.
+      @toDropQueue = Queue.new
+
+      # A semaphore to guard accesses to @runningJobs, @spoolingJobs and
+      # following shared data structures.
       @lock = Monitor.new
-      # A hash that maps process ids to JobInfo objects.
-      @jobs = { }
-      # Counts the number of pending processes.
-      @pendingJobs = 0
+      # We count the submitted and completed jobs. The @jobsIn counter also
+      # doubles as a unique job ID.
+      @jobsIn = @jobsOut = 0
       # An Array that holds all the IO objects to receive data from.
       @pipes = []
       # A hash that maps IO objects to JobInfo objects
       @pipeToJob = {}
+
       # This global flag is set to true to signal the threads to terminate.
       @terminate = false
-      # Sleep time of the threads when no data is pending.
-      @timeout = 0.05
+      # Sleep time of the threads when no data is pending. This value must be
+      # large enough to allow for a context switch between the sending
+      # (forked-off) process and this process. If it's too large, throughput
+      # will suffer.
+      @timeout = 0.02
 
       Thread.abort_on_exception = true
-      # The JobInfo objects in the @queue are processed by the pusher thread.
-      # It forkes off processes to execute the code block associated with the
-      # JobInfo.
-      @pusher = Thread.new { pusher }
-      # The popper thread waits for terminated childs and picks up the
-      # results.
-      @popper = Thread.new { popper }
-      # The grabber thread collects $stdout and $stderr data from each child
-      # process and stores them in the corresponding JobInfo.
-      @grabber = Thread.new { grabber }
     end
 
     # Add a new job the job queue. +tag+ is some data that the caller can use
     # to identify the job upon completion. +block+ is a Ruby code block to be
     # executed in a separate process.
     def queue(tag = nil, &block)
-      # Create a new JobInfo object for the job and push it to the @queue.
-      jobInfo = JobInfo.new(@queue.length, block, tag)
-      @queue.push(jobInfo)
-      @lock.synchronize do
-        # Add the receiver end of the pipe to the @pipes Array.
-        @pipes << jobInfo.stdoutP
-        # Map the pipe end to this JobInfo object.
-        @pipeToJob[jobInfo.stdoutP] = jobInfo
-        # Same for $stderr.
-        @pipes << jobInfo.stderrP
-        @pipeToJob[jobInfo.stderrP] = jobInfo
+      raise 'You cannot call queue() while wait() is running!' if @jobsOut > 0
+
+      # If this is the first queued job for this run, we have to start the
+      # helper threads.
+      if @jobsIn == 0
+        # The JobInfo objects in the @toRunQueue are processed by the pusher
+        # thread.  It forkes off processes to execute the code block associated
+        # with the JobInfo.
+        @pusher = Thread.new { pusher }
+        # The popper thread waits for terminated childs and picks up the
+        # results.
+        @popper = Thread.new { popper }
+        # The grabber thread collects $stdout and $stderr data from each child
+        # process and stores them in the corresponding JobInfo.
+        @grabber = Thread.new { grabber }
       end
+
+      # Create a new JobInfo object for the job and push it to the @toRunQueue.
+      job = JobInfo.new(@jobsIn, block, tag)
+      # Increase job counter
+      @lock.synchronize { @jobsIn += 1 }
+      @toRunQueue.push(job)
     end
 
     # Wait for all jobs to complete. The code block will get the JobInfo
     # objects for each job to pick up the results.
     def wait
-      while !@queue.empty? || @pendingJobs > 0 do
-        sleep(@timeout)
+      # When we have received as many jobs in the @toDropQueue than we have
+      # started then we're done.
+      while !@lock.synchronize { @jobsIn == @jobsOut }
+        if @toDropQueue.empty?
+          sleep(@timeout)
+        else
+          # We have completed jobs.
+          while !@toDropQueue.empty?
+            # Pop a job from the @toDropQueue and call the block with it.
+            job = @toDropQueue.pop
+            # Remove the job related entries from the housekeeping tables.
+            @lock.synchronize { @jobsOut += 1 }
+
+            # Call the post-processing block that was passed to wait() with
+            # the JobInfo object as argument.
+            yield(job)
+          end
+        end
       end
 
       # Signal threads to stop
@@ -120,38 +159,59 @@ class TaskJuggler
       @popper.join
       @grabber.join
 
-      # Pass the results of the jobs to the caller.
-      @jobs.each_value { |job| yield(job) }
+      # Reset some variables so we can reuse the object for further job runs.
+      @jobsIn = @jobsOut = 0
+      @terminate = false
+
+      # Make sure all data structures are empty and clean.
+      check
     end
 
     private
 
     # This function runs in a separate thread to pop JobInfo items from the
-    # @queue and create child processes for them.
+    # @toRunQueue and create child processes for them.
     def pusher
       # Run until the terminate flag is set.
       until @terminate
-        if @queue.empty? || @pendingJobs >= @maxCpuCores
-          # We have no jobs in the @queue or all CPU cores in use already.
+        if @toRunQueue.empty? || @runningJobs.length >= @maxCpuCores
+          # We have no jobs in the @toRunQueue or all CPU cores in use already.
           sleep(@timeout)
         else
-          # Get a new job from the @queue
-          job = @queue.pop
-          job.pid = fork do
-            # This is the child process now. Connect $stdout and $stderr to
-            # the pipes.
-            $stdout.reopen(job.stdoutC)
-            job.stdoutC.close
-            $stderr.reopen(job.stderrC)
-            job.stderrC.close
-            # Call the Ruby code block
-            job.block.call
-          end
+          # Get a new job from the @toRunQueue
+          job = @toRunQueue.pop
+
+          job.openPipes
+          # Add the receiver end of the pipe to the @pipes Array.
+          @pipes << job.stdoutP
+          # Map the pipe end to this JobInfo object.
+          @pipeToJob[job.stdoutP] = job
+          # Same for $stderr.
+          @pipes << job.stderrP
+          @pipeToJob[job.stderrP] = job
+
           @lock.synchronize do
+            pid = fork do
+              # This is the child process now. Connect $stdout and $stderr to
+              # the pipes.
+              $stdout.reopen(job.stdoutC)
+              job.stdoutC.close
+              $stderr.reopen(job.stderrC)
+              job.stderrC.close
+              # Call the Ruby code block
+              retVal = job.block.call
+              # Send EOT character to mark the end of the text.
+              $stdout.putc 4
+              $stdout.close
+              $stderr.putc 4
+              $stderr.close
+              # Now exit the child process and return the return value of the
+              # block as process return value.
+              exit retVal
+            end
+            job.pid = pid
             # Save the process ID in the PID to JobInfo hash.
-            @jobs[job.pid] = job
-            # Increase the jobs-in-flight counter.
-            @pendingJobs += 1
+            @runningJobs[pid] = job
           end
         end
       end
@@ -162,20 +222,31 @@ class TaskJuggler
     # corresponding JobInfo object.
     def popper
       until @terminate
-        if @pendingJobs == 0
+        if @runningJobs.empty?
           # No pending jobs, wait a bit.
           sleep(@timeout)
         else
           # Wait for the next job to complete.
           pid, retVal = Process.wait2
+          job = nil
           @lock.synchronize do
             # Get the JobInfo object that corresponds to the process ID.
-            job = @jobs[pid]
-            raise "Unknown job" if pid.nil?
+            job = @runningJobs[pid]
+            raise "Unknown pid #{pid}" if job.nil?
+            # Remove the job from the @runningJobs Hash.
+            @runningJobs.delete(pid)
             # Save the return value.
-            job.retVal = retVal
-            # We have one less job to worry about.
-            @pendingJobs -= 1
+            job.retVal = retVal.dup
+            if retVal.signaled?
+              cleanPipes(job)
+              # Aborted jobs will probably not send an EOT. So we fastrack
+              # them to the toDropQueue.
+              @toDropQueue.push(job)
+            else
+              # Push the job into the @spoolingJobs list to wait for it to
+              # finish writing IO.
+              @spoolingJobs << job
+            end
           end
         end
       end
@@ -186,24 +257,80 @@ class TaskJuggler
     # object that corresponds to each child process.
     def grabber
       until @terminate
-        # Wait for output in any of the pipes or a timeout.
-        if (res = select(@pipes, nil, nil, @timeout))
-          # We have output data from at least one child. Check which pipe
-          # actually triggered the select.
-          res[0].each do |pipe|
-            # Find the corresponding JobInfo object.
-            job = @pipeToJob[pipe]
-            # Store the output.
-            if pipe == job.stdoutP
-              job.stdout << pipe.getc
-            else
-              job.stderr << pipe.getc
+        # Wait for output in any of the pipes or a timeout. To make sure that
+        # we get all output, we remain in the loop until the select() call
+        # times out.
+        res = nil
+        begin
+          @lock.synchronize do
+            if (res = select(@pipes, nil, @pipes, @timeout))
+              # We have output data from at least one child. Check which pipe
+              # actually triggered the select.
+              res[0].each do |pipe|
+                # Find the corresponding JobInfo object.
+                job = @pipeToJob[pipe]
+                # Store the output.
+                if pipe == job.stdoutP
+                  # Look for the EOT character to signal the end of the text.
+                  if (c = pipe.getc) == ?\004
+                    job.stdoutEOT = true
+                  else
+                    job.stdout << c
+                  end
+                else
+                  if (c = pipe.getc) == ?\004
+                    job.stderrEOT = true
+                  else
+                    job.stderr << c
+                  end
+                end
+              end
+            end
+          end
+          sleep(@timeout) unless res
+        end while res
+
+        # Search the @spoolingJobs list for jobs that have completed IO and
+        # push them to the @toDropQueue.
+        @lock.synchronize do
+          @spoolingJobs.each do |job|
+            # Both stdout and stderr need to have reached the end of text.
+            if job.stdoutEOT && job.stderrEOT
+              @spoolingJobs.delete(job)
+              cleanPipes(job)
+              @toDropQueue.push(job)
+              # Since we deleted a list item during an iterator run, we
+              # terminate the iterator.
+              break
             end
           end
         end
       end
     end
 
+    def cleanPipes(job)
+      @pipes.delete(job.stdoutP)
+      @pipeToJob.delete(job.stdoutP)
+      @pipes.delete(job.stderrP)
+      @pipeToJob.delete(job.stderrP)
+      job.stdoutC.close
+      job.stdoutP.close
+      job.stderrC.close
+      job.stderrP.close
+      job.stdoutC = job.stderrC = nil
+      job.stdoutP = job.stderrP = nil
+    end
+
+    def check
+      raise "toRunQueue not empty!" unless @toRunQueue.empty?
+      raise "runningJobs list not empty!" unless @runningJobs.empty?
+      raise "spoolingJobs list not empty!" unless @spoolingJobs.empty?
+      raise "toDropQueue not empty!" unless @toDropQueue.empty?
+
+      raise "pipe list not empty!" unless @pipes.empty?
+      raise "pipe map not empty!" unless @pipeToJob.empty?
+    end
+
   end
 
 end

data/lib/Booking.rb

@@ -3,7 +3,7 @@
 #
 # = Booking.rb -- The TaskJuggler III Project Management Software
 #
-# Copyright (c) 2006, 2007, 2008, 2009 by Chris Schlaeger <cs@kde.org>
+# Copyright (c) 2006, 2007, 2008, 2009, 2010 by Chris Schlaeger <cs@kde.org>
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of version 2 of the GNU General Public License as

data/lib/Charge.rb

@@ -3,7 +3,7 @@
 #
 # = Charge.rb -- The TaskJuggler III Project Management Software
 #
-# Copyright (c) 2006, 2007, 2008, 2009 by Chris Schlaeger <cs@kde.org>
+# Copyright (c) 2006, 2007, 2008, 2009, 2010 by Chris Schlaeger <cs@kde.org>
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of version 2 of the GNU General Public License as

data/lib/ChargeSet.rb

@@ -3,7 +3,7 @@
 #
 # = ChargeSet.rb -- The TaskJuggler III Project Management Software
 #
-# Copyright (c) 2006, 2007, 2008, 2009 by Chris Schlaeger <cs@kde.org>
+# Copyright (c) 2006, 2007, 2008, 2009, 2010 by Chris Schlaeger <cs@kde.org>
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of version 2 of the GNU General Public License as

data/lib/HTMLDocument.rb

@@ -3,7 +3,7 @@
 #
 # = HTMLDocument.rb -- The TaskJuggler III Project Management Software
 #
-# Copyright (c) 2006, 2007, 2008, 2009 by Chris Schlaeger <cs@kde.org>
+# Copyright (c) 2006, 2007, 2008, 2009, 2010 by Chris Schlaeger <cs@kde.org>
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of version 2 of the GNU General Public License as
@@ -25,7 +25,7 @@ class TaskJuggler
     def initialize(docType = :transitional)
       super()
 
-      @elements << XMLBlob.new('<?xml version="1.0" encoding="utf8"?>')
+      @elements << XMLBlob.new('<?xml version="1.0" encoding="utf-8"?>')
       case docType
       when :strict
         dtdRef = 'Strict'

data/lib/Interval.rb

@@ -3,7 +3,7 @@
 #
 # = Interval.rb -- The TaskJuggler III Project Management Software
 #
-# Copyright (c) 2006, 2007, 2008, 2009 by Chris Schlaeger <cs@kde.org>
+# Copyright (c) 2006, 2007, 2008, 2009, 2010 by Chris Schlaeger <cs@kde.org>
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of version 2 of the GNU General Public License as

data/lib/Journal.rb

@@ -1,9 +1,9 @@
 #!/usr/bin/env ruby -w
 # encoding: UTF-8
 #
-# = WorkingHours.rb -- The TaskJuggler III Project Management Software
+# = Journal.rb -- The TaskJuggler III Project Management Software
 #
-# Copyright (c) 2006, 2007, 2008, 2009 by Chris Schlaeger <cs@kde.org>
+# Copyright (c) 2006, 2007, 2008, 2009, 2010 by Chris Schlaeger <cs@kde.org>
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of version 2 of the GNU General Public License as
@@ -12,31 +12,253 @@
 
 class TaskJuggler
 
+  # A JournalEntry stores some RichText strings to describe a status or a
+  # property of the project at a certain point in time. Additionally, the
+  # entry can contain a reference to a Resource as author and an alert level.
+  # The text is structured in 3 different elements, a headline, a short
+  # summary and a longer text segment. The headline is mandatory, the
+  # summary and details sections are optional.
   class JournalEntry
 
-    attr_reader :date, :headline, :property
-    attr_accessor :intro, :more
+    attr_reader :date, :headline, :property, :sourceFileInfo
+    attr_accessor :author, :summary, :details, :alertLevel
 
-    def initialize(journal, date, headline, property)
+    # Create a new JournalEntry object.
+    def initialize(journal, date, headline, property, sourceFileInfo = nil)
+      # A reference to the Journal object this entry belongs to.
       @journal = journal
-      @journal.addEntry(self)
+      # The date of the entry.
       @date = date
+      # A very short description. Should not be longer than about 40
+      # characters.
       @headline = headline
+      # A reference to a PropertyTreeNode object.
       @property = property
-      @intro = nil
-      @more = nil
+      # Source file location of this entry of type SourceFileInfo
+      @sourceFileInfo = sourceFileInfo
+      # A reference to a Resource.
+      @author = nil
+      # An introductory or summarizing RichText paragraph.
+      @summary = nil
+      # A RichText of arbitrary length.
+      @details = nil
+      # The alert level.
+      @alertLevel = 0
+
+      # Add the new entry to the journal.
+      @journal.addEntry(self)
+    end
+
+    # Just for debugging
+    def to_s # :nodoc:
+      @headline
     end
 
   end
 
-  class Journal
+  # The JournalEntryList is an Array with a twist. Before any data retrieval
+  # function is called, the list of JournalEntry objects will be sorted by
+  # date. This is a utility class only. Use Journal to store a journal.
+  class JournalEntryList
 
     def initialize
       @entries = []
+      @sorted = false
+    end
+
+    # Return the number of entries.
+    def count
+      @entries.length
+    end
+
+    # Add a new JournalEntry to the list. The list will be marked as unsorted.
+    def <<(entry)
+      @entries << entry
+      @sorted = false
+    end
+
+    # Add a list of JournalEntry objects to the existing list. The list will
+    # be marked unsorted.
+    def +(list)
+      @entries + list
     end
 
+    # Return the _index_-th entry.
+    def[](index)
+      sort
+      @entries[index]
+    end
+
+    # The well known iterator. The list will be sorted first.
+    def each
+      sort
+      @entries.each do |entry|
+        yield entry
+      end
+    end
+
+    # Like Array::include?
+    def include?(entry)
+      @entries.include?(entry)
+    end
+
+    # Returns the last elements (by date) if date is nil or the last elements
+    # right before the given _date_. If there are multiple entries with
+    # exactly the same date, all are returned. Otherwise the result Array will
+    # only contain one element. In case no matching entry is found, the Array
+    # will be empty.
+    def last(date = nil)
+      result = []
+      sort
+      # If we have no date, return the latest entry.
+      return [ @entries.last ] unless date
+
+      @entries.reverse_each do |e|
+        if result.empty?
+          result << e if e.date <= date
+        elsif result.first.date == e.date
+          result << e
+        else
+          break
+        end
+      end
+      result
+    end
+
+    private
+
+    # Sort the list of entries. First by ascending by date, than by alertLevel
+    # and finally by PropertyTreeNode sequence number.
+    def sort
+      return if @sorted
+
+      @entries.sort! { |a, b| a.date != b.date ?
+                              a.date <=> b.date :
+                              (a.alertLevel != b.alertLevel ?
+                               a.alertLevel <=> b.alertLevel :
+                               a.property.sequenceNo <=>
+                               b.property.sequenceNo) }
+      @sorted = true
+    end
+
+  end
+
+  # A Journal is a list of JournalEntry objects. It provides methods to add
+  # JournalEntry objects and retrieve specific entries or other processed
+  # information.
+  class Journal
+
+    # Create a new Journal object.
+    def initialize
+      # This list holds all entries.
+      @entries = JournalEntryList.new
+      # This hash holds a list of entries for each property.
+      @propertyToEntries = {}
+    end
+
+    # Add a new JournalEntry to the Journal.
     def addEntry(entry)
+      return if @entries.include?(entry)
       @entries << entry
+
+      return if entry.property.nil?
+
+      unless @propertyToEntries.include?(entry.property)
+        @propertyToEntries[entry.property] = JournalEntryList.new
+      end
+      @propertyToEntries[entry.property] << entry
+    end
+
+    def entries(startDate = nil, endDate = nil, property = nil,
+                alertLevel = nil)
+      list = []
+      @entries.each do |entry|
+        if (startDate.nil? || startDate <= entry.date) &&
+           (endDate.nil? || endDate >= entry.date) &&
+           (property.nil? || property == entry.property ||
+                             entry.property.isChildOf?(property)) ||
+           (alertLevel.nil? || alertLevel == entry.alertLevel)
+          list << entry
+        end
+      end
+      list
+    end
+
+    # Determine the alert level for the given _property_ at the given _date_.
+    # If the property does not have any JournalEntry objects or they are out
+    # of date compared to the child properties, the level is computed based on
+    # the highest level of the children.
+    def alertLevel(date, property)
+      maxLevel = 0
+      # Gather all the current (as of the specified _date_) JournalEntry
+      # objects for the property and than find the highest level.
+      currentEntriesR(date, property).each do |e|
+        maxLevel = e.alertLevel if maxLevel < e.alertLevel
+      end
+      maxLevel
+    end
+
+    # This function returns a list of entries that have all the exact same
+    # date and are the last entries before the deadline _date_. Only messages
+    # with at least the required alert level _minLevel_ are returned. Messages
+    # with alert level _minLevel_ must not be older than _minDate_.
+    def currentEntries(date, property, minLevel, minDate)
+      pEntries = @propertyToEntries[property] ?
+                 @propertyToEntries[property].last(date) : []
+      # Remove entries below the minium alert level or before the timeout
+      # date.
+      pEntries.delete_if { |e| e.alertLevel < minLevel  || e.headline.empty? ||
+                               (e.alertLevel == minLevel && e.date < minDate) }
+
+      return [] if pEntries.empty?
+
+      # Check parents for a more important or more up-to-date message.
+      p = property.parent
+      while p do
+        ppEntries = @propertyToEntries[p] ?
+                    @propertyToEntries[p].last(date) : []
+
+        # A parent has a more up-to-date message.
+        if !ppEntries.empty? && ppEntries.first.date >= pEntries.first.date
+          return []
+        end
+
+        p = p.parent
+      end
+
+      pEntries
+    end
+
+    # This function recursively traverses a tree of PropertyTreeNode objects
+    # from bottom to top. It returns the last entries before _date_ for each
+    # property unless there is a property in the sub-tree specified by the
+    # root _property_ with more up-to-date entries. The result is a
+    # JournalEntryList.
+    def currentEntriesR(date, property)
+      # See if this property has any current JournalEntry objects.
+      pEntries = @propertyToEntries[property] ?
+                 @propertyToEntries[property].last(date) : []
+
+      entries = JournalEntryList.new
+      latestDate = nil
+      # Now gather all current entries of the child properties and find the
+      # date that is closest to and right before the given _date_.
+      property.children.each do |p|
+        currentEntriesR(date, p).each do |e|
+          latestDate = e.date if latestDate.nil? || e.date > latestDate
+          entries << e
+        end
+      end
+      # If no child property has a more current JournalEntry than this
+      # property and this property has JournalEntry objects, than those are
+      # taken.
+      if !pEntries.empty? && (latestDate.nil? ||
+                              pEntries.first.date >= latestDate)
+        entries = JournalEntryList.new
+        entries += pEntries
+      end
+      # Otherwise return the list provided by the childen.
+      entries
     end
 
   end