mpp_reader 0.1.0

data/lib/mpp_reader/project.rb

@@ -0,0 +1,70 @@
+require "set"
+module MppReader
+  # A parsed MS Project file. Tasks and resources are read lazily on first
+  # access and memoized.
+  class Project
+    attr_reader :file_format, :application_name
+
+    def initialize(cfbf, comp_obj)
+      @cfbf = cfbf
+      @file_format = comp_obj.file_format
+      @application_name = comp_obj.application_name
+    end
+
+    def tasks
+      @tasks ||= reader.read_tasks.tap do |list|
+        reader.read_relations(list.to_h { |t| [t.unique_id, t] })
+      end
+    end
+
+    # Calendars carry the resource->calendar links, so reading them also
+    # fills Resource#calendar_unique_id; force that before handing out
+    # resources.
+    def resources
+      calendars
+      raw_resources
+    end
+
+    def assignments
+      @assignments ||= reader.read_assignments(tasks.map(&:unique_id).to_set)
+    end
+
+    def calendars
+      @calendars ||= begin
+        list = reader.read_calendars
+
+        # Derived calendars not used by any resource are leftovers MS
+        # Project does not show; prune them (as MPXJ does). Surviving
+        # resource links are mirrored onto the resources, and unnamed
+        # resource calendars inherit the resource name.
+        by_uid = raw_resources.to_h { |r| [r.unique_id, r] }
+        list.reject! do |cal|
+          cal.base_calendar_unique_id && by_uid[cal.resource_unique_id].nil?
+        end
+        list.each do |cal|
+          res = by_uid[cal.resource_unique_id]
+          next if res.nil?
+
+          res.calendar_unique_id = cal.unique_id
+          cal.name = res.name || "Unnamed Resource" if cal.name.nil? || cal.name.empty?
+        end
+      end
+    end
+
+    def task(unique_id) = tasks_by_uid[unique_id]
+
+    def calendar(unique_id) = calendars.find { |c| c.unique_id == unique_id }
+
+    def resource(unique_id) = resources_by_uid[unique_id]
+
+    private
+
+    def raw_resources = @resources ||= reader.read_resources
+
+    def reader = @reader ||= Reader14.new(@cfbf)
+
+    def tasks_by_uid = @tasks_by_uid ||= tasks.to_h { |t| [t.unique_id, t] }
+
+    def resources_by_uid = @resources_by_uid ||= resources.to_h { |r| [r.unique_id, r] }
+  end
+end

data/lib/mpp_reader/reader14.rb

