mhc 1.0.0

data/lib/mhc/event.rb

@@ -0,0 +1,396 @@
+# -*- coding: utf-8 -*-
+
+### event.rb
+##
+## Author:  Yoshinari Nomura <nom@quickhack.net>
+##
+## Created: 1999/07/16
+## Revised: $Date: 2008-10-08 03:22:37 $
+##
+
+module Mhc
+  # Mhc::Event defines a simple representation of calendar events.
+  # It looks like a RFC822 message with some X- headers to represent event properties:
+  # * X-SC-Subject:
+  # * X-SC-Location:
+  # * X-SC-Day:
+  # * X-SC-Time:
+  # * X-SC-Category:
+  # * X-SC-Recurrence-Tag:
+  # * X-SC-Mission-Tag:
+  # * X-SC-Cond:
+  # * X-SC-Duration:
+  # * X-SC-Alarm:
+  # * X-SC-Record-Id:
+  # * X-SC-Sequence:
+  #
+  class Event
+    ################################################################
+    ## initializers
+
+    def initialize
+      clear
+    end
+
+    def self.parse(string)
+      return new.parse(string)
+    end
+
+    def self.parse_file(path, lazy = true)
+      return new.parse_file(path, lazy)
+    end
+
+    def parse_file(path, lazy = true)
+      STDOUT.puts "parsing #{File.expand_path(path)}" if $MHC_DEBUG
+
+      clear
+      header, body = nil, nil
+
+      File.open(path, "r") do |file|
+        header = file.gets("\n\n")
+        body   = file.gets(nil) unless lazy
+      end
+
+      @path = path if lazy
+      parse_header(header)
+      self.description = body if body
+      return self
+    end
+
+    def parse(string)
+      clear
+      header, body = string.scrub.split(/\n\n/, 2)
+
+      parse_header(header)
+      self.description = body
+      return self
+    end
+
+    def self.new_from_ics(ics_string)
+      Mhc::Converter::IcalendarImporter.parse_ics(ics_string)
+    end
+
+    def path
+      return @path
+    end
+    ################################################################
+    ## access methods to each property.
+
+    ## alarm
+    def alarm
+      return @alarm ||= Mhc::PropertyValue::Period.new
+    end
+
+    def alarm=(string)
+      return @alarm = alarm.parse(string)
+    end
+
+    ## category
+    def categories
+      return @categories ||=
+        Mhc::PropertyValue::List.new(Mhc::PropertyValue::Text)
+    end
+
+    def categories=(string)
+      return @categories = categories.parse(string)
+    end
+
+    ## description
+    def description
+      unless @description
+        @description = Mhc::PropertyValue::Text.new
+
+        if lazy? && File.file?(@path)
+          File.open(@path, "r") do |file|
+            file.gets("\n\n") # discard header.
+            @description.parse(file.gets(nil))
+          end
+        end
+      end
+      return @description
+    end
+    alias_method :body, :description
+
+    def description=(string)
+      return @description = description.parse(string)
+    end
+
+    ## location
+    def location
+      return @location ||= Mhc::PropertyValue::Text.new
+    end
+
+    def location=(string)
+      return @location = location.parse(string)
+    end
+
+    ## record-id
+    def record_id
+      return @record_id ||= Mhc::PropertyValue::Text.new
+    end
+
+    def record_id=(string)
+      return @record_id = record_id.parse(string)
+    end
+
+    def uid
+      record_id.to_s
+    end
+
+    ## subject
+    def subject
+      return @subject ||= Mhc::PropertyValue::Text.new
+    end
+
+    def subject=(string)
+      return @subject = subject.parse(string)
+    end
+
+    ## date list is a list of date range
+    def dates
+      return @dates ||=
+        Mhc::PropertyValue::List.new(Mhc::PropertyValue::Range.new(Mhc::PropertyValue::Date.new))
+    end
+
+    def dates=(string)
+      string = string.split.select {|s| /^!/ !~ s}.join(" ")
+      return @dates = dates.parse(string)
+    end
+
+    def obsolete_dates=(string)
+      # STDERR.print "Obsolete X-SC-Date: header.\n"
+      if /(\d+)\s+([A-Z][a-z][a-z])\s+(\d+)\s+(\d\d:\d\d)/ =~ string
+        dd, mm, yy, hhmm = $1.to_i, $2, $3.to_i + 1900, $4
+        mm = ("JanFebMarAprMayJunJulAugSepOctNovDec".index(mm)) / 3 + 1
+        @dates = dates.parse("%04d%02d%02d" % [yy, mm, dd])
+        if hhmm and hhmm != '00:00'
+          @time_range = time_range.parse(hhmm)
+        end
+      end
+    end
+
+    def exceptions
+      return @exceptions ||=
+        Mhc::PropertyValue::List.new(Mhc::PropertyValue::Range.new(Mhc::PropertyValue::Date.new, "!"))
+    end
+
+    def exceptions=(string)
+      string = string.split.select {|s| /^!/ =~ s}.map{|s| s[1..-1]}.join(" ")
+      return @exceptions = exceptions.parse(string)
+    end
+
+    ## time
+    def time_range
+      return @time_range ||=
+        Mhc::PropertyValue::Range.new(Mhc::PropertyValue::Time)
+    end
+
+    def time_range=(string)
+      @time_range = time_range.parse(string)
+      return @time_range
+    end
+
+    ## duration
+    def duration
+      return @duration ||=
+        Mhc::PropertyValue::Range.new(Mhc::PropertyValue::Date)
+    end
+
+    def duration=(string)
+      return @duration = duration.parse(string)
+    end
+
+    ## recurrence condition
+    def recurrence_condition
+      return @cond ||= Mhc::PropertyValue::RecurrenceCondition.new
+    end
+
+    def recurrence_condition=(string)
+      return @cond = recurrence_condition.parse(string)
+    end
+
+    ## recurrence-tag
+    def recurrence_tag
+      return @recurrence_tag ||= Mhc::PropertyValue::Text.new
+    end
+
+    def recurrence_tag=(string)
+      return @recurrence_tag = recurrence_tag.parse(string)
+    end
+
+    ## mission-tag
+    def mission_tag
+      return @mission_tag ||= Mhc::PropertyValue::Text.new
+    end
+
+    def mission_tag=(string)
+      return @mission_tag = mission_tag.parse(string)
+    end
+
+    ## sequence
+    def sequence
+      return @sequence ||= Mhc::PropertyValue::Integer.new.parse("0")
+    end
+
+    def sequence=(string)
+      return @sequence = sequence.parse(string.to_s)
+    end
+
+    def occurrences(range:nil)
+      Mhc::OccurrenceEnumerator.new(self, dates, exceptions, recurrence_condition, duration, range)
+    end
+
+    def etag
+      return "#{uid.to_s}-#{sequence.to_s}"
+    end
+
+    def recurring?
+      not recurrence_condition.empty?
+    end
+
+    def allday?
+      time_range.blank?
+    end
+
+    def range
+      min0, max0 = Mhc::PropertyValue::Date.parse("19000101"),
+                   Mhc::PropertyValue::Date.parse("99991231")
+
+      if recurring?
+        min, max = min0, max0
+      else
+        min, max = dates.min, dates.max
+        min = min.respond_to?(:first) ? min.first : min0
+        max = max.respond_to?(:last)  ? max.last  : max0
+      end
+      min = duration.first if duration.first && duration.first > min
+      max = duration.last  if duration.last  && duration.last  < max
+
+      return min..max if min && max && min <= max
+
+      STDERR.puts "Warn: invalid date range? #{self.uid}"
+      return min0..max0
+    end
+
+    ################################################################
+    ### dump
+
+    def dump
+      non_xsc_header = @non_xsc_header.to_s.sub(/\n+\z/, "")
+      non_xsc_header += "\n" if non_xsc_header != ""
+
+      body = description.to_mhc_string
+      body += "\n" if body != "" && body !~ /\n\z/
+
+      return dump_header + non_xsc_header + "\n" + body
+    end
+
+    def dump_header
+      return "X-SC-Subject: #{subject.to_mhc_string}\n"      +
+        "X-SC-Location: #{location.to_mhc_string}\n"         +
+        "X-SC-Day: " + "#{dates.to_mhc_string} #{exceptions.to_mhc_string}".strip + "\n" +
+        "X-SC-Time: #{time_range.to_mhc_string}\n"           +
+        "X-SC-Category: #{categories.to_mhc_string}\n"       +
+        "X-SC-Mission-Tag: #{mission_tag.to_mhc_string}\n"   +
+        "X-SC-Recurrence-Tag: #{recurrence_tag.to_mhc_string}\n"       +
+        "X-SC-Cond: #{recurrence_condition.to_mhc_string}\n" +
+        "X-SC-Duration: #{duration.to_mhc_string}\n"         +
+        "X-SC-Alarm: #{alarm.to_mhc_string}\n"               +
+        "X-SC-Record-Id: #{record_id.to_mhc_string}\n"       +
+        "X-SC-Sequence: #{sequence.to_mhc_string}\n"
+    end
+
+    alias_method :to_mhc_string, :dump
+
+    ################################################################
+    ### converter
+
+    def to_ics
+      Mhc::Converter::Icalendar.new.to_ics(self)
+    end
+
+    def to_icalendar
+      Mhc::Converter::Icalendar.new.to_icalendar(self)
+    end
+
+    def to_ics_string
+      Mhc::Converter::Icalendar.new.to_ics_string(self)
+    end
+
+    ################################################################
+    private
+
+    def lazy?
+      return !@path.nil?
+    end
+
+    def clear
+      @alarm, @categories, @description, @location = [nil]*4
+      @record_id, @subject = [nil]*2
+      @dates, @exceptions, @time_range, @duration, @cond, @oc = [nil]*6
+      @non_xsc_header, @path = [nil]*2
+      return self
+    end
+
+    def parse_header_full(string)
+      xsc, @non_xsc_header = separate_header(string)
+      parse_xsc_header(xsc)
+      return self
+    end
+
+    def parse_header(string)
+      hash = {}
+      string.scan(/^x-sc-([^:]++):[ \t]*([^\n]*(?:\n[ \t]+[^\n]*)*)/i) do |key, val|
+        hash[key.downcase] = val.gsub("\n", " ").strip
+      end
+      parse_xsc_header(hash)
+      return self
+    end
+
+    def parse_xsc_header(hash)
+      hash.each do |key, val|
+        case key
+        when "day"       ; self.dates      = val ; self.exceptions = val
+        when "date"      ; self.obsolete_dates = val
+        when "subject"   ; self.subject    = val
+        when "location"  ; self.location   = val
+        when "time"      ; self.time_range = val
+        when "duration"  ; self.duration   = val
+        when "category"  ; self.categories = val
+        when "mission-tag"  ; self.mission_tag = val
+        when "recurrence-tag"  ; self.recurrence_tag = val
+        when "cond"      ; self.recurrence_condition  = val
+        when "alarm"     ; self.alarm      = val
+        when "record-id" ; self.record_id  = val
+        when "sequence"  ; self.sequence   = val
+        else
+          # raise NotImplementedError, "X-SC-#{key.capitalize}"
+          # STDERR.print "Obsolete: X-SC-#{key.capitalize}\n"
+        end
+      end
+      return self
+    end
+
+    ## return: X-SC-* headers as a hash and
+    ##         non-X-SC-* headers as one string.
+    def separate_header(header)
+      xsc, non_xsc, xsc_key = {}, "", nil
+
+      header.split("\n").each do |line|
+        if line =~ /^X-SC-([^:]+):(.*)/i
+          xsc_key = $1.downcase
+          xsc[xsc_key] = $2.to_s.strip
+
+        elsif line =~ /^\s/ && xsc_key
+          xsc[xsc_key] += " " + line
+
+        else
+          xsc_key = nil
+          non_xsc += line + "\n"
+        end
+      end
+      return [xsc, non_xsc]
+    end
+
+  end # class Event
+end # module Mhc

