mhc 1.1.1 → 1.2.4

data/lib/mhc/builder.rb

@@ -11,6 +11,10 @@ module Mhc
       @config = Mhc::Config.create_from_file(config) if config.is_a?(String)
     end
 
+    def datastore
+      Mhc::DataStore.new(@config.general.repository)
+    end
+
     def calendar(calendar_name)
       calendar = @config.calendars[calendar_name]
       raise Mhc::ConfigurationError, "calendar '#{calendar_name}' not found" unless calendar
@@ -23,7 +27,7 @@ module Mhc
       when "lastnote"
         db = Mhc::LastNote::Client.new(calendar.name)
       when "mhc"
-        db = Mhc::Calendar.new(Mhc::DataStore.new(@config.general.repository), calendar.modifiers, &calendar.filter)
+        db = Mhc::Calendar.new(self.datastore, calendar.modifiers, &calendar.filter)
       end
       return db
     end

data/lib/mhc/caldav.rb

@@ -26,7 +26,7 @@ module Mhc
              D:propstat/D:prop/caldav:calendar-data
           ).map{|e| xmldoc.elements[e].text rescue nil}
 
-        info.href = URI.unescape(href)
+        info.href = URI.decode_www_form_component(href)
         info.uid = File.basename(info.href, ".ics")
         info.status = status
         info.content_type = content_type

data/lib/mhc/calendar.rb

@@ -19,9 +19,13 @@ module Mhc
       occurrences(date_range, &scope_block).map(&:event).uniq
     end
 
+    def tasks(&scope_block)
+      @datastore.entries(category: "todo")
+    end
+
     def occurrences(date_range, &scope_block)
       ocs = []
-      @datastore.entries(date_range).each do |event|
+      @datastore.entries(range: date_range).each do |event|
         event = decorate_event(event)
         event.occurrences(range:date_range).each do |oc|
           ocs << oc if in_scope?(oc, &scope_block)

data/lib/mhc/command/cache.rb

@@ -2,10 +2,11 @@ module Mhc
   module Command
     class Cache
 
-      def initialize(calendar)
-        calendar.events.each do |event|
-          range = event.range
-          puts "#{range.min.to_mhc_string},#{range.max.to_mhc_string},#{event.uid},#{event.subject}"
+      def initialize(datastore)
+        epoch = Date.new(1970, 1, 1)
+        puts"UID,MTIME,MIN,MAX,CATEGORIES,RECURRENCE,SUBJECT"
+        datastore.each_cache_entry do |uid, ent|
+          puts"#{ent.uid},#{ent.mtime},#{epoch + ent.range.min},#{epoch + ent.range.max},#{(ent.categories||[]).join(' ')},#{ent.recurrence},#{ent.subject}"
         end
       end
 

data/lib/mhc/command/completions.rb

@@ -95,7 +95,7 @@ module Mhc
         when "COMMAND"
           possible_commands
         when "RANGE"
-          "(today tomorrow thismonth nextmonth)"
+          "(all today tomorrow thismonth nextmonth)"
         when /^NUM/
           "_guard '[0-9]#' 'Number'"
         else

data/lib/mhc/command/init.rb

@@ -1,3 +1,5 @@
+require "fileutils"
+
 module Mhc
   module Command
     class Init

data/lib/mhc/converter.rb

@@ -44,8 +44,9 @@ module Mhc
 
       def to_emacs_string(str)
         # 1. quote " and \