@@ -0,0 +1,455 @@
+module MppReader
+  # Reads tasks and resources from an MPP14 project directory. Ported from
+  # MPXJ MPP14Reader (processTaskData/createTaskMap, processResourceData/
+  # createResourceMap).
+  class Reader14
+    PROJECT_DIR = "   114"
+
+    TASK_FIXED_META_ITEM_SIZE = 47
+    TASK_FIXED2_META_ITEM_SIZES = [92, 93, 94, 95, 96].freeze
+    RESOURCE_FIXED_META_ITEM_SIZE = 37
+
+    NULL_TASK_BLOCK_SIZE = 16
+    DELETED_FLAG = 0x02
+    KEEP_EXISTING_FLAG = 0x04
+
+    ASSIGNMENT_FIXED_META_ITEM_SIZE = 34
+    ASSIGNMENT_FIXED_DATA_ITEM_SIZE = 110
+    ASSIGNMENT_FIXED2_DATA_ITEM_SIZE = 48
+    NULL_RESOURCE_ID = -65_535
+
+    # Project 2016 task meta-data bit flags (MPXJ
+    # PROJECT2016_TASK_META_DATA_BIT_FLAGS / *_META_DATA2_BIT_FLAGS, core
+    # subset). Files written by older Project versions use slightly
+    # different locations; not yet ported (the corpus this gem targets is
+    # written by Project 2016+).
+    MILESTONE_FLAG = [10, 0x02].freeze    # in FixedMeta records
+    ACTIVE_FLAG = [8, 0x40].freeze        # in Fixed2Meta records
+    MANUALLY_SCHEDULED_FLAG = [8, 0x80].freeze
+
+    def initialize(cfbf)
+      @cfbf = cfbf
+      props_stream = stream("Props")
+      raise InvalidFormatError, "missing project Props stream" if props_stream.nil?
+
+      @props = Blocks::Props.new(props_stream)
+      @field_reader = FieldReader.new(@props)
+    end
+
+    def read_tasks
+      field_map = FieldMap.for_tasks(@props)
+      var_meta = Blocks::VarMeta.new(stream("TBkndTask/VarMeta"))
+      var_data = Blocks::Var2Data.new(var_meta, stream("TBkndTask/Var2Data"))
+      fixed_meta = Blocks::FixedMeta.new(stream("TBkndTask/FixedMeta"), TASK_FIXED_META_ITEM_SIZE)
+      fixed_data = Blocks::FixedData.new(fixed_meta, stream("TBkndTask/FixedData"),
+                                         max_expected_size: field_map.max_fixed_data_size(0))
+      fixed2_meta = Blocks::FixedMeta.with_derived_item_size(
+        stream("TBkndTask/Fixed2Meta"), TASK_FIXED2_META_ITEM_SIZES, fixed_data.item_count
+      )
+      fixed2_data = Blocks::FixedData.new(fixed2_meta, stream("TBkndTask/Fixed2Data"))
+
+      uid_offset = field_map[:unique_id]&.fixed_offset
+      raise InvalidFormatError, "task field map lacks a unique_id location" if uid_offset.nil?
+
+      task_map = build_task_map(field_map, fixed_meta, fixed_data, fixed2_data, var_meta, uid_offset)
+
+      tasks = task_map.sort.filter_map do |unique_id, index|
+        next if index.nil?
+
+        record = fixed_data[index]
+        next if record.nil? || record.bytesize == NULL_TASK_BLOCK_SIZE
+
+        build_task(field_map, unique_id, [record, fixed2_data[index]],
+                   fixed_meta[index], fixed2_meta[index], var_data)
+      end
+
+      link_hierarchy(tasks.sort_by! { |t| t.id || 0 })
+      tasks
+    end
+
+    def read_resources
+      field_map = FieldMap.for_resources(@props)
+      var_meta = Blocks::VarMeta.new(stream("TBkndRsc/VarMeta"))
+      var_data = Blocks::Var2Data.new(var_meta, stream("TBkndRsc/Var2Data"))
+      fixed_meta = Blocks::FixedMeta.new(stream("TBkndRsc/FixedMeta"), RESOURCE_FIXED_META_ITEM_SIZE)
+      fixed_data = Blocks::FixedData.new(fixed_meta, stream("TBkndRsc/FixedData"))
+
+      uid_offset = field_map[:unique_id]&.fixed_offset
+      raise InvalidFormatError, "resource field map lacks a unique_id location" if uid_offset.nil?
+
+      resource_map = build_resource_map(field_map, fixed_data, uid_offset)
+
+      var_meta.unique_ids.filter_map do |unique_id|
+        index = resource_map[unique_id]
+        next if index.nil?
+
+        build_resource(field_map, unique_id, [fixed_data[index]], var_data)
+      end
+    end
+
+    # Ported from MPXJ ResourceAssignmentFactory#process. task_uids gates
+    # assignments to known tasks (MPXJ skips assignments whose task is
+    # absent from the file).
+    def read_assignments(task_uids)
+      field_map = FieldMap.for_assignments(@props)
+      var_meta = Blocks::VarMeta.new(stream("TBkndAssn/VarMeta"))
+      var_data = Blocks::Var2Data.new(var_meta, stream("TBkndAssn/Var2Data"))
+      fixed_meta = Blocks::FixedMeta.new(stream("TBkndAssn/FixedMeta"), ASSIGNMENT_FIXED_META_ITEM_SIZE)
+      fixed_data = Blocks::FixedData.fixed_size(stream("TBkndAssn/FixedData"), ASSIGNMENT_FIXED_DATA_ITEM_SIZE)
+      fixed2_data = Blocks::FixedData.fixed_size(stream("TBkndAssn/Fixed2Data"), ASSIGNMENT_FIXED2_DATA_ITEM_SIZE)
+
+      uid_offset = field_map[:unique_id]&.fixed_offset
+      raise InvalidFormatError, "assignment field map lacks a unique_id location" if uid_offset.nil?
+
+      assignments = []
+      fixed_meta.item_count.times do |meta_index|
+        meta = fixed_meta[meta_index]
+        next if meta.nil? || meta.getbyte(0) != 0 # deleted
+
+        index = fixed_data.index_from_offset(meta.byteslice(4, 4).unpack1("V"))
+        next if index.nil?
+
+        record = fixed_data[index]
+        record = record.ljust(field_map.max_fixed_data_size(0), "\0") if record.bytesize < field_map.max_fixed_data_size(0)
+        unique_id = record.byteslice(uid_offset, 4).unpack1("l<")
+        next unless var_meta.entries?(unique_id)
+
+        assignment = build_assignment(field_map, unique_id, [record, fixed2_data[index]], var_data)
+        next unless task_uids.include?(assignment.task_unique_id)
+
+        assignments << assignment
+      end
+      assignments
+    end
+
+    # Reads predecessor links from TBkndCons and wires them into the given
+    # tasks (by unique id). Ported from MPXJ ConstraintFactory. Layout: uid
+    # u32@0, predecessor u32@4, successor u32@8, type u16@12; lag location
+    # depends on writer version (Project 2010 vs 2013+).
+    def read_relations(tasks_by_uid)
+      meta_stream = stream("TBkndCons/FixedMeta")
+      return if meta_stream.nil?
+
+      fixed_meta = Blocks::FixedMeta.new(meta_stream, 10)
+      fixed_data = Blocks::FixedData.meta_offsets_with_size(fixed_meta, stream("TBkndCons/FixedData"), 20)
+      project15 = application_version > 14
+      lag_offset = project15 ? 14 : 16
+      lag_units_offset = project15 ? 18 : 14
+
+      seen = {}
+      # NOTE: the header count, not the block-derived count - MS Project
+      # leaves stale link records past the header count (MPXJ iterates
+      # getItemCount() here, unlike for tasks).
+      [fixed_meta.header_item_count, fixed_meta.item_count].min.times do |index|
+        meta = fixed_meta[index]
+        next if meta.nil? || meta.byteslice(0, 2).unpack1("v") != 0 # deleted
+
+        data_index = fixed_data.index_from_offset(meta.byteslice(4, 4).unpack1("V"))
+        next if data_index.nil?
+
+        record = fixed_data[data_index]
+        next if record.nil? || record.bytesize < 14
+
+        predecessor_uid = record.byteslice(4, 4).unpack1("V")
+        successor_uid = record.byteslice(8, 4).unpack1("V")
+        # Links to the project summary task and self-links are not valid.
+        next if predecessor_uid.zero? || successor_uid.zero? || predecessor_uid == successor_uid
+
+        predecessor = tasks_by_uid[predecessor_uid]
+        successor = tasks_by_uid[successor_uid]
+        next if predecessor.nil? || successor.nil?
+
+        relation = Relation.new
+        relation.unique_id = record.byteslice(0, 4).unpack1("V")
+        relation.predecessor_task_unique_id = predecessor_uid
+        relation.successor_task_unique_id = successor_uid
+        relation.type = Relation::TYPES.fetch(record.byteslice(12, 2).unpack1("v"), :finish_start)
+        units = Decode.duration_units(record.byteslice(lag_units_offset, 2).to_s.unpack1("v").to_i)
+        lag = record.byteslice(lag_offset, 4).to_s.unpack1("l<")
+        relation.lag = lag.nil? ? nil : @field_reader.adjusted_duration(lag, units)
+
+        # Only one relation per (successor, predecessor, type, lag), as in
+        # MPXJ RelationContainer#addPredecessor.
+        next if seen[[successor_uid, predecessor_uid, relation.type, relation.lag]]
+
+        seen[[successor_uid, predecessor_uid, relation.type, relation.lag]] = true
+        successor.predecessors << relation
+        predecessor.successors << relation
+      end
+    end
+
+    # Reads calendars from TBkndCal (ported from MPXJ AbstractCalendarFactory
+    # and AbstractCalendarAndExceptionFactory; Project 2013+ record layout).
+    # Calendar var data: seven 60-byte day blocks then exception records.
+    def read_calendars
+      var_meta = Blocks::VarMeta.new(stream("TBkndCal/VarMeta"))
+      var_data = Blocks::Var2Data.new(var_meta, stream("TBkndCal/Var2Data"))
+      fixed_meta = Blocks::FixedMeta.new(stream("TBkndCal/FixedMeta"), 10)
+      fixed_data = Blocks::FixedData.new(fixed_meta, stream("TBkndCal/FixedData"), max_expected_size: 12)
+
+      default_data = @props[DEFAULT_CALENDAR_HOURS_KEY]
+      project15 = application_version > 14
+      id_offset = project15 ? 8 : 0
+      base_offset = project15 ? 0 : 4
+      resource_offset = project15 ? 4 : 8
+
+      calendars = {}
+      fixed_data.item_count.times do |index|
+        record = fixed_data[index]
+        next if record.nil? || record.bytesize < 8
+
+        offset = 0
+        while offset + 12 <= record.bytesize
+          unique_id = record.byteslice(offset + id_offset, 4).unpack1("V")
+          base_id = record.byteslice(offset + base_offset, 4).unpack1("l<")
+          resource_id = record.byteslice(offset + resource_offset, 4).unpack1("l<")
+          offset += 12
+          next if unique_id <= 0 || calendars.key?(unique_id)
+
+          data = var_data.bytes(unique_id, CALENDAR_DATA_KEY)
+          calendar = Calendar.new
+          calendar.unique_id = unique_id
+          is_base = base_id <= 0 || base_id == unique_id
+          # Only base calendars take their name from the file; derived
+          # (resource) calendar name entries are often stale, so MPXJ
+          # ignores them and names the calendar after its resource.
+          calendar.name = var_data.string(unique_id, CALENDAR_NAME_KEY) if is_base
+          calendar.base_calendar_unique_id = base_id unless is_base
+          # Derived (resource) calendars keep the link even for resource id
+          # 0 - the unnamed placeholder resource is a real, linkable entry.
+          calendar.resource_unique_id = resource_id if !is_base || resource_id.positive?
+          data = default_data if data.nil? && is_base
+          read_calendar_days(data, calendar, is_base)
+          read_calendar_exceptions(data, calendar)
+          calendars[unique_id] = calendar
+        end
+      end
+      calendars.values
+    end
+
+    private
+
+    CALENDAR_NAME_KEY = 1
+    CALENDAR_DATA_KEY = 8
+    DEFAULT_CALENDAR_HOURS_KEY = 37_753_736 # PropsKey.DEFAULT_CALENDAR_HOURS
+    CALENDAR_EXCEPTIONS_OFFSET = 420 # after seven 60-byte day blocks
+
+    # Standard week used when a base calendar leaves a day on "default":
+    # Monday-Friday 08:00-12:00 and 13:00-17:00.
+    DEFAULT_WORKING_DAYS = %i[monday tuesday wednesday thursday friday].freeze
+    DEFAULT_WORKING_HOURS = [[8 * 3600, 12 * 3600], [13 * 3600, 17 * 3600]].freeze
+
+    def read_calendar_days(data, calendar, is_base)
+      Calendar::DAY_NAMES.each_with_index do |day, index|
+        offset = 60 * index
+        default_flag = data.nil? ? 1 : data.byteslice(offset, 2).to_s.unpack1("v")
+        calendar.days[day] =
+          if default_flag == 1
+            if is_base
+              if DEFAULT_WORKING_DAYS.include?(day)
+                { type: :working, hours: DEFAULT_WORKING_HOURS.map(&:dup) }
+              else
+                { type: :non_working, hours: [] }
+              end
+            else
+              { type: :default, hours: [] }
+            end
+          else
+            hours = read_time_ranges(data, count_offset: offset + 2,
+                                     starts_at: offset + 8, durations_at: offset + 20)
+            { type: hours.empty? ? :non_working : :working, hours: hours }
+          end
+      end
+    end
+
+    def read_calendar_exceptions(data, calendar)
+      return if data.nil? || data.bytesize <= CALENDAR_EXCEPTIONS_OFFSET
+
+      offset = CALENDAR_EXCEPTIONS_OFFSET
+      count = data.byteslice(offset, 2).unpack1("v")
+      offset += 4
+      count.times do
+        break if offset + 92 > data.bytesize
+
+        hours = read_time_ranges(data, count_offset: offset + 14,
+                                 starts_at: offset + 20, durations_at: offset + 32)
+        name_length = data.byteslice(offset + 88, 4).unpack1("V")
+        name_length = ((name_length / 4) + 1) * 4 unless (name_length % 4).zero?
+        name = if name_length.zero?
+                 nil
+               else
+                 data.byteslice(offset + 92, name_length)
+                     .force_encoding(Encoding::UTF_16LE)
+                     .encode(Encoding::UTF_8, invalid: :replace, undef: :replace)
+                     .sub(/\0.*\z/m, "")
+               end
+        calendar.exceptions << {
+          from: Decode.date(data, offset),
+          to: Decode.date(data, offset + 2),
+          name: name,
+          hours: hours
+        }
+        offset += 92 + name_length
+      end
+    end
+
+    # Time ranges as stored in day blocks and exceptions: a u16 period
+    # count, u16 start times (tenths of a minute since midnight) and u16
+    # durations (tenths of a minute), returned as [start_sec, end_sec].
+    def read_time_ranges(data, count_offset:, starts_at:, durations_at:)
+      count = data.byteslice(count_offset, 2).to_s.unpack1("v").to_i
+      (0...count).filter_map do |i|
+        start_tenths = data.byteslice(starts_at + i * 2, 2).to_s.unpack1("v")
+        duration_tenths = data.byteslice(durations_at + i * 4, 2).to_s.unpack1("v")
+        next if start_tenths.nil? || duration_tenths.nil?
+
+        start_seconds = (start_tenths / 10) * 60
+        [start_seconds, start_seconds + duration_tenths * 6]
+      end
+    end
+
+    # Major version of the Project release that wrote the file, from the
+    # CompObj application name (e.g. "Microsoft.Project 16.0" -> 16).
+    def application_version
+      @application_version ||= @cfbf.stream("\x01CompObj")
+                                    .then { |s| CompObj.new(s).application_name }
+                                    .to_s[/(\d+)\.\d+\z/, 1].to_i
+    end
+
+    def build_assignment(field_map, unique_id, fixed_records, var_data)
+      read = ->(field) { @field_reader.read(field_map, field, unique_id, fixed_records, var_data) }
+      assignment = Assignment.new
+      assignment.unique_id = unique_id
+      assignment.task_unique_id = read.call(:task_unique_id)
+      assignment.resource_unique_id = read.call(:resource_unique_id)
+      assignment.resource_unique_id = nil if assignment.resource_unique_id == NULL_RESOURCE_ID
+      assignment.start = read.call(:start)
+      assignment.finish = read.call(:finish)
+      assignment.units = read.call(:assignment_units)
+      assignment.work = read.call(:work)
+      assignment.notes = read.call(:notes)
+      assignment
+    end
+
+    def stream(name) = @cfbf.stream("#{PROJECT_DIR}/#{name}")
+
+    # Ported from MPP14Reader#createTaskMap: the first three fixed items are
+    # not tasks; we work backwards because with duplicates the later
+    # occurrences are the correct ones; deleted and suspect records are
+    # filtered out.
+    def build_task_map(field_map, fixed_meta, fixed_data, fixed2_data, var_meta, uid_offset)
+      task_map = {}
+      max_size = field_map.max_fixed_data_size(0)
+
+      (fixed_meta.item_count - 1).downto(3) do |index|
+        record = fixed_data[index]
+        next if record.nil? || fixed2_data[index].nil?
+
+        flags = fixed_meta[index].byteslice(0, 4).to_s.unpack1("V").to_i
+        if (flags & DELETED_FLAG) != 0
+          # Deleted tasks store only a short unique id; remember it so a
+          # phantom duplicate later in the block is not resurrected.
+          unique_id = record.byteslice(0, 2).to_s.unpack1("v")
+          task_map[unique_id] = nil unless task_map.key?(unique_id)
+        elsif record.bytesize == NULL_TASK_BLOCK_SIZE
+          unique_id = record.byteslice(0, 4).to_s.unpack1("V")
+          task_map[unique_id] = index unless task_map.key?(unique_id)
+        elsif max_size.zero? || (record.bytesize * 100) / max_size > 75
+          unique_id = record.byteslice(uid_offset, 4).to_s.unpack1("V")
+          next unless unique_id
+
+          if (!task_map.key?(unique_id) || var_meta.entries?(unique_id)) &&
+             (!task_map.key?(unique_id) || (flags & KEEP_EXISTING_FLAG).zero?)
+            task_map[unique_id] = index
+          end
+        end
+      end
+
+      task_map
+    end
+
+    # Ported from MPP14Reader#createResourceMap.
+    def build_resource_map(field_map, fixed_data, uid_offset)
+      resource_map = {}
+      max_size = field_map.max_fixed_data_size(0)
+
+      fixed_data.item_count.times do |index|
+        record = fixed_data[index]
+        next if record.nil? || record.bytesize < max_size
+
+        unique_id = record.byteslice(uid_offset, 2).to_s.unpack1("v")
+        resource_map[unique_id] = index unless resource_map.key?(unique_id)
+      end
+
+      resource_map
+    end
+
+    def build_task(field_map, unique_id, fixed_records, meta_record, meta2_record, var_data)
+      read = ->(field) { @field_reader.read(field_map, field, unique_id, fixed_records, var_data) }
+      task = Task.new
+      task.unique_id = unique_id
+      task.id = read.call(:id)
+      task.name = read.call(:name)
+      task.start = read.call(:start)
+      task.finish = read.call(:finish)
+      task.duration = read.call(:duration)
+      task.outline_level = read.call(:outline_level)
+      task.percent_complete = read.call(:percent_complete)
+      task.notes = read.call(:notes)
+      task.milestone = meta_bit?(meta_record, MILESTONE_FLAG)
+      task.active = meta_bit?(meta2_record, ACTIVE_FLAG)
+      task.manual = meta_bit?(meta2_record, MANUALLY_SCHEDULED_FLAG)
+
+      # In MPP14 the start/finish/duration slots hold manually-scheduled
+      # values; auto-scheduled tasks carry theirs in the scheduled_* fields
+      # (ported from MPP14Reader#processTaskData).
+      apply_scheduled_fallbacks(task, read)
+      task
+    end
+
+    def apply_scheduled_fallbacks(task, read)
+      scheduled_start = read.call(:scheduled_start)
+      scheduled_finish = read.call(:scheduled_finish)
+      scheduled_duration = read.call(:scheduled_duration)
+      auto = !task.manual
+      task.start = scheduled_start if task.start.nil? || (scheduled_start && auto)
+      task.finish = scheduled_finish if task.finish.nil? || (scheduled_finish && auto)
+      task.duration = scheduled_duration if task.duration.nil? || (scheduled_duration && auto)
+      # The duration attribute is unreliable for manually scheduled tasks;
+      # MS Project displays the manual duration value, so prefer it.
+      task.duration = read.call(:manual_duration) if task.manual
+    end
+
+    def build_resource(field_map, unique_id, fixed_records, var_data)
+      read = ->(field) { @field_reader.read(field_map, field, unique_id, fixed_records, var_data) }
+      resource = Resource.new
+      resource.unique_id = unique_id
+      resource.id = read.call(:id)
+      resource.name = read.call(:name)
+      resource.notes = read.call(:notes)
+      resource
+    end
+
+    def meta_bit?(meta_record, (offset, mask))
+      byte = meta_record && meta_record.getbyte(offset)
+      !byte.nil? && (byte & mask) != 0
+    end
+
+    # Builds parent/child links from outline levels over the id-ordered
+    # task list (MPXJ updateStructure does the equivalent).
+    def link_hierarchy(tasks)
+      stack = []
+      tasks.each do |task|
+        level = task.outline_level
+        next if level.nil?
+
+        stack.pop while stack.any? && stack.last.outline_level >= level
+        if (parent = stack.last)
+          task.parent = parent
+          parent.children << task
+        end
+        stack << task
+      end
+    end
+  end
+end