data/lib/mhc/formatter.rb

@@ -0,0 +1,312 @@
+# -*- coding: utf-8 -*-
+
+module Mhc
+  class FormatterNameError < StandardError; end
+
+  class Formatter
+    def self.build(formatter:, date_range:, **options)
+      case formatter.to_sym
+      when :text
+        Text.new(date_range: date_range, options:options)
+      when :mail
+        Mail.new(date_range: date_range, options:options)
+      when :orgtable
+        OrgTable.new(date_range: date_range, options:options)
+      when :emacs
+        Emacs.new(date_range: date_range, options:options)
+      when :icalendar
+        ICalendar.new(date_range: date_range, options:options)
+      when :calfw
+        SymbolicExpression.new(date_range: date_range, options:options)
+      when :howm
+        Howm.new(date_range: date_range, options:options)
+      else
+        raise FormatterNameError.new("Unknown format: #{formatter} (#{formatter.class})")
+      end
+    end
+
+    class Base
+      def initialize(date_range:, options:nil)
+        @date_range = date_range
+        @options = options
+        @occurrences, @events, @items = [], [], {}
+        @event_hash = {}
+      end
+
+      def <<(occurrence)
+        event = occurrence.event
+        @occurrences << occurrence
+        @events << event unless @event_hash[event]
+        @event_hash[event] = true
+
+        @items[occurrence.date] ||= []
+        @items[occurrence.date] << occurrence
+      end
+
+      def to_s
+        context = {:items => @items}.merge(@options)
+        prepare(context)
+        string = format_header(context) + format_body(context) + format_footer(context)
+        teardown(context)
+        return string
+      end
+
+      ################################################################
+      private
+
+      def prepare(context);  end
+      def teardown(context); end
+
+      def pad_empty_dates
+        @date_range.each do |date|
+          @items[date] ||= []
+        end
+      end
+
+      def expand_multiple_days_occurrences
+        @occurrences.each do |oc|
+          next if oc.oneday?
+          ((oc.first + 1) .. oc.last).each do |date|
+            @items[date] ||= []
+            @items[date] << oc
+          end
+        end
+      end
+
+      def format_header(context); ""; end
+      def format_footer(context); ""; end
+      def format_day_header(context, date); ""; end
+      def format_day_footer(context, date); ""; end
+
+      def format_body(context)
+        context[:number] = 0
+        @items.keys.sort.map{|date| format_day(context, date, @items[date]) }.join
+      end
+
+      def format_day(context, date, items)
+        string = format_day_header(context, date)
+
+        items = sort_items_in_day(items)
+        items.each_with_index do |occurrence, count|
+          context[:number] += 1
+          context[:number_in_day] = count + 1
+          string += format_item(context, date, occurrence)
+        end
+
+        return string + format_day_footer(context, date)
+      end
+
+      def format_item(context, date, item)
+        format("%s%-11s %s%s\n",
+               format_item_header(context, date, item),
+               item.time_range.to_mhc_string.toutf8,
+               item.subject.to_s.toutf8,
+               append(enclose(item.location)).toutf8
+               )
+      end
+
+      def format_item_header(context, date, item)
+        if context[:number_in_day] == 1
+          date.strftime("%Y/%m/%d %a ")
+        else
+          " " * 15
+        end
+      end
+
+      ################################################################
+      ## helpers
+      def append(item, separator = " ")
+        return "" if item.to_s.empty?
+        return separator + item.to_s
+      end
+
+      def prepend(item, separator = " ")
+        return "" if item.to_s.empty?
+        return item.to_s + separator
+      end
+
+      def enclose(item, bracket = "[]")
+        return "" if item.to_s.empty?
+        return bracket[0] + item.to_s + bracket[1]
+      end
+
+      # sort occurrences in a day
+      # make sure all-day occurrences are prior to others
+      def sort_items_in_day(items)
+        items.sort do |a,b|
+          sign_a = a.allday? ? 0 : 1
+          sign_b = b.allday? ? 0 : 1
+
+          if sign_a != sign_b
+            sign_a - sign_b
+          else
+            a <=> b
+          end
+        end
+      end
+    end
+
+    class Text < Base
+      def prepare(context)
+        expand_multiple_days_occurrences
+      end
+    end # class Text
+
+    class Mail < Base
+      private
+
+      def format_header(context)
+        mail_address = context[:mailto].to_s
+        subject = format("MHC schedule report (%s--%s)", *context[:items].keys.minmax)
+        header =  "To: #{mail_address}\n"
+        header += "From: #{append(mail_address, "secretary-of-")}\n"
+        header += "Subject: #{subject}\n"
+        header += "Content-Type: Text/Plain; charset=utf-8\n"
+        header += "Content-Transfer-Encoding: 8bit\n"
+        header += "\n"
+        header += format("* mhc %s--%s\n", *context[:items].keys.minmax)
+      end
+    end # class Mail
+
+    class SymbolicExpression < Base
+      private
+
+      def format_header(context);  "(";   end
+      def format_footer(context);  "(periods #{@periods}))\n"; end
+
+      def format_day_header(context, date)
+        date.strftime("((%2m %2d %Y) . (")
+      end
+
+      def format_item(context, date, item)
+        unless item.oneday?
+          format_multiple_days_item(context, date, item)
+          return ""
+        end
+        format_item_line(item)
+      end
+
+      def format_multiple_days_item(context, date, item)
+        @periods ||= ""
+        @periods +=  item.first.strftime("((%2m %2d %Y) ") +
+                    item.last.strftime(" (%2m %2d %Y) ") +
+          format_item_line(item) + ') '
+      end
+
+      def format_day_footer(context, date); ")) "; end
+
+      def format_item_line(item)
+        '"' +
+          format("%s%s%s",
+                 prepend(item.time_range.first.to_s).toutf8,
+                 item.subject.to_s.toutf8,
+                 append(enclose(item.location)).toutf8).gsub(/[\"\\]/, '\\\\\&') +
+          '" '
+
+      end
+    end
+
+    class Emacs < SymbolicExpression
+      private
+
+      def prepare(context)
+        expand_multiple_days_occurrences
+      end
+
+      def format_header(context);  "(";   end
+      def format_footer(context);  ")\n"; end
+
+      def format_day_header(context, date)
+        # (DAYS_FROM_EPOC . [year month day wday holiday-p (
+        format("(%d . [%d %d %d %d nil (", date.absolute_from_epoch, date.year, date.month, date.day, date.wday)
+      end
+
+      def format_item(context, date, item)
+        # [ RECORD CONDITION SUBJECT LOCATION (TIMEB . TIMEE) ALARM CATEGORIES PRIORITY REGION RECURRENCE-TAG]
+        format("[(%s . [%s nil nil]) nil %s %s (%s . %s) %s (%s) nil nil %s]",
+               elisp_string(item.path.to_s),
+               elisp_string(item.uid.to_s),
+               elisp_string(item.subject),
+               elisp_string(item.location),
+               (item.time_range.first ? (item.time_range.first.to_i / 60) : "nil"),
+               (item.time_range.last  ? (item.time_range.last.to_i  / 60) : "nil"),
+               elisp_string(item.alarm.to_s),
+               item.categories.map{|c| elisp_string(c.to_s.downcase)}.join(" "),
+               elisp_string(item.recurrence_tag))
+      end
+
+      def format_day_footer(context, date)
+        ")]) "
+      end
+
+      def elisp_string(string)
+        '"' + string.to_s.toutf8.gsub(/[\"\\]/, '\\\\\&') + '"'
+      end
+    end
+
+    class ICalendar < Base
+      private
+
+      def format_body(context)
+        ical = RiCal.Calendar
+        ical.prodid = Mhc::PRODID
+        @events.each do |event|
+          ical.events << event.to_icalendar
+        end
+        return ical.to_s
+      end
+    end
+
+    class OrgTable < Base
+      private
+
+      def format_header(context)
+        format("* mhc %s--%s\n", *context[:items].keys.minmax)
+      end
+
+      def format_item(context, date, item)
+        # | No | Mission | Recurrence | Subject | Path | Date |
+        format("  | %4d | %s | %s | %s | %s | [%04d-%02d-%02d%s] |\n",
+               context[:number],
+               item.mission_tag.to_s.toutf8,
+               item.recurrence_tag.to_s.toutf8,
+               item.subject.to_s.toutf8,
+               item.path.to_s,
+               date.year, date.month, date.mday,
+               append(item.time_range.to_s))
+      end
+    end # class OrgTable
+
+    class Howm < Base
+      private
+
+      def format_header(context)
+        format("= mhc %s--%s\n", *context[:items].keys.minmax)
+      end
+
+      def format_item(context, date, item)
+        string = format("[%04d-%02d-%02d %5s]%1s %s\n",
+                        date.year, date.month, date.mday,
+                        item.time_range.first.to_s,
+                        mark_todo(item.categories.to_mhc_string),
+                        item.subject)
+        if item.description.to_s != ""
+          string += item.description.to_s.gsub(/^/, " ") + "\n"
+        end
+        return string
+      end
+
+      def mark_todo(category)
+        case category
+        when /done/i
+          "."
+        when /todo/i
+          "+"
+        else
+          "@"
+        end
+      end
+    end # class Howm
+
+  end # module Formatter
+end # module Mhc