-        # 2. surround by "
-        '"' + str.to_s.toutf8.gsub(/[\"\\]/, '\\\\\&') + '"'
+        # 2. LF => \n
+        # 3. surround by "
+        '"' + str.to_s.toutf8.gsub(/[\"\\]/, '\\\\\&').gsub("\n", "\\n") + '"'
       end
 
       def to_emacs_plist(hash)

data/lib/mhc/datastore.rb

@@ -11,9 +11,9 @@ module Mhc
       @cache   = Cache.new(File.expand_path("status/cache/events.pstore", @basedir))
     end
 
-    def entries(date_range = nil)
-      if date_range
-        int_range = date_range.min.absolute_from_epoch .. date_range.max.absolute_from_epoch
+    def entries(range: nil, category: nil, recurrence: nil)
+      if range
+        int_range = range.min.absolute_from_epoch .. range.max.absolute_from_epoch
       end
 
       Enumerator.new do |yielder|
@@ -23,13 +23,18 @@ module Mhc
 
           Dir.chdir(dir) do
             Dir.foreach(".") do |ent|
-              parse_mhcc(ent).each {|ev| yielder << ev} if /\.mhcc$/ =~ ent
+              parse_mhcc(ent).each {|ev|
+                next if category   && !ev.in_category?(category)
+                next if recurrence && !ev.in_recurrence?(recurrence)
+                yielder << ev
+              } if /\.mhcc$/ =~ ent
               next unless /\.mhc$/ =~ ent
               uid = $`
               cache_entry = @cache.lookup(uid, ent)
-              if !date_range || cache_entry.involved?(int_range)
-                yielder << Event.parse_file(File.expand_path(ent))
-              end
+              next if range      && !cache_entry.in_range?(int_range)
+              next if category   && !cache_entry.in_category?(category)
+              next if recurrence && !cache_entry.in_recurrence?(recurrence)
+              yielder << Event.parse_file(File.expand_path(ent))
             end
           end
         end
@@ -78,6 +83,13 @@ module Mhc
       end
     end
 
+    # dump cache entry for debug usage
+    def each_cache_entry
+      @cache.each do |uid, ent|
+        yield uid, ent
+      end
+    end
+
     ################################################################
     private
 
@@ -105,11 +117,21 @@ module Mhc
     class Cache
       require 'pstore'
 
+      VERSION = "1"
+
       def initialize(cache_filename)
         @pstore = PStore.new(cache_filename)
         load
       end
 
+      # dump cache entry for debug usage
+      def each
+        load unless @db
+        @db.each do |uid, ent|
+          yield uid, ent
+        end
+      end
+
       def lookup(uid, filename)
         unless c = get(uid) and File.mtime(filename).to_i <= c.mtime
           c = CacheEntry.new(filename)
@@ -122,6 +144,7 @@ module Mhc
         return self unless @dirty
         @pstore.transaction do
           @pstore["root"] = @db
+          @pstore["version"] = VERSION
         end
         @dirty = false
       end
@@ -139,7 +162,7 @@ module Mhc
 
       def load
         @pstore.transaction do
-          @db = @pstore["root"] || {}
+          @db = (@pstore["version"] == VERSION) && @pstore["root"] || {}
         end
         @dirty = false
       end
@@ -147,18 +170,34 @@ module Mhc
     end # class Cache
 
     class CacheEntry
-      attr_reader :mtime, :range
+      attr_reader :mtime, :uid, :subject, :location, :categories, :recurrence, :mission, :range
 
       def initialize(filename)
-        @mtime, event = File.mtime(filename).to_i, Event.parse_file(filename)
-        @range = event.range.min.absolute_from_epoch ..
-                 event.range.max.absolute_from_epoch
+        @mtime = File.mtime(filename).to_i
+
+        event = Event.parse_file(filename)
+        @uid            = event.uid.to_s
+        @subject        = event.subject.to_s
+        @location       = event.location.to_s
+        @categories     = event.categories.map {|c| c.to_s.downcase}
+        @recurrence     = event.recurrence_tag.to_s
+        @mission        = event.mission_tag.to_s
+        @range          = event.range.min.absolute_from_epoch ..
+                          event.range.max.absolute_from_epoch
+      end
+
+      def in_category?(category)
+        @categories.member?(category.downcase)
       end
 
-      def involved?(range)
+      def in_range?(range)
         range.min <= @range.max && @range.min <= range.max
       end
 
+      def in_recurrence?(recurrence)
+        @recurrence && @recurrence.downcase == recurrence.downcase
+      end
+
     end # class CacheEntry
 
   end # class DataStore

data/lib/mhc/date_enumerator.rb

@@ -257,8 +257,8 @@ module Mhc
       def each
         head, tail = range
         @range_list.each do |date_range|
-          break if date_range.first > tail
-          next  if date_range.last  < head
+          break if date_range.first.to_date > tail
+          next  if date_range.last.to_date  < head
           yield date_range
         end
       end

data/lib/mhc/event.rb

@@ -40,6 +40,10 @@ module Mhc
       return new.parse_file(path, lazy)
     end
 
+    def self.validate(string)
+      return new.validate(string)
+    end
+
     def parse_file(path, lazy = true)
       STDOUT.puts "parsing #{File.expand_path(path)}" if $MHC_DEBUG
 
@@ -325,6 +329,17 @@ module Mhc
       Mhc::Converter::Icalendar.new.to_ics_string(self)
     end
 
+    def validate(string)
+      header, _ = string.scrub.split(/\n\n/, 2)
+      errors = parse_header(header)
+
+      errors << ["no subject"] if subject.empty?
+      errors << ["no record-id"] if record_id.empty?
+      errors << ["no effective date specified"] if dates.empty? && recurrence_condition.empty?
+
+      return errors
+    end
+
     ################################################################
     private
 
@@ -348,35 +363,41 @@ module Mhc
 
     def parse_header(string)
       hash = {}
-      string.scan(/^x-sc-([^:]++):[ \t]*([^\n]*(?:\n[ \t]+[^\n]*)*)/i) do |key, val|
+      string.scrub.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
+      return parse_xsc_header(hash)
     end
 
     def parse_xsc_header(hash)
+      errors = []
       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"
+        next if val.empty?
+        begin
+          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 Mhc::PropertyValue::ParseError,
+                  "invalid X-SC-#{key.capitalize} header"
+          end
+        rescue Mhc::PropertyValue::ParseError => e
+          errors << [e, key]
         end
       end
-      return self
+      return errors
     end
 
     ## return: X-SC-* headers as a hash and

data/lib/mhc/formatter.rb

@@ -1,9 +1,8 @@
-# -*- coding: utf-8 -*-
-
 module Mhc
-  class FormatterNameError < StandardError; end
-
   class Formatter
+
+    class NameError < StandardError; end
+
     def self.build(formatter:, date_range:, **options)
       case formatter.to_sym
       when :text
@@ -15,323 +14,29 @@ module Mhc
       when :emacs
         Emacs.new(date_range: date_range, options:options)
       when :icalendar
-        ICalendar.new(date_range: date_range, options:options)
+        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)
       when :json
-        FullCalendar.new(date_range: date_range, options:options)
+        Json.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, is_holiday); ""; 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.any?{|e| e.holiday?})
-
-        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
+        raise Formatter::NameError.new("Unknown format: #{formatter} (#{formatter.class})")
       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
+    dir = File.dirname(__FILE__) + "/formatter"
 
-      def format_day_header(context, date, is_holiday)
-        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, is_holiday)
-        # (DAYS_FROM_EPOC . [year month day wday holiday-p (
-        format("(%d . [%d %d %d %d #{is_holiday ? 't' : '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
-
-    class FullCalendar < Base
-      require "json"
-
-      def format_body(context)
-        events = []
-        @occurrences.each do |oc|
-          class_name = []
-          class_name += oc.categories.map{|c| "mhc-category-#{c.to_s.downcase}"}
-          class_name << (oc.allday? ? "mhc-allday" : "mhc-time-range")
-
-          events << {
-            id:    oc.record_id,
-            allDay: oc.allday?,
-            title: oc.subject,
-            start: oc.dtstart.iso8601,
-            end:   oc.dtend.iso8601,
-            className: class_name
-          }
-        end
-        return events.to_json
-      end
-    end # class FullCalendar
+    autoload :Base,               "#{dir}/base.rb"
+    autoload :Emacs,              "#{dir}/emacs.rb"
+    autoload :Howm,               "#{dir}/howm.rb"
+    autoload :Icalendar,          "#{dir}/icalendar.rb"
+    autoload :Json,               "#{dir}/json.rb"
+    autoload :Mail,               "#{dir}/mail.rb"
+    autoload :OrgTable,           "#{dir}/org_table.rb"
+    autoload :SymbolicExpression, "#{dir}/symbolic_expression.rb"
+    autoload :Text,               "#{dir}/text.rb"
 
-  end # module Formatter
+  end # class Formatter
 end # module Mhc