data/lib/mpp_reader/relation.rb

@@ -0,0 +1,11 @@
+module MppReader
+  # A dependency link between two tasks. type is one of :finish_start,
+  # :start_start, :finish_finish, :start_finish; lag is a Duration.
+  class Relation
+    TYPES = { 0 => :finish_finish, 1 => :finish_start,
+              2 => :start_finish, 3 => :start_start }.freeze
+
+    attr_accessor :unique_id, :predecessor_task_unique_id,
+                  :successor_task_unique_id, :type, :lag
+  end
+end

data/lib/mpp_reader/resource.rb

@@ -0,0 +1,5 @@
+module MppReader
+  class Resource
+    attr_accessor :unique_id, :id, :name, :calendar_unique_id, :notes
+  end
+end

data/lib/mpp_reader/rtf_text.rb

@@ -0,0 +1,92 @@
+module MppReader
+  # Minimal RTF-to-plain-text conversion for notes fields. MS Project
+  # stores notes as simple RTF (font/color tables, \par breaks, hex and
+  # unicode escapes); anything not starting with {\rtf is returned as-is.
+  module RtfText
+    # Destination groups whose text is not document content.
+    SKIP_GROUPS = %w[fonttbl colortbl stylesheet info pict object header
+                     footer generator].freeze
+
+    module_function
+
+    def strip(text)
+      return text if text.nil? || text.empty? || !text.start_with?("{\\rtf")
+
+      out = +""
+      pos = 0
+      bytes = text.b
+      # Each entry mirrors the group nesting: true while inside a skipped
+      # destination group.
+      skip_stack = [false]
+      pending_unicode_skip = 0
+
+      while pos < bytes.bytesize
+        ch = bytes[pos]
+        case ch
+        when "{"
+          skip_stack.push(skip_stack.last)
+          pos += 1
+        when "}"
+          skip_stack.pop if skip_stack.size > 1
+          pos += 1
+        when "\\"
+          pos = control(bytes, pos, out, skip_stack) { pending_unicode_skip = _1 }
+        else
+          if pending_unicode_skip.positive?
+            pending_unicode_skip -= 1
+          elsif !skip_stack.last && ch != "\r" && ch != "\n"
+            out << ch
+          end
+          pos += 1
+        end
+      end
+      out.sub!(/\n\z/, "") # formal RTF always ends with one extra \par
+      out.force_encoding(Encoding::UTF_8).valid_encoding? ? out.force_encoding(Encoding::UTF_8) : out
+    end
+
+    def control(bytes, pos, out, skip_stack)
+      suppressed = skip_stack.last
+      rest = bytes.byteslice(pos + 1, 12).to_s
+
+      case rest
+      when /\A([{}\\])/ # escaped literal
+        out << Regexp.last_match(1) unless suppressed
+        yield 0
+        pos + 2
+      when /\A'([0-9a-fA-F]{2})/ # hex escape, Windows-1252
+        unless suppressed
+          out << Regexp.last_match(1).to_i(16).chr
+                       .force_encoding(Encoding::WINDOWS_1252)
+                       .encode(Encoding::UTF_8, invalid: :replace, undef: :replace).b
+        end
+        yield 0
+        pos + 4
+      when /\Au(-?\d+)/ # unicode escape; following char is the fallback
+        out << [Regexp.last_match(1).to_i].pack("U").b unless suppressed
+        yield 1
+        pos + 2 + Regexp.last_match(1).length
+      when /\A([a-z]+)(-?\d*) ?/i # control word
+        word = Regexp.last_match(1)
+        consumed = 1 + Regexp.last_match(0).length
+        if SKIP_GROUPS.include?(word)
+          skip_stack[-1] = true
+        elsif !suppressed
+          case word
+          when "par", "line" then out << "\n"
+          when "tab" then out << "\t"
+          end
+        end
+        yield 0
+        pos + consumed
+      when /\A\*/ # \* marks an optional destination group - skip it
+        skip_stack[-1] = true
+        yield 0
+        pos + 2
+      else
+        yield 0
+        pos + 1
+      end
+    end
+    private_class_method :control
+  end
+end

data/lib/mpp_reader/task.rb

@@ -0,0 +1,21 @@
+module MppReader
+  class Task
+    attr_accessor :unique_id, :id, :name, :start, :finish, :duration,
+                  :outline_level, :percent_complete, :milestone, :parent,
+                  :active, :manual, :notes
+    attr_reader :children, :predecessors, :successors
+
+    def initialize
+      @children = []
+      @predecessors = []
+      @successors = []
+    end
+
+    def milestone? = !!@milestone
+
+    # A summary task is one with subtasks (MS Project derives this the
+    # same way).
+    def summary = !@children.empty?
+    alias summary? summary
+  end
+end

data/lib/mpp_reader/version.rb

@@ -0,0 +1,3 @@
+module MppReader
+  VERSION = "0.1.0"
